lrama 0.7.0 → 0.7.1

data/sig/generated/lrama/state/resolved_conflict.rbs

@@ -0,0 +1,38 @@
+# Generated from lib/lrama/state/resolved_conflict.rb with RBS::Inline
+
+module Lrama
+  class State
+    # * state: A state on which the conflct is resolved
+    # * symbol: A symbol under discussion
+    # * reduce: A reduce under discussion
+    # * which: For which a conflict is resolved. :shift, :reduce or :error (for nonassociative)
+    # * resolved_by_precedence: If the conflict is resolved by precedence definition or not
+    class ResolvedConflict
+      type which_enum = :reduce | :shift | :error
+
+      attr_reader state: State
+
+      attr_reader symbol: Grammar::Symbol
+
+      attr_reader reduce: State::Action::Reduce
+
+      attr_reader which: which_enum
+
+      attr_reader resolved_by_precedence: bool
+
+      # @rbs (state: State, symbol: Grammar::Symbol, reduce: State::Action::Reduce, which: which_enum, resolved_by_precedence: bool) -> void
+      def initialize: (state: State, symbol: Grammar::Symbol, reduce: State::Action::Reduce, which: which_enum, resolved_by_precedence: bool) -> void
+
+      # @rbs () -> (::String | bot)
+      def report_message: () -> (::String | bot)
+
+      # @rbs () -> (::String | bot)
+      def report_precedences_message: () -> (::String | bot)
+
+      private
+
+      # @rbs () -> (::String | bot)
+      def how_resolved: () -> (::String | bot)
+    end
+  end
+end

data/sig/generated/lrama/state/shift_reduce_conflict.rbs

@@ -0,0 +1,19 @@
+# Generated from lib/lrama/state/shift_reduce_conflict.rb with RBS::Inline
+
+module Lrama
+  class State
+    class ShiftReduceConflict
+      attr_reader symbols: Array[Grammar::Symbol]
+
+      attr_reader shift: State::Action::Shift
+
+      attr_reader reduce: State::Action::Reduce
+
+      # @rbs (symbols: Array[Grammar::Symbol], shift: State::Action::Shift, reduce: State::Action::Reduce) -> void
+      def initialize: (symbols: Array[Grammar::Symbol], shift: State::Action::Shift, reduce: State::Action::Reduce) -> void
+
+      # @rbs () -> :shift_reduce
+      def type: () -> :shift_reduce
+    end
+  end
+end

data/sig/generated/lrama/state.rbs

