Merge pull request #755 from ydah/use-%empty-warning

Add support warning [-Wempty-rule]

Author: ydah

lib/lrama/warnings.rb

@@ -2,6 +2,7 @@
 # frozen_string_literal: true
 
 require_relative 'warnings/conflicts'
+require_relative 'warnings/implicit_empty'
 require_relative 'warnings/redefined_rules'
 require_relative 'warnings/required'
 require_relative 'warnings/useless_precedence'
@@ -11,6 +12,7 @@ class Warnings
     # @rbs (Logger logger, bool warnings) -> void
     def initialize(logger, warnings)
       @conflicts = Conflicts.new(logger, warnings)
+      @implicit_empty = ImplicitEmpty.new(logger, warnings)
       @redefined_rules = RedefinedRules.new(logger, warnings)
       @required = Required.new(logger, warnings)
       @useless_precedence = UselessPrecedence.new(logger, warnings)
@@ -19,6 +21,7 @@ def initialize(logger, warnings)
     # @rbs (Lrama::Grammar grammar, Lrama::States states) -> void
     def warn(grammar, states)
       @conflicts.warn(states)
+      @implicit_empty.warn(grammar)
       @redefined_rules.warn(grammar)
       @required.warn(grammar)
       @useless_precedence.warn(grammar, states)

lib/lrama/warnings/implicit_empty.rb

@@ -0,0 +1,29 @@
+# rbs_inline: enabled
+# frozen_string_literal: true
+
+module Lrama
+  class Warnings
+    # Warning rationale: Empty rules are easily overlooked and ambiguous
+    # - Empty alternatives like `rule: | "token";` can be missed during code reading
+    # - Difficult to distinguish between intentional empty rules vs. omissions
+    # - Explicit marking with %empty directive comment improves clarity
+    class ImplicitEmpty
+      # @rbs (Lrama::Logger logger, bool warnings) -> void
+      def initialize(logger, warnings)
+        @logger = logger
+        @warnings = warnings
+      end
+
+      # @rbs (Lrama::Grammar grammar) -> void
+      def warn(grammar)
+        return unless @warnings
+
+        grammar.rule_builders.each do |builder|
+          if builder.rhs.empty?
+            @logger.warn("warning: empty rule without %empty")
+          end
+        end
+      end
+    end
+  end
+end

sig/generated/lrama/warnings/implicit_empty.rbs

@@ -0,0 +1,17 @@
+# Generated from lib/lrama/warnings/implicit_empty.rb with RBS::Inline
+
+module Lrama
+  class Warnings
+    # Warning rationale: Empty rules are easily overlooked and ambiguous
+    # - Empty alternatives like `rule: | "token";` can be missed during code reading
+    # - Difficult to distinguish between intentional empty rules vs. omissions
+    # - Explicit marking with %empty directive comment improves clarity
+    class ImplicitEmpty
+      # @rbs (Lrama::Logger logger, bool warnings) -> void
+      def initialize: (Lrama::Logger logger, bool warnings) -> void
+
+      # @rbs (Lrama::Grammar grammar) -> void
+      def warn: (Lrama::Grammar grammar) -> void
+    end
+  end
+end

spec/lrama/warnings/implicit_empty_spec.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+RSpec.describe Lrama::Warnings::ImplicitEmpty do
+  describe "#warn" do
+    let(:y) do
+      <<~STR
+        %{
+        // Prologue
+        %}
+        %union {
+            int i;
+        }
+        %token <i> tNUMBER
+        %%
+        program: /* empty */
+                | tNUMBER
+                ;
+      STR
+    end
+
+    context "when warnings true" do
+      it "has warns for parameterized rule redefined" do
+        grammar = Lrama::Parser.new(y, "states/empty.y").parse
+        grammar.prepare
+        grammar.validate!
+        states = Lrama::States.new(grammar, Lrama::Tracer.new(Lrama::Logger.new))
+        states.compute
+        logger = Lrama::Logger.new
+        allow(logger).to receive(:warn)
+        Lrama::Warnings.new(logger, true).warn(grammar, states)
+        expect(logger).to have_received(:warn).with("warning: empty rule without %empty")
+      end
+    end
+
+    context "when warnings false" do
+      it "has not warns for parameterized rule redefined" do
+        grammar = Lrama::Parser.new(y, "states/empty.y").parse
+        grammar.prepare
+        grammar.validate!
+        states = Lrama::States.new(grammar, Lrama::Tracer.new(Lrama::Logger.new))
+        states.compute
+        logger = Lrama::Logger.new
+        allow(logger).to receive(:warn)
+        Lrama::Warnings.new(logger, false).warn(grammar, states)
+        expect(logger).not_to have_received(:warn).with("warning: empty rule without %empty")
+      end
+    end
+  end
+end