lrama 0.7.0 → 0.7.1

data/lib/lrama/tracer/actions.rb

@@ -0,0 +1,22 @@
+# rbs_inline: enabled
+# frozen_string_literal: true
+
+module Lrama
+  class Tracer
+    class Actions
+      # @rbs (IO io, ?actions: bool, **bool options) -> void
+      def initialize(io, actions: false, **options)
+        @io = io
+        @actions = actions
+      end
+
+      # @rbs (Lrama::Grammar grammar) -> void
+      def trace(grammar)
+        return unless @actions
+
+        @io << "Grammar rules with actions:" << "\n"
+        grammar.rules.each { |rule| @io << rule.with_actions << "\n" }
+      end
+    end
+  end
+end

data/lib/lrama/tracer/closure.rb

@@ -0,0 +1,30 @@
+# rbs_inline: enabled
+# frozen_string_literal: true
+
+module Lrama
+  class Tracer
+    class Closure
+      # @rbs (IO io, ?automaton: bool, ?closure: bool, **bool) -> void
+      def initialize(io, automaton: false, closure: false, **_)
+        @io = io
+        @closure = automaton || closure
+      end
+
+      # @rbs (Lrama::State state) -> void
+      def trace(state)
+        return unless @closure
+
+        @io << "Closure: input" << "\n"
+        state.kernels.each do |item|
+          @io << "  #{item.display_rest}" << "\n"
+        end
+        @io << "\n\n"
+        @io << "Closure: output" << "\n"
+        state.items.each do |item|
+          @io << "  #{item.display_rest}" << "\n"
+        end
+        @io << "\n\n"
+      end
+    end
+  end
+end

data/lib/lrama/tracer/duration.rb

@@ -0,0 +1,38 @@
+# rbs_inline: enabled
+# frozen_string_literal: true
+
+module Lrama
+  class Tracer
+    module Duration
+      # TODO: rbs-inline 0.11.0 doesn't support instance variables.
+      #       Move these type declarations above instance variable definitions, once it's supported.
+      #       see: https://github.com/soutaro/rbs-inline/pull/149
+      #
+      # @rbs!
+      #   @_report_duration_enabled: bool
+
+      # @rbs () -> void
+      def self.enable
+        @_report_duration_enabled = true
+      end
+
+      # @rbs () -> bool
+      def self.enabled?
+        !!@_report_duration_enabled
+      end
+
+      # @rbs [T] (_ToS message) { -> T } -> T
+      def report_duration(message)
+        time1 = Time.now.to_f
+        result = yield
+        time2 = Time.now.to_f
+
+        if Duration.enabled?
+          STDERR.puts sprintf("%s %10.5f s", message, time2 - time1)
+        end
+
+        return result
+      end
+    end
+  end
+end

data/lib/lrama/tracer/only_explicit_rules.rb

@@ -0,0 +1,24 @@
+# rbs_inline: enabled
+# frozen_string_literal: true
+
+module Lrama
+  class Tracer
+    class OnlyExplicitRules
+      # @rbs (IO io, ?only_explicit: bool, **bool) -> void
+      def initialize(io, only_explicit: false, **_)
+        @io = io
+        @only_explicit = only_explicit
+      end
+
+      # @rbs (Lrama::Grammar grammar) -> void
+      def trace(grammar)
+        return unless @only_explicit
+
+        @io << "Grammar rules:" << "\n"
+        grammar.rules.each do |rule|
+          @io << rule.display_name_without_action << "\n" if rule.lhs.first_set.any?
+        end
+      end
+    end
+  end
+end

data/lib/lrama/tracer/rules.rb

@@ -0,0 +1,23 @@
+# rbs_inline: enabled
+# frozen_string_literal: true
+
+module Lrama
+  class Tracer
+    class Rules
+      # @rbs (IO io, ?rules: bool, ?only_explicit: bool, **bool) -> void
+      def initialize(io, rules: false, only_explicit: false, **_)
+        @io = io
+        @rules = rules
+        @only_explicit = only_explicit
+      end
+
+      # @rbs (Lrama::Grammar grammar) -> void
+      def trace(grammar)
+        return if !@rules || @only_explicit
+
+        @io << "Grammar rules:" << "\n"
+        grammar.rules.each { |rule| @io << rule.display_name << "\n" }
+      end
+    end
+  end
+end

data/lib/lrama/tracer/state.rb