@@ -0,0 +1,231 @@
+# Generated from lib/lrama/state.rb with RBS::Inline
+
+module Lrama
+  class State
+    type conflict = State::ShiftReduceConflict | State::ReduceReduceConflict
+
+    type transition = Action::Shift | Action::Goto
+
+    type lookahead_set = Hash[Item, Array[Grammar::Symbol]]
+
+    @id: Integer
+
+    @accessing_symbol: Grammar::Symbol
+
+    @kernels: Array[Item]
+
+    @items: Array[Item]
+
+    @items_to_state: Hash[Array[Item], State]
+
+    @conflicts: Array[conflict]
+
+    @resolved_conflicts: Array[ResolvedConflict]
+
+    @default_reduction_rule: Grammar::Rule?
+
+    @closure: Array[Item]
+
+    @nterm_transitions: Array[Action::Goto]
+
+    @term_transitions: Array[Action::Shift]
+
+    @transitions: Array[transition]
+
+    @internal_dependencies: Hash[Action::Goto, Array[Action::Goto]]
+
+    @successor_dependencies: Hash[Action::Goto, Array[Action::Goto]]
+
+    attr_reader id: Integer
+
+    attr_reader accessing_symbol: Grammar::Symbol
+
+    attr_reader kernels: Array[Item]
+
+    attr_reader conflicts: Array[conflict]
+
+    attr_reader resolved_conflicts: Array[ResolvedConflict]
+
+    attr_reader default_reduction_rule: Grammar::Rule?
+
+    attr_reader closure: Array[Item]
+
+    attr_reader items: Array[Item]
+
+    attr_reader annotation_list: Array[InadequacyAnnotation]
+
+    attr_reader predecessors: Array[State]
+
+    attr_reader items_to_state: Hash[Array[Item], State]
+
+    attr_reader lane_items: Hash[State, Array[[ Item, Item ]]]
+
+    attr_accessor _transitions: Array[[ Grammar::Symbol, Array[Item] ]]
+
+    attr_accessor reduces: Array[Action::Reduce]
+
+    attr_accessor ielr_isocores: Array[State]
+
+    attr_accessor lalr_isocore: State
+
+    attr_accessor lookaheads_recomputed: bool
+
+    attr_accessor follow_kernel_items: Hash[Action::Goto, Hash[Item, bool]]
+
+    attr_accessor always_follows: Hash[Action::Goto, Array[Grammar::Symbol]]
+
+    attr_accessor goto_follows: Hash[Action::Goto, Array[Grammar::Symbol]]
+
+    # @rbs (Integer id, Grammar::Symbol accessing_symbol, Array[Item] kernels) -> void
+    def initialize: (Integer id, Grammar::Symbol accessing_symbol, Array[Item] kernels) -> void
+
+    # @rbs (State other) -> bool
+    def ==: (State other) -> bool
+
+    # @rbs (Array[Item] closure) -> void
+    def closure=: (Array[Item] closure) -> void
+
+    # @rbs () -> Array[Action::Reduce]
+    def non_default_reduces: () -> Array[Action::Reduce]
+
+    # @rbs () -> void
+    def compute_transitions_and_reduces: () -> void
+
+    # @rbs (Grammar::Symbol next_sym, State next_state) -> void
+    def set_lane_items: (Grammar::Symbol next_sym, State next_state) -> void
+
+    # @rbs (Array[Item] items, State next_state) -> void
+    def set_items_to_state: (Array[Item] items, State next_state) -> void
+
+    # @rbs (Grammar::Rule rule, Array[Grammar::Symbol] look_ahead) -> void
+    def set_look_ahead: (Grammar::Rule rule, Array[Grammar::Symbol] look_ahead) -> void
+
+    # @rbs (Grammar::Rule rule, Hash[Grammar::Symbol, Array[Action::Goto]] sources) -> void
+    def set_look_ahead_sources: (Grammar::Rule rule, Hash[Grammar::Symbol, Array[Action::Goto]] sources) -> void
+
+    # @rbs () -> Array[Action::Goto]
+    def nterm_transitions: () -> Array[Action::Goto]
+
+    # @rbs () -> Array[Action::Shift]
+    def term_transitions: () -> Array[Action::Shift]
+
+    # @rbs () -> Array[transition]
+    def transitions: () -> Array[transition]
+
+    # @rbs (transition transition, State next_state) -> void
+    def update_transition: (transition transition, State next_state) -> void
+
+    # @rbs () -> void
+    def update_transitions_caches: () -> void
+
+    # @rbs () -> Array[Action::Shift]
+    def selected_term_transitions: () -> Array[Action::Shift]
+
+    # Move to next state by sym
+    #
+    # @rbs (Grammar::Symbol sym) -> State
+    def transition: (Grammar::Symbol sym) -> State
+
+    # @rbs (Item item) -> Action::Reduce
+    def find_reduce_by_item!: (Item item) -> Action::Reduce
+
+    # @rbs (Grammar::Rule default_reduction_rule) -> void
+    def default_reduction_rule=: (Grammar::Rule default_reduction_rule) -> void
+
+    # @rbs () -> bool
+    def has_conflicts?: () -> bool
+
+    # @rbs () -> Array[conflict]
+    def sr_conflicts: () -> Array[conflict]
+
+    # @rbs () -> Array[conflict]
+    def rr_conflicts: () -> Array[conflict]
+
+    # Clear information related to conflicts.
+    # IELR computation re-calculates conflicts and default reduction of states
+    # after LALR computation.
+    # Call this method before IELR computation to avoid duplicated conflicts information
+    # is stored.
+    #
+    # @rbs () -> void
+    def clear_conflicts: () -> void
+
+    # @rbs () -> bool
+    def split_state?: () -> bool
+
+    # Definition 3.40 (propagate_lookaheads)
+    #
+    # @rbs (State next_state) -> lookahead_set
+    def propagate_lookaheads: (State next_state) -> lookahead_set
+
+    # Definition 3.43 (is_compatible)
+    #
+    # @rbs (lookahead_set filtered_lookahead) -> bool
+    def is_compatible?: (lookahead_set filtered_lookahead) -> bool
+
+    # Definition 3.38 (lookahead_set_filters)
+    #
+    # @rbs () -> lookahead_set
+    def lookahead_set_filters: () -> lookahead_set
+
+    # Definition 3.27 (inadequacy_lists)
+    #
+    # @rbs () -> Hash[Grammar::Symbol, Array[Action::Shift | Action::Reduce]]
+    def inadequacy_list: () -> Hash[Grammar::Symbol, Array[Action::Shift | Action::Reduce]]
+
+    # Definition 3.30 (annotate_manifestation)
+    #
+    # @rbs () -> void
+    def annotate_manifestation: () -> void
+
+    # Definition 3.32 (annotate_predecessor)
+    #
+    # @rbs (State predecessor) -> void
+    def annotate_predecessor: (State predecessor) -> void
+
+    # @rbs () -> Array[Item]
+    def first_kernels: () -> Array[Item]
+
+    # @rbs (Array[InadequacyAnnotation] propagating_list) -> void
+    def append_annotation_list: (Array[InadequacyAnnotation] propagating_list) -> void
+
+    # Definition 3.31 (compute_lhs_contributions)
+    #
+    # @rbs (Grammar::Symbol sym, Grammar::Symbol token) -> (nil | Hash[Item, bool])
+    def lhs_contributions: (Grammar::Symbol sym, Grammar::Symbol token) -> (nil | Hash[Item, bool])
+
+    # Definition 3.26 (item_lookahead_sets)
+    #
+    # @rbs () -> lookahead_set
+    def item_lookahead_set: () -> lookahead_set
+
+    # @rbs (lookahead_set k) -> void
+    def item_lookahead_set=: (lookahead_set k) -> void
+
+    # @rbs (Item item) -> Array[[State, Item]]
+    def predecessors_with_item: (Item item) -> Array[[ State, Item ]]
+
+    # @rbs (State prev_state) -> void
+    def append_predecessor: (State prev_state) -> void
+
+    # Definition 3.39 (compute_goto_follow_set)
+    #
+    # @rbs (Grammar::Symbol nterm_token) -> Array[Grammar::Symbol]
+    def goto_follow_set: (Grammar::Symbol nterm_token) -> Array[Grammar::Symbol]
+
+    # Definition 3.8 (Goto Follows Internal Relation)
+    #
+    # @rbs (Action::Goto goto) -> Array[Action::Goto]
+    def internal_dependencies: (Action::Goto goto) -> Array[Action::Goto]
+
+    # Definition 3.5 (Goto Follows Successor Relation)
+    #
+    # @rbs (Action::Goto goto) -> Array[Action::Goto]
+    def successor_dependencies: (Action::Goto goto) -> Array[Action::Goto]
+
+    # Definition 3.9 (Goto Follows Predecessor Relation)
+    #
+    # @rbs (Action::Goto goto) -> Array[Action::Goto]
+    def predecessor_dependencies: (Action::Goto goto) -> Array[Action::Goto]
+  end
+end

