lrama 0.6.10 → 0.7.0

data/rbs_collection.lock.yaml

@@ -1,6 +1,14 @@
 ---
 path: ".gem_rbs_collection"
 gems:
+- name: diff-lcs
+  version: '1.5'
+  source:
+    type: git
+    name: ruby/gem_rbs_collection
+    revision: 7651e7b92c15bd5b4bc11fd3dd455be0ea571fd0
+    remote: https://github.com/ruby/gem_rbs_collection.git
+    repo_dir: gems
 - name: erb
   version: '0'
   source:
@@ -18,7 +26,7 @@ gems:
   source:
     type: git
     name: ruby/gem_rbs_collection
-    revision: 4b0d2f72e63b6c3e92dc54e19ce23dd24524f9a7
+    revision: 7651e7b92c15bd5b4bc11fd3dd455be0ea571fd0
     remote: https://github.com/ruby/gem_rbs_collection.git
     repo_dir: gems
 - name: stackprof
@@ -26,7 +34,7 @@ gems:
   source:
     type: git
     name: ruby/gem_rbs_collection
-    revision: 4b0d2f72e63b6c3e92dc54e19ce23dd24524f9a7
+    revision: 7651e7b92c15bd5b4bc11fd3dd455be0ea571fd0
     remote: https://github.com/ruby/gem_rbs_collection.git
     repo_dir: gems
 - name: strscan

data/sig/generated/lrama/bitmap.rbs

@@ -0,0 +1,11 @@
+# Generated from lib/lrama/bitmap.rb with RBS::Inline
+
+module Lrama
+  module Bitmap
+    # @rbs (Array[Integer] ary) -> Integer
+    def self.from_array: (Array[Integer] ary) -> Integer
+
+    # @rbs (Integer int) -> Array[Integer]
+    def self.to_array: (Integer int) -> Array[Integer]
+  end
+end

data/sig/generated/lrama/digraph.rbs

@@ -0,0 +1,39 @@
+# Generated from lib/lrama/digraph.rb with RBS::Inline
+
+module Lrama
+  # Algorithm Digraph of https://dl.acm.org/doi/pdf/10.1145/69622.357187 (P. 625)
+  #
+  # @rbs generic X < Object -- Type of a member of `sets`
+  # @rbs generic Y < _Or    -- Type of sets assigned to a member of `sets`
+  class Digraph[X < Object, Y < _Or]
+    interface _Or
+      def |: (self) -> self
+    end
+
+    @sets: Array[X]
+
+    @relation: Hash[X, Array[X]]
+
+    @base_function: Hash[X, Y]
+
+    @stack: Array[X]
+
+    @h: Hash[X, (Integer | Float)?]
+
+    @result: Hash[X, Y]
+
+    # @rbs sets: Array[X]
+    # @rbs relation: Hash[X, Array[X]]
+    # @rbs base_function: Hash[X, Y]
+    # @rbs return: void
+    def initialize: (Array[X] sets, Hash[X, Array[X]] relation, Hash[X, Y] base_function) -> void
+
+    # @rbs () -> Hash[X, Y]
+    def compute: () -> Hash[X, Y]
+
+    private
+
+    # @rbs (X x) -> void
+    def traverse: (X x) -> void
+  end
+end

data/sig/generated/lrama/grammar/binding.rbs