@@ -0,0 +1,33 @@
+# rbs_inline: enabled
+# frozen_string_literal: true
+
+module Lrama
+  class Tracer
+    class State
+      # @rbs (IO io, ?automaton: bool, ?closure: bool, **bool) -> void
+      def initialize(io, automaton: false, closure: false, **_)
+        @io = io
+        @state = automaton || closure
+      end
+
+      # @rbs (Lrama::State state) -> void
+      def trace(state)
+        return unless @state
+
+        # Bison 3.8.2 renders "(reached by "end-of-input")" for State 0 but
+        # I think it is not correct...
+        previous = state.kernels.first.previous_sym
+        @io << "Processing state #{state.id} (reached by #{previous.display_name})" << "\n"
+      end
+
+      # @rbs (Integer state_count, Lrama::State state) -> void
+      def trace_list_append(state_count, state)
+        return unless @state
+
+        previous = state.kernels.first.previous_sym
+        @io << sprintf("state_list_append (state = %d, symbol = %d (%s))",
+                        state_count, previous.number, previous.display_name) << "\n"
+      end
+    end
+  end
+end

data/lib/lrama/tracer.rb

@@ -0,0 +1,51 @@
+# rbs_inline: enabled
+# frozen_string_literal: true
+
+require_relative "tracer/actions"
+require_relative "tracer/closure"
+require_relative "tracer/duration"
+require_relative "tracer/only_explicit_rules"
+require_relative "tracer/rules"
+require_relative "tracer/state"
+
+module Lrama
+  class Tracer
+    # @rbs (IO io, **bool options) -> void
+    def initialize(io, **options)
+      @io = io
+      @options = options
+      @only_explicit_rules = OnlyExplicitRules.new(io, **options)
+      @rules = Rules.new(io, **options)
+      @actions = Actions.new(io, **options)
+      @closure = Closure.new(io, **options)
+      @state = State.new(io, **options)
+    end
+
+    # @rbs (Lrama::Grammar grammar) -> void
+    def trace(grammar)
+      @only_explicit_rules.trace(grammar)
+      @rules.trace(grammar)
+      @actions.trace(grammar)
+    end
+
+    # @rbs (Lrama::State state) -> void
+    def trace_closure(state)
+      @closure.trace(state)
+    end
+
+    # @rbs (Lrama::State state) -> void
+    def trace_state(state)
+      @state.trace(state)
+    end
+
+    # @rbs (Integer state_count, Lrama::State state) -> void
+    def trace_state_list_append(state_count, state)
+      @state.trace_list_append(state_count, state)
+    end
+
+    # @rbs () -> void
+    def enable_duration
+      Duration.enable if @options[:time]
+    end
+  end
+end

data/lib/lrama/version.rb

@@ -1,5 +1,6 @@
+# rbs_inline: enabled
 # frozen_string_literal: true
 
 module Lrama
-  VERSION = "0.7.0".freeze
+  VERSION = "0.7.1".freeze #: String
 end

data/lib/lrama/warnings/conflicts.rb

@@ -0,0 +1,27 @@
+# rbs_inline: enabled
+# frozen_string_literal: true
+
+module Lrama
+  class Warnings
+    class Conflicts
+      # @rbs (Lrama::Logger logger, bool warnings) -> void
+      def initialize(logger, warnings)
+        @logger = logger
+        @warnings = warnings
+      end
+
+      # @rbs (Lrama::States states) -> void
+      def warn(states)
+        return unless @warnings
+
+        if states.sr_conflicts_count != 0
+          @logger.warn("shift/reduce conflicts: #{states.sr_conflicts_count} found")
+        end
+
+        if states.rr_conflicts_count != 0
+          @logger.warn("reduce/reduce conflicts: #{states.rr_conflicts_count} found")
+        end
+      end
+    end
+  end
+end

data/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

data/lib/lrama/warnings/name_conflicts.rb

@@ -0,0 +1,63 @@
+# rbs_inline: enabled
+# frozen_string_literal: true
+
+module Lrama
+  class Warnings
+    # Warning rationale: Parameterized rule names conflicting with symbol names
+    # - When a %rule name is identical to a terminal or non-terminal symbol name,
+    #   it reduces grammar readability and may cause unintended behavior
+    # - Detecting these conflicts helps improve grammar definition quality
+    class NameConflicts
+      # @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
+        return if grammar.parameterized_rules.empty?
+
+        symbol_names = collect_symbol_names(grammar)
+        check_conflicts(grammar.parameterized_rules, symbol_names)
+      end
+
+      private
+
+      # @rbs (Lrama::Grammar grammar) -> Set[String]
+      def collect_symbol_names(grammar)
+        symbol_names = Set.new
+
+        collect_term_names(grammar.terms, symbol_names)
+        collect_nterm_names(grammar.nterms, symbol_names)
+
+        symbol_names
+      end
+
+      # @rbs (Array[untyped] terms, Set[String] symbol_names) -> void
+      def collect_term_names(terms, symbol_names)
+        terms.each do |term|
+          symbol_names.add(term.id.s_value)
+          symbol_names.add(term.alias_name) if term.alias_name
+        end
+      end
+
+      # @rbs (Array[untyped] nterms, Set[String] symbol_names) -> void
+      def collect_nterm_names(nterms, symbol_names)
+        nterms.each do |nterm|
+          symbol_names.add(nterm.id.s_value)
+        end
+      end
+
+      # @rbs (Array[untyped] parameterized_rules, Set[String] symbol_names) -> void
+      def check_conflicts(parameterized_rules, symbol_names)
+        parameterized_rules.each do |param_rule|
+          next unless symbol_names.include?(param_rule.name)
+
+          @logger.warn("warning: parameterized rule name \"#{param_rule.name}\" conflicts with symbol name")
+        end
+      end
+    end
+  end
+end