data/sig/generated/lrama/states.rbs

@@ -0,0 +1,215 @@
+# Generated from lib/lrama/states.rb with RBS::Inline
+
+module Lrama
+  # States is passed to a template file
+  #
+  # "Efficient Computation of LALR(1) Look-Ahead Sets"
+  #   https://dl.acm.org/doi/pdf/10.1145/69622.357187
+  class States
+    type state_id = Integer
+
+    type rule_id = Integer
+
+    include Grammar::_DelegatedMethods
+
+    @grammar: Grammar
+
+    @tracer: Tracer
+
+    @states: Array[State]
+
+    @direct_read_sets: Hash[State::Action::Goto, Bitmap::bitmap]
+
+    @reads_relation: Hash[State::Action::Goto, Array[State::Action::Goto]]
+
+    @read_sets: Hash[State::Action::Goto, Bitmap::bitmap]
+
+    @includes_relation: Hash[State::Action::Goto, Array[State::Action::Goto]]
+
+    @lookback_relation: Hash[state_id, Hash[rule_id, Array[State::Action::Goto]]]
+
+    @follow_sets: Hash[State::Action::Goto, Bitmap::bitmap]
+
+    @la: Hash[state_id, Hash[rule_id, Bitmap::bitmap]]
+
+    extend Forwardable
+
+    include Lrama::Tracer::Duration
+
+    attr_reader states: Array[State]
+
+    attr_reader reads_relation: Hash[State::Action::Goto, Array[State::Action::Goto]]
+
+    attr_reader includes_relation: Hash[State::Action::Goto, Array[State::Action::Goto]]
+
+    attr_reader lookback_relation: Hash[state_id, Hash[rule_id, Array[State::Action::Goto]]]
+
+    # @rbs (Grammar grammar, Tracer tracer) -> void
+    def initialize: (Grammar grammar, Tracer tracer) -> void
+
+    # @rbs () -> void
+    def compute: () -> void
+
+    # @rbs () -> void
+    def compute_ielr: () -> void
+
+    # @rbs () -> Integer
+    def states_count: () -> Integer
+
+    # @rbs () -> Hash[State::Action::Goto, Array[Grammar::Symbol]]
+    def direct_read_sets: () -> Hash[State::Action::Goto, Array[Grammar::Symbol]]
+
+    # @rbs () -> Hash[State::Action::Goto, Array[Grammar::Symbol]]
+    def read_sets: () -> Hash[State::Action::Goto, Array[Grammar::Symbol]]
+
+    # @rbs () -> Hash[State::Action::Goto, Array[Grammar::Symbol]]
+    def follow_sets: () -> Hash[State::Action::Goto, Array[Grammar::Symbol]]
+
+    # @rbs () -> Hash[state_id, Hash[rule_id, Array[Grammar::Symbol]]]
+    def la: () -> Hash[state_id, Hash[rule_id, Array[Grammar::Symbol]]]
+
+    # @rbs () -> Integer
+    def sr_conflicts_count: () -> Integer
+
+    # @rbs () -> Integer
+    def rr_conflicts_count: () -> Integer
+
+    # @rbs (Logger logger) -> void
+    def validate!: (Logger logger) -> void
+
+    def compute_la_sources_for_conflicted_states: () -> untyped
+
+    private
+
+    # @rbs (Grammar::Symbol accessing_symbol, Array[State::Item] kernels, Hash[Array[State::Item], State] states_created) -> [State, bool]
+    def create_state: (Grammar::Symbol accessing_symbol, Array[State::Item] kernels, Hash[Array[State::Item], State] states_created) -> [ State, bool ]
+
+    # @rbs (State state) -> void
+    def setup_state: (State state) -> void
+
+    # @rbs (Array[State] states, State state) -> void
+    def enqueue_state: (Array[State] states, State state) -> void
+
+    # @rbs () -> void
+    def compute_lr0_states: () -> void
+
+    # @rbs () -> Array[State::Action::Goto]
+    def nterm_transitions: () -> Array[State::Action::Goto]
+
+    # @rbs () -> void
+    def compute_look_ahead_sets: () -> void
+
+    # @rbs () -> void
+    def compute_direct_read_sets: () -> void
+
+    # @rbs () -> void
+    def compute_reads_relation: () -> void
+
+    # @rbs () -> void
+    def compute_read_sets: () -> void
+
+    # Execute transition of state by symbols
+    # then return final state.
+    #
+    # @rbs (State state, Array[Grammar::Symbol] symbols) -> State
+    def transition: (State state, Array[Grammar::Symbol] symbols) -> State
+
+    # @rbs () -> void
+    def compute_includes_relation: () -> void
+
+    # @rbs () -> void
+    def compute_lookback_relation: () -> void
+
+    # @rbs () -> void
+    def compute_follow_sets: () -> void
+
+    # @rbs () -> void
+    def compute_la: () -> void
+
+    # @rbs (Bitmap::bitmap bit) -> Array[Grammar::Symbol]
+    def bitmap_to_terms: (Bitmap::bitmap bit) -> Array[Grammar::Symbol]
+
+    # @rbs () -> void
+    def compute_conflicts: () -> void
+
+    # @rbs () -> void
+    def compute_shift_reduce_conflicts: () -> void
+
+    # @rbs (Grammar::Precedence shift_prec, Grammar::Precedence reduce_prec, State::ResolvedConflict resolved_conflict) -> void
+    def mark_precedences_used: (Grammar::Precedence shift_prec, Grammar::Precedence reduce_prec, State::ResolvedConflict resolved_conflict) -> void
+
+    # @rbs () -> void
+    def compute_reduce_reduce_conflicts: () -> void
+
+    # @rbs () -> void
+    def compute_default_reduction: () -> void
+
+    # @rbs () -> void
+    def clear_conflicts: () -> void
+
+    # Definition 3.15 (Predecessors)
+    #
+    # @rbs () -> void
+    def compute_predecessors: () -> void
+
+    # Definition 3.16 (follow_kernel_items)
+    #
+    # @rbs () -> void
+    def compute_follow_kernel_items: () -> void
+
+    # @rbs () -> Hash[State::Action::Goto, Array[State::Action::Goto]]
+    def compute_goto_internal_relation: () -> Hash[State::Action::Goto, Array[State::Action::Goto]]
+
+    # @rbs () -> Hash[State::Action::Goto, Bitmap::bitmap]
+    def compute_goto_bitmaps: () -> Hash[State::Action::Goto, Bitmap::bitmap]
+
+    # Definition 3.20 (always_follows, one closure)
+    #
+    # @rbs () -> void
+    def compute_always_follows: () -> void
+
+    # @rbs () -> Hash[State::Action::Goto, Array[State::Action::Goto]]
+    def compute_goto_successor_or_internal_relation: () -> Hash[State::Action::Goto, Array[State::Action::Goto]]
+
+    # @rbs () -> Hash[State::Action::Goto, Bitmap::bitmap]
+    def compute_transition_bitmaps: () -> Hash[State::Action::Goto, Bitmap::bitmap]
+
+    # Definition 3.24 (goto_follows, via always_follows)
+    #
+    # @rbs () -> void
+    def compute_goto_follows: () -> void
+
+    # @rbs () -> Hash[State::Action::Goto, Array[State::Action::Goto]]
+    def compute_goto_internal_or_predecessor_dependencies: () -> Hash[State::Action::Goto, Array[State::Action::Goto]]
+
+    # @rbs () -> Hash[State::Action::Goto, Bitmap::bitmap]
+    def compute_always_follows_bitmaps: () -> Hash[State::Action::Goto, Bitmap::bitmap]
+
+    # @rbs () -> void
+    def split_states: () -> void
+
+    # @rbs () -> void
+    def compute_inadequacy_annotations: () -> void
+
+    # @rbs (State state, State::lookahead_set filtered_lookaheads) -> void
+    def merge_lookaheads: (State state, State::lookahead_set filtered_lookaheads) -> void
+
+    # @rbs (State state, State::Action::Shift | State::Action::Goto transition, State next_state) -> void
+    def compute_state: (State state, State::Action::Shift | State::Action::Goto transition, State next_state) -> void
+
+    # @rbs (Logger logger) -> void
+    def validate_conflicts_within_threshold!: (Logger logger) -> void
+
+    # @rbs (Logger logger) -> bool
+    def conflicts_within_threshold?: (Logger logger) -> bool
+
+    # @rbs (Logger logger) -> bool
+    def sr_conflicts_within_threshold?: (Logger logger) -> bool
+
+    # @rbs (Logger logger) -> bool
+    def rr_conflicts_within_threshold?: (Logger logger) -> bool
+
+    # @rbs () -> void
+    def clear_look_ahead_sets: () -> void
+  end
+end