@@ -0,0 +1,34 @@
+# Generated from lib/lrama/grammar/binding.rb with RBS::Inline
+
+module Lrama
+  class Grammar
+    class Binding
+      @actual_args: Array[Lexer::Token]
+
+      @param_to_arg: Hash[String, Lexer::Token]
+
+      # @rbs (Array[Lexer::Token] params, Array[Lexer::Token] actual_args) -> void
+      def initialize: (Array[Lexer::Token] params, Array[Lexer::Token] actual_args) -> void
+
+      # @rbs (Lexer::Token sym) -> Lexer::Token
+      def resolve_symbol: (Lexer::Token sym) -> Lexer::Token
+
+      # @rbs (Lexer::Token::InstantiateRule token) -> String
+      def concatenated_args_str: (Lexer::Token::InstantiateRule token) -> String
+
+      private
+
+      # @rbs (Array[Lexer::Token] params, Array[Lexer::Token] actual_args) -> Hash[String, Lexer::Token]
+      def map_params_to_args: (Array[Lexer::Token] params, Array[Lexer::Token] actual_args) -> Hash[String, Lexer::Token]
+
+      # @rbs (Lexer::Token::InstantiateRule sym) -> Array[Lexer::Token]
+      def resolved_args: (Lexer::Token::InstantiateRule sym) -> Array[Lexer::Token]
+
+      # @rbs (Lexer::Token sym) -> Lexer::Token
+      def param_to_arg: (Lexer::Token sym) -> Lexer::Token
+
+      # @rbs (Lexer::Token::InstantiateRule token) -> Array[String]
+      def token_to_args_s_values: (Lexer::Token::InstantiateRule token) -> Array[String]
+    end
+  end
+end

data/sig/generated/lrama/lexer/grammar_file.rbs

@@ -0,0 +1,28 @@
+# Generated from lib/lrama/lexer/grammar_file.rb with RBS::Inline
+
+module Lrama
+  class Lexer
+    class GrammarFile
+      class Text < String
+        # @rbs () -> String
+        def inspect: () -> String
+      end
+
+      attr_reader path: String
+
+      attr_reader text: String
+
+      # @rbs (String path, String text) -> void
+      def initialize: (String path, String text) -> void
+
+      # @rbs () -> String
+      def inspect: () -> String
+
+      # @rbs (GrammarFile other) -> bool
+      def ==: (GrammarFile other) -> bool
+
+      # @rbs () -> Array[String]
+      def lines: () -> Array[String]
+    end
+  end
+end

data/sig/generated/lrama/lexer/location.rbs

@@ -0,0 +1,52 @@
+# Generated from lib/lrama/lexer/location.rb with RBS::Inline
+
+module Lrama
+  class Lexer
+    class Location
+      attr_reader grammar_file: GrammarFile
+
+      attr_reader first_line: Integer
+
+      attr_reader first_column: Integer
+
+      attr_reader last_line: Integer
+
+      attr_reader last_column: Integer
+
+      # @rbs (grammar_file: GrammarFile, first_line: Integer, first_column: Integer, last_line: Integer, last_column: Integer) -> void
+      def initialize: (grammar_file: GrammarFile, first_line: Integer, first_column: Integer, last_line: Integer, last_column: Integer) -> void
+
+      # @rbs (Location other) -> bool
+      def ==: (Location other) -> bool
+
+      # @rbs (Integer left, Integer right) -> Location
+      def partial_location: (Integer left, Integer right) -> Location
+
+      # @rbs () -> String
+      def to_s: () -> String
+
+      # @rbs (String error_message) -> String
+      def generate_error_message: (String error_message) -> String
+
+      # @rbs () -> String
+      def line_with_carets: () -> String
+
+      private
+
+      # @rbs () -> String
+      def path: () -> String
+
+      # @rbs () -> String
+      def blanks: () -> String
+
+      # @rbs () -> String
+      def carets: () -> String
+
+      # @rbs () -> String
+      def text: () -> String
+
+      # @rbs () -> Array[String]
+      def _text: () -> Array[String]
+    end
+  end
+end

data/sig/{lrama → generated/lrama}/lexer/token/char.rbs

@@ -1,3 +1,5 @@
+# Generated from lib/lrama/lexer/token/char.rb with RBS::Inline
+
 module Lrama
   class Lexer
     class Token

data/sig/{lrama → generated/lrama}/lexer/token/ident.rbs

@@ -1,3 +1,5 @@
+# Generated from lib/lrama/lexer/token/ident.rb with RBS::Inline
+
 module Lrama
   class Lexer
     class Token

data/sig/{lrama → generated/lrama}/lexer/token/instantiate_rule.rbs

@@ -1,12 +1,20 @@
+# Generated from lib/lrama/lexer/token/instantiate_rule.rb with RBS::Inline
+
 module Lrama
   class Lexer
     class Token
       class InstantiateRule < Token
         attr_reader args: Array[Lexer::Token]
+
         attr_reader lhs_tag: Lexer::Token::Tag?
 