data/lib/lrama/warnings/redefined_rules.rb

@@ -0,0 +1,23 @@
+# rbs_inline: enabled
+# frozen_string_literal: true
+
+module Lrama
+  class Warnings
+    class RedefinedRules
+      # @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.parameterized_resolver.redefined_rules.each do |rule|
+          @logger.warn("parameterized rule redefined: #{rule}")
+        end
+      end
+    end
+  end
+end

data/lib/lrama/warnings/required.rb

@@ -0,0 +1,23 @@
+# rbs_inline: enabled
+# frozen_string_literal: true
+
+module Lrama
+  class Warnings
+    class Required
+      # @rbs (Lrama::Logger logger, bool warnings) -> void
+      def initialize(logger, warnings = false, **_)
+        @logger = logger
+        @warnings = warnings
+      end
+
+      # @rbs (Lrama::Grammar grammar) -> void
+      def warn(grammar)
+        return unless @warnings
+
+        if grammar.required
+          @logger.warn("currently, %require is simply valid as a grammar but does nothing")
+        end
+      end
+    end
+  end
+end

data/lib/lrama/warnings/useless_precedence.rb

@@ -0,0 +1,25 @@
+# rbs_inline: enabled
+# frozen_string_literal: true
+
+module Lrama
+  class Warnings
+    class UselessPrecedence
+      # @rbs (Lrama::Logger logger, bool warnings) -> void
+      def initialize(logger, warnings)
+        @logger = logger
+        @warnings = warnings
+      end
+
+      # @rbs (Lrama::Grammar grammar, Lrama::States states) -> void
+      def warn(grammar, states)
+        return unless @warnings
+
+        grammar.precedences.each do |precedence|
+          unless precedence.used_by?
+            @logger.warn("Precedence #{precedence.s_value} (line: #{precedence.lineno}) is defined but not used in any rule.")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lrama/warnings.rb

@@ -0,0 +1,33 @@
+# rbs_inline: enabled
+# frozen_string_literal: true
+
+require_relative 'warnings/conflicts'
+require_relative 'warnings/implicit_empty'
+require_relative 'warnings/name_conflicts'
+require_relative 'warnings/redefined_rules'
+require_relative 'warnings/required'
+require_relative 'warnings/useless_precedence'
+
+module Lrama
+  class Warnings
+    # @rbs (Logger logger, bool warnings) -> void
+    def initialize(logger, warnings)
+      @conflicts = Conflicts.new(logger, warnings)
+      @implicit_empty = ImplicitEmpty.new(logger, warnings)
+      @name_conflicts = NameConflicts.new(logger, warnings)
+      @redefined_rules = RedefinedRules.new(logger, warnings)
+      @required = Required.new(logger, warnings)
+      @useless_precedence = UselessPrecedence.new(logger, warnings)
+    end
+
+    # @rbs (Lrama::Grammar grammar, Lrama::States states) -> void
+    def warn(grammar, states)
+      @conflicts.warn(states)
+      @implicit_empty.warn(grammar)
+      @name_conflicts.warn(grammar)
+      @redefined_rules.warn(grammar)
+      @required.warn(grammar)
+      @useless_precedence.warn(grammar, states)
+    end
+  end
+end

data/lib/lrama.rb

@@ -4,19 +4,19 @@ require_relative "lrama/bitmap"
 require_relative "lrama/command"
 require_relative "lrama/context"
 require_relative "lrama/counterexamples"
-require_relative "lrama/diagnostics"
+require_relative "lrama/diagram"
 require_relative "lrama/digraph"
+require_relative "lrama/erb"
 require_relative "lrama/grammar"
-require_relative "lrama/grammar_validator"
 require_relative "lrama/lexer"
 require_relative "lrama/logger"
 require_relative "lrama/option_parser"
 require_relative "lrama/options"
 require_relative "lrama/output"
 require_relative "lrama/parser"
-require_relative "lrama/report"
+require_relative "lrama/reporter"
 require_relative "lrama/state"
 require_relative "lrama/states"
-require_relative "lrama/states_reporter"
-require_relative "lrama/trace_reporter"
+require_relative "lrama/tracer"
 require_relative "lrama/version"
+require_relative "lrama/warnings"