data/sig/generated/lrama/tracer/actions.rbs

@@ -0,0 +1,13 @@
+# Generated from lib/lrama/tracer/actions.rb with RBS::Inline
+
+module Lrama
+  class Tracer
+    class Actions
+      # @rbs (IO io, ?actions: bool, **bool options) -> void
+      def initialize: (IO io, ?actions: bool, **bool options) -> void
+
+      # @rbs (Lrama::Grammar grammar) -> void
+      def trace: (Lrama::Grammar grammar) -> void
+    end
+  end
+end

data/sig/generated/lrama/tracer/closure.rbs

@@ -0,0 +1,13 @@
+# Generated from lib/lrama/tracer/closure.rb with RBS::Inline
+
+module Lrama
+  class Tracer
+    class Closure
+      # @rbs (IO io, ?automaton: bool, ?closure: bool, **bool) -> void
+      def initialize: (IO io, ?automaton: bool, ?closure: bool, **bool) -> void
+
+      # @rbs (Lrama::State state) -> void
+      def trace: (Lrama::State state) -> void
+    end
+  end
+end

data/sig/generated/lrama/tracer/duration.rbs

@@ -0,0 +1,18 @@
+# Generated from lib/lrama/tracer/duration.rb with RBS::Inline
+
+module Lrama
+  class Tracer
+    module Duration
+      @_report_duration_enabled: bool
+
+      # @rbs () -> void
+      def self.enable: () -> void
+
+      # @rbs () -> bool
+      def self.enabled?: () -> bool
+
+      # @rbs [T] (_ToS message) { -> T } -> T
+      def report_duration: [T] (_ToS message) { () -> T } -> T
+    end
+  end
+end