+        # @rbs (s_value: String, ?alias_name: String, ?location: Location, ?args: Array[Lexer::Token], ?lhs_tag: Lexer::Token::Tag?) -> void
         def initialize: (s_value: String, ?alias_name: String, ?location: Location, ?args: Array[Lexer::Token], ?lhs_tag: Lexer::Token::Tag?) -> void
+
+        # @rbs () -> String
         def rule_name: () -> String
+
+        # @rbs () -> Integer
         def args_count: () -> Integer
       end
     end

data/sig/{lrama → generated/lrama}/lexer/token/tag.rbs

@@ -1,7 +1,10 @@
+# Generated from lib/lrama/lexer/token/tag.rb with RBS::Inline
+
 module Lrama
   class Lexer
     class Token
       class Tag < Token
+        # @rbs () -> String
         def member: () -> String
       end
     end

data/sig/{lrama → generated/lrama}/lexer/token/user_code.rbs

@@ -1,15 +1,20 @@
+# Generated from lib/lrama/lexer/token/user_code.rb with RBS::Inline
+
 module Lrama
   class Lexer
     class Token
       class UserCode < Token
         attr_accessor tag: Lexer::Token::Tag
-        @references: Array[Lrama::Grammar::Reference]
 
+        # @rbs () -> Array[Lrama::Grammar::Reference]
         def references: () -> Array[Lrama::Grammar::Reference]
 
         private
 
+        # @rbs () -> Array[Lrama::Grammar::Reference]
         def _references: () -> Array[Lrama::Grammar::Reference]
+
+        # @rbs (StringScanner scanner) -> Lrama::Grammar::Reference?
         def scan_reference: (StringScanner scanner) -> Lrama::Grammar::Reference?
       end
     end

data/sig/{lrama → generated/lrama}/lexer/token.rbs

@@ -1,22 +1,45 @@
+# Generated from lib/lrama/lexer/token.rb with RBS::Inline
+
 module Lrama
   class Lexer
     class Token
       attr_reader s_value: String
-      attr_accessor alias_name: String
+
       attr_reader location: Location
+
+      attr_accessor alias_name: String
+
       attr_accessor referred: bool
 
+      # @rbs (s_value: String, ?alias_name: String, ?location: Location) -> void
       def initialize: (s_value: String, ?alias_name: String, ?location: Location) -> void
 
+      # @rbs () -> String
       def to_s: () -> String
+
+      # @rbs (String string) -> bool
       def referred_by?: (String string) -> bool
+
+      # @rbs (Token other) -> bool
       def ==: (Token other) -> bool
+
+      # @rbs () -> Integer
       def first_line: () -> Integer
+
+      alias line first_line
+
+      # @rbs () -> Integer
       def first_column: () -> Integer
+
+      alias column first_column
+
+      # @rbs () -> Integer
       def last_line: () -> Integer
+
+      # @rbs () -> Integer
       def last_column: () -> Integer
-      alias line first_line
-      alias column first_column
+
+      # @rbs (Lrama::Grammar::Reference ref, String message) -> bot
       def invalid_ref: (Lrama::Grammar::Reference ref, String message) -> bot
     end
   end

data/sig/generated/lrama/logger.rbs

@@ -0,0 +1,14 @@
+# Generated from lib/lrama/logger.rb with RBS::Inline
+
+module Lrama
+  class Logger
+    # @rbs (IO out) -> void
+    def initialize: (IO out) -> void
+
+    # @rbs (String message) -> void
+    def warn: (String message) -> void
+
+    # @rbs (String message) -> void
+    def error: (String message) -> void
+  end
+end

data/sig/generated/lrama/trace_reporter.rbs

@@ -0,0 +1,25 @@
+# Generated from lib/lrama/trace_reporter.rb with RBS::Inline
+
+module Lrama
+  class TraceReporter
+    # @rbs (Lrama::Grammar grammar) -> void
+    def initialize: (Lrama::Grammar grammar) -> void
+
+    # @rbs (**Hash[Symbol, bool] options) -> void
+    def report: (**Hash[Symbol, bool] options) -> void
+
+    private
+
+    # @rbs rules: (bool rules, bool actions, bool only_explicit_rules, **untyped _) -> void
+    def _report: (?rules: untyped, ?actions: untyped, ?only_explicit_rules: untyped, **untyped _) -> untyped
+
+    # @rbs () -> void
+    def report_rules: () -> void
+
+    # @rbs () -> void
+    def report_only_explicit_rules: () -> void
+
+    # @rbs () -> void
+    def report_actions: () -> void
+  end
+end

