Add --no-inline option support to convert inline rules to regular non-terminal rules

Author: ydah

lib/lrama/grammar.rb

@@ -256,7 +256,9 @@ def epilogue=(epilogue)
 
     # @rbs () -> void
     def prepare
-      unless @no_inline
+      if @no_inline
+        convert_inline_rules_to_regular_rules
+      else
         validate_inline_rules
         resolve_inline_rules
       end
@@ -462,6 +464,40 @@ def resolve_inline_rules
       end
     end
 
+    # Convert inline rules to regular rules when --no-inline is specified.
+    # This allows inline rules to be treated as ordinary non-terminal rules.
+    # Only non-parameterized inline rules can be converted (rules with parameters
+    # require instantiation and cannot be converted to simple rules).
+    #
+    # @rbs () -> void
+    def convert_inline_rules_to_regular_rules
+      inline_rules = @parameterized_resolver.rules.select { |rule| rule.inline? && rule.required_parameters_count == 0 }
+      return if inline_rules.empty?
+
+      converted_names = Set.new #: Set[String]
+
+      inline_rules.each do |inline_rule|
+        lhs_token = Lexer::Token::Ident.new(s_value: inline_rule.name)
+        converted_names << inline_rule.name
+
+        inline_rule.rhs.each do |rhs|
+          rule_builder = RuleBuilder.new(@rule_counter, @midrule_action_counter, @parameterized_resolver, lhs_tag: inline_rule.tag)
+          rule_builder.lhs = lhs_token
+          rhs.symbols.each { |sym| rule_builder.add_rhs(sym) }
+          rule_builder.precedence_sym = rhs.precedence_sym
+          rule_builder.user_code = rhs.user_code
+          rule_builder.complete_input
+          @rule_builders << rule_builder
+        end
+      end
+
+      # Remove converted inline rules from the resolver so that find_inline
+      # won't find them, allowing rules that reference them to be built normally
+      @parameterized_resolver.rules = @parameterized_resolver.rules.reject do |rule|
+        rule.inline? && converted_names.include?(rule.name)
+      end
+    end
+
     # @rbs () -> void
     def normalize_rules
       add_accept_rule

sig/generated/lrama/grammar.rbs

@@ -3312,6 +3312,35 @@
           expect(times_rule.token_code.s_value).to include("$$ = _inline_2($1, $3)")
         end
       end
+
+      context 'when no_inline is true' do
+        let(:path) { "inlining/basic.y" }
+        let(:grammar) do
+          grammar = Lrama::Parser.new(y, path).parse
+          stdlib_grammar = Lrama::Parser.new(File.read("lib/lrama/grammar/stdlib.y"), "lib/lrama/grammar/stdlib.y").parse
+          grammar.prepend_parameterized_rules(stdlib_grammar.parameterized_rules)
+          grammar.no_inline = true
+          grammar.prepare
+          grammar.validate!
+          grammar
+        end
+
+        it "treats inline rules as regular non-terminal rules" do
+          nterm_names = grammar.nterms.map { |n| n.id.s_value }
+          expect(nterm_names).to include("op")
+          expect(nterm_names).to include("other_op")
+
+          expression_rules = grammar.rules.select { |r| r.lhs.id.s_value == "expression" }
+          op_referenced = expression_rules.any? do |r|
+            r.rhs.any? { |s| s.id.s_value == "op" }
+          end
+          other_op_referenced = expression_rules.any? do |r|
+            r.rhs.any? { |s| s.id.s_value == "other_op" }
+          end
+          expect(op_referenced).to be true
+          expect(other_op_referenced).to be true
+        end
+      end
     end
 
     it "; for rules is optional" do