data/sig/generated/lrama/tracer/only_explicit_rules.rbs

@@ -0,0 +1,13 @@
+# Generated from lib/lrama/tracer/only_explicit_rules.rb with RBS::Inline
+
+module Lrama
+  class Tracer
+    class OnlyExplicitRules
+      # @rbs (IO io, ?only_explicit: bool, **bool) -> void
+      def initialize: (IO io, ?only_explicit: bool, **bool) -> void
+
+      # @rbs (Lrama::Grammar grammar) -> void
+      def trace: (Lrama::Grammar grammar) -> void
+    end
+  end
+end

data/sig/generated/lrama/tracer/rules.rbs

@@ -0,0 +1,13 @@
+# Generated from lib/lrama/tracer/rules.rb with RBS::Inline
+
+module Lrama
+  class Tracer
+    class Rules
+      # @rbs (IO io, ?rules: bool, ?only_explicit: bool, **bool) -> void
+      def initialize: (IO io, ?rules: bool, ?only_explicit: bool, **bool) -> void
+
+      # @rbs (Lrama::Grammar grammar) -> void
+      def trace: (Lrama::Grammar grammar) -> void
+    end
+  end
+end

data/sig/generated/lrama/tracer/state.rbs

@@ -0,0 +1,16 @@
+# Generated from lib/lrama/tracer/state.rb with RBS::Inline
+
+module Lrama
+  class Tracer
+    class State
+      # @rbs (IO io, ?automaton: bool, ?closure: bool, **bool) -> void
+      def initialize: (IO io, ?automaton: bool, ?closure: bool, **bool) -> void
+
+      # @rbs (Lrama::State state) -> void
+      def trace: (Lrama::State state) -> void
+
+      # @rbs (Integer state_count, Lrama::State state) -> void
+      def trace_list_append: (Integer state_count, Lrama::State state) -> void
+    end
+  end
+end