data/sig/lrama/counterexamples/derivation.rbs

@@ -0,0 +1,33 @@
+module Lrama
+  class Counterexamples
+    class Derivation
+      @item: States::Item
+
+      @left: Derivation?
+
+      @right: Derivation?
+
+      attr_reader item: States::Item
+
+      attr_reader left: Derivation?
+
+      attr_reader right: Derivation?
+
+      attr_writer right: Derivation?
+
+      def initialize: (States::Item item, Derivation? left, ?Derivation? right) -> void
+
+      def to_s: () -> ::String
+
+      alias inspect to_s
+
+      def render_strings_for_report: () -> Array[String]
+
+      def render_for_report: () -> String
+
+      private
+
+      def _render_for_report: (Derivation derivation, Integer offset, Array[String] strings, Integer index) -> Integer
+    end
+  end
+end

data/sig/lrama/counterexamples/example.rbs

@@ -0,0 +1,45 @@
+module Lrama
+  class Counterexamples
+    class Example
+      @path1: ::Array[StartPath | TransitionPath | ProductionPath]
+
+      @path2: ::Array[StartPath | TransitionPath | ProductionPath]
+
+      @conflict: (State::ShiftReduceConflict | State::ReduceReduceConflict)
+
+      @conflict_symbol: Grammar::Symbol
+
+      @counterexamples: Counterexamples
+
+      @derivations1: Derivation
+
+      @derivations2: Derivation
+
+      attr_reader path1: ::Array[StartPath | TransitionPath | ProductionPath]
+
+      attr_reader path2: ::Array[StartPath | TransitionPath | ProductionPath]
+
+      attr_reader conflict: (State::ShiftReduceConflict | State::ReduceReduceConflict)
+
+      attr_reader conflict_symbol: Grammar::Symbol
+
+      def initialize: (::Array[StartPath | TransitionPath | ProductionPath]? path1, ::Array[StartPath | TransitionPath | ProductionPath]? path2, (State::ShiftReduceConflict | State::ReduceReduceConflict) conflict, Grammar::Symbol conflict_symbol, Counterexamples counterexamples) -> void
+
+      def type: () -> (:shift_reduce | :reduce_reduce)
+
+      def path1_item: () -> States::Item
+
+      def path2_item: () -> States::Item
+
+      def derivations1: () -> Derivation
+
+      def derivations2: () -> Derivation
+
+      private
+
+      def _derivations: (::Array[StartPath | TransitionPath | ProductionPath] paths) -> Derivation
+
+      def find_derivation_for_symbol: (StateItem state_item, Grammar::Symbol sym) -> Derivation?
+    end
+  end
+end

data/sig/lrama/counterexamples/path.rbs

@@ -0,0 +1,21 @@
+module Lrama
+  class Counterexamples
+    class Path
+      @from_state_item: StateItem?
+
+      @to_state_item: StateItem
+
+      def initialize: (StateItem? from_state_item, StateItem to_state_item) -> void
+
+      def from: () -> StateItem?
+
+      def to: () -> StateItem
+
+      def to_s: () -> ::String
+
+      alias inspect to_s
+
+      def type: -> bot
+    end
+  end
+end

data/sig/lrama/counterexamples/production_path.rbs

@@ -0,0 +1,11 @@
+module Lrama
+  class Counterexamples
+    class ProductionPath < Path
+      def type: () -> :production
+
+      def transition?: () -> false
+
+      def production?: () -> true
+    end
+  end
+end

data/sig/lrama/counterexamples/start_path.rbs

@@ -0,0 +1,13 @@
+module Lrama
+  class Counterexamples
+    class StartPath < Path
+      def initialize: (StateItem to_state_item) -> void
+
+      def type: () -> :start
+
+      def transition?: () -> false
+
+      def production?: () -> false
+    end
+  end
+end