data/sig/generated/lrama/tracer.rbs

@@ -0,0 +1,23 @@
+# Generated from lib/lrama/tracer.rb with RBS::Inline
+
+module Lrama
+  class Tracer
+    # @rbs (IO io, **bool options) -> void
+    def initialize: (IO io, **bool options) -> void
+
+    # @rbs (Lrama::Grammar grammar) -> void
+    def trace: (Lrama::Grammar grammar) -> void
+
+    # @rbs (Lrama::State state) -> void
+    def trace_closure: (Lrama::State state) -> void
+
+    # @rbs (Lrama::State state) -> void
+    def trace_state: (Lrama::State state) -> void
+
+    # @rbs (Integer state_count, Lrama::State state) -> void
+    def trace_state_list_append: (Integer state_count, Lrama::State state) -> void
+
+    # @rbs () -> void
+    def enable_duration: () -> void
+  end
+end

data/sig/generated/lrama/version.rbs

@@ -0,0 +1,5 @@
+# Generated from lib/lrama/version.rb with RBS::Inline
+
+module Lrama
+  VERSION: String
+end

data/sig/generated/lrama/warnings/conflicts.rbs

@@ -0,0 +1,13 @@
+# Generated from lib/lrama/warnings/conflicts.rb with RBS::Inline
+
+module Lrama
+  class Warnings
+    class Conflicts
+      # @rbs (Lrama::Logger logger, bool warnings) -> void
+      def initialize: (Lrama::Logger logger, bool warnings) -> void
+
+      # @rbs (Lrama::States states) -> void
+      def warn: (Lrama::States states) -> void
+    end
+  end
+end

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

data/sig/generated/lrama/warnings/name_conflicts.rbs

@@ -0,0 +1,31 @@
+# Generated from lib/lrama/warnings/name_conflicts.rb with RBS::Inline
+
+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: (Lrama::Logger logger, bool warnings) -> void
+
+      # @rbs (Lrama::Grammar grammar) -> void
+      def warn: (Lrama::Grammar grammar) -> void
+
+      private
+
+      # @rbs (Lrama::Grammar grammar) -> Set[String]
+      def collect_symbol_names: (Lrama::Grammar grammar) -> Set[String]
+
+      # @rbs (Array[untyped] terms, Set[String] symbol_names) -> void
+      def collect_term_names: (Array[untyped] terms, Set[String] symbol_names) -> void
+
+      # @rbs (Array[untyped] nterms, Set[String] symbol_names) -> void
+      def collect_nterm_names: (Array[untyped] nterms, Set[String] symbol_names) -> void
+
+      # @rbs (Array[untyped] parameterized_rules, Set[String] symbol_names) -> void
+      def check_conflicts: (Array[untyped] parameterized_rules, Set[String] symbol_names) -> void
+    end
+  end
+end