data/sig/lrama/counterexamples/state_item.rbs

@@ -0,0 +1,10 @@
+module Lrama
+  class Counterexamples
+    class StateItem
+     attr_accessor state: State
+     attr_accessor item: States::Item
+
+      def initialize: (State state, States::Item item) -> void
+    end
+  end
+end

data/sig/lrama/counterexamples/transition_path.rbs

@@ -0,0 +1,11 @@
+module Lrama
+  class Counterexamples
+    class TransitionPath < Path
+      def type: () -> :transition
+
+      def transition?: () -> true
+
+      def production?: () -> false
+    end
+  end
+end

data/sig/lrama/counterexamples/triple.rbs

@@ -0,0 +1,20 @@
+module Lrama
+  class Counterexamples
+    class Triple
+      attr_accessor s: State
+      attr_accessor itm: States::Item
+      attr_accessor l: Set[Grammar::Symbol]
+
+      alias state s
+      alias item itm
+      alias precise_lookahead_set l
+
+      def initialize: (State s, States::Item itm, Set[Grammar::Symbol] l) -> void
+
+      def state_item: () -> StateItem
+      def inspect: () -> ::String
+
+      alias to_s inspect
+    end
+  end
+end

data/sig/lrama/counterexamples.rbs

@@ -0,0 +1,29 @@
+module Lrama
+  class Counterexamples
+    @states: States
+    @transitions: Hash[[StateItem, Grammar::Symbol], StateItem]
+    @reverse_transitions: Hash[[StateItem, Grammar::Symbol], Set[StateItem]]
+    @productions: Hash[StateItem, Set[States::Item]]
+    @reverse_productions: Hash[[State, Grammar::Symbol], Set[States::Item]]
+
+    attr_reader transitions: Hash[[StateItem, Grammar::Symbol], StateItem]
+    attr_reader productions: Hash[StateItem, Set[States::Item]]
+
+    def initialize: (States states) -> void
+    def to_s: () -> "#<Counterexamples>"
+    alias inspect to_s
+    def compute: (State conflict_state) -> Array[Example]
+
+    private
+
+    def setup_transitions: () -> void
+    def setup_productions: () -> void
+    def shift_reduce_example: (State conflict_state, State::ShiftReduceConflict conflict) -> Example
+    def reduce_reduce_examples: (State conflict_state, State::ReduceReduceConflict conflict) -> Example
+    def find_shift_conflict_shortest_path: (::Array[StartPath|TransitionPath|ProductionPath]? reduce_path, State conflict_state, States::Item conflict_item) -> ::Array[StartPath|TransitionPath|ProductionPath]
+    def find_shift_conflict_shortest_state_items: (::Array[StartPath|TransitionPath|ProductionPath]? reduce_path, State conflict_state, States::Item conflict_item) -> Array[StateItem]
+    def build_paths_from_state_items: (Array[StateItem] state_items) -> ::Array[StartPath|TransitionPath|ProductionPath]
+    def shortest_path: (State conflict_state, States::Item conflict_reduce_item, Grammar::Symbol conflict_term) -> ::Array[StartPath|TransitionPath|ProductionPath]?
+    def follow_l: (States::Item item, Set[Grammar::Symbol] current_l) -> Set[Grammar::Symbol]
+  end
+end

data/sig/lrama/grammar/rule_builder.rbs

@@ -37,7 +37,6 @@ module Lrama
       def preprocess_references: () -> void
       def build_rules: () -> void
       def process_rhs: () -> void
-      def lhs_s_value: (Lexer::Token::InstantiateRule token, Grammar::Binding bindings) -> String
       def resolve_inline: () -> void
       def resolve_inline_rhs: (RuleBuilder rule_builder, Grammar::ParameterizingRule::Rhs inline_rhs, Integer index, ?Binding bindings) -> void
       def replace_inline_user_code: (Grammar::ParameterizingRule::Rhs inline_rhs, Integer index) -> Lexer::Token::UserCode?

data/sig/lrama/grammar/symbol.rbs

@@ -13,7 +13,7 @@ module Lrama
       attr_accessor destructor: Destructor?
       attr_accessor error_token: ErrorToken
 
-      attr_accessor first_set: Set[Array[Symbol]] | Set[Symbol]
+      attr_accessor first_set: Set[Grammar::Symbol]
       attr_accessor first_set_bitmap: Integer
       attr_writer eof_symbol: bool
       attr_writer error_symbol: bool

data/sig/lrama/grammar/symbols/resolver.rbs

@@ -14,8 +14,8 @@ module Lrama
         def sort_by_number!: () -> Array[Grammar::Symbol]
         def add_term: (id: Lexer::Token, ?alias_name: String?, ?tag: Lexer::Token::Tag?, ?token_id: Integer?, ?replace: bool) -> Grammar::Symbol
         def add_nterm: (id: Lexer::Token, ?alias_name: String?, ?tag: Lexer::Token::Tag?) -> Grammar::Symbol
-        def find_symbol_by_s_value: (Grammar::Symbol s_value) -> Grammar::Symbol?
-        def find_symbol_by_s_value!: (Grammar::Symbol s_value) -> Grammar::Symbol
+        def find_symbol_by_s_value: (::String s_value) -> Grammar::Symbol?
+        def find_symbol_by_s_value!: (::String s_value) -> Grammar::Symbol
         def find_symbol_by_id: (Lexer::Token id) -> Grammar::Symbol?
         def find_symbol_by_id!: (Lexer::Token id) -> Grammar::Symbol
         def find_symbol_by_token_id: (Integer token_id) -> Grammar::Symbol?
@@ -47,7 +47,7 @@ module Lrama
         def find_symbol_by_number!: (Integer number) -> Grammar::Symbol
         def find_symbol_by_id!: (Lexer::Token id) -> Grammar::Symbol
         def token_to_symbol: (Lexer::Token token) -> Grammar::Symbol
-        def find_symbol_by_s_value!: (Grammar::Symbol s_value) -> Grammar::Symbol
+        def find_symbol_by_s_value!: (::String s_value) -> Grammar::Symbol
         def fill_nterm_type: (Array[Grammar::Type] types) -> void
         def fill_symbol_number: () -> void
         def fill_printer: (Array[Grammar::Printer] printers) -> void

data/sig/lrama/grammar.rbs

@@ -91,5 +91,18 @@ module Lrama
     def fill_sym_to_rules: () -> Array[Rule]
     def validate_rule_lhs_is_nterm!: () -> void
     def set_locations: () -> void
+
+    interface _DelegatedMethods
+    def rules: () -> Array[Rule]
+    def accept_symbol: () -> Grammar::Symbol
+    def eof_symbol: () -> Grammar::Symbol
+    def undef_symbol: () -> Grammar::Symbol
+
+    # delegate to @symbols_resolver
+    def symbols: () -> Array[Grammar::Symbol]
+    def terms: () -> Array[Grammar::Symbol]
+    def nterms: () -> Array[Grammar::Symbol]
+    def find_symbol_by_s_value!: (::String s_value) -> Grammar::Symbol
+    end
   end
 end

data/sig/lrama/options.rbs

@@ -1,6 +1,7 @@
 module Lrama
   class Options
     attr_accessor skeleton: String
+    attr_accessor define: Hash[String, String]
     attr_accessor header: bool
     attr_accessor header_file: String?
     attr_accessor report_file: String?

data/sig/lrama/state/reduce_reduce_conflict.rbs

@@ -1,11 +1,11 @@
 module Lrama
   class State
     class ReduceReduceConflict
-      attr_accessor symbols: Array[Grammar::Symbol?]
+      attr_accessor symbols: Array[Grammar::Symbol]
       attr_accessor reduce1: State::Reduce
       attr_accessor reduce2: State::Reduce
 
-      def initialize: (?symbols: Array[Grammar::Symbol?], ?reduce1: State::Reduce, ?reduce2: State::Reduce) -> void
+      def initialize: (?symbols: Array[Grammar::Symbol], ?reduce1: State::Reduce, ?reduce2: State::Reduce) -> void
 
       def type: () -> :reduce_reduce
     end