lrama 0.7.0 → 0.7.1

data/rbs_collection.lock.yaml

@@ -1,12 +1,16 @@
 ---
 path: ".gem_rbs_collection"
 gems:
+- name: dbm
+  version: '0'
+  source:
+    type: stdlib
 - name: diff-lcs
   version: '1.5'
   source:
     type: git
     name: ruby/gem_rbs_collection
-    revision: 7651e7b92c15bd5b4bc11fd3dd455be0ea571fd0
+    revision: 01f77ce44d0ac13c8ebfc3cfdd7104320021f991
     remote: https://github.com/ruby/gem_rbs_collection.git
     repo_dir: gems
 - name: erb
@@ -21,24 +25,44 @@ gems:
   version: '0'
   source:
     type: stdlib
+- name: optparse
+  version: '0'
+  source:
+    type: stdlib
+- name: pstore
+  version: '0'
+  source:
+    type: stdlib
+- name: psych
+  version: '0'
+  source:
+    type: stdlib
 - name: rake
   version: '13.0'
   source:
     type: git
     name: ruby/gem_rbs_collection
-    revision: 7651e7b92c15bd5b4bc11fd3dd455be0ea571fd0
+    revision: 01f77ce44d0ac13c8ebfc3cfdd7104320021f991
     remote: https://github.com/ruby/gem_rbs_collection.git
     repo_dir: gems
+- name: rdoc
+  version: '0'
+  source:
+    type: stdlib
 - name: stackprof
   version: '0.2'
   source:
     type: git
     name: ruby/gem_rbs_collection
-    revision: 7651e7b92c15bd5b4bc11fd3dd455be0ea571fd0
+    revision: 01f77ce44d0ac13c8ebfc3cfdd7104320021f991
     remote: https://github.com/ruby/gem_rbs_collection.git
     repo_dir: gems
 - name: strscan
   version: '0'
   source:
     type: stdlib
+- name: timeout
+  version: '0'
+  source:
+    type: stdlib
 gemfile_lock_path: Gemfile.lock

data/rbs_collection.yaml

@@ -16,8 +16,10 @@ path: .gem_rbs_collection
 gems:
   - name: erb
   - name: strscan
+  - name: timeout
   # Skip loading rbs gem's RBS.
   # It's unnecessary if you don't use rbs as a library.
   - name: rbs
     ignore: true
   - name: forwardable
+  - name: optparse

data/sig/generated/lrama/bitmap.rbs

@@ -2,10 +2,18 @@
 
 module Lrama
   module Bitmap
-    # @rbs (Array[Integer] ary) -> Integer
-    def self.from_array: (Array[Integer] ary) -> Integer
+    type bitmap = Integer
 
-    # @rbs (Integer int) -> Array[Integer]
-    def self.to_array: (Integer int) -> Array[Integer]
+    # @rbs (Array[Integer] ary) -> bitmap
+    def self.from_array: (Array[Integer] ary) -> bitmap
+
+    # @rbs (Integer int) -> bitmap
+    def self.from_integer: (Integer int) -> bitmap
+
+    # @rbs (bitmap int) -> Array[Integer]
+    def self.to_array: (bitmap int) -> Array[Integer]
+
+    # @rbs (bitmap int, Integer size) -> Array[bool]
+    def self.to_bool_array: (bitmap int, Integer size) -> Array[bool]
   end
 end

data/sig/generated/lrama/counterexamples/derivation.rbs

@@ -0,0 +1,36 @@
+# Generated from lib/lrama/counterexamples/derivation.rb with RBS::Inline
+
+module Lrama
+  class Counterexamples
+    class Derivation
+      @item: State::Item
+
+      @left: Derivation?
+
+      attr_reader item: State::Item
+
+      attr_reader left: Derivation?
+
+      attr_accessor right: Derivation?
+
+      # @rbs (State::Item item, Derivation? left) -> void
+      def initialize: (State::Item item, Derivation? left) -> void
+
+      # @rbs () -> ::String
+      def to_s: () -> ::String
+
+      alias inspect to_s
+
+      # @rbs () -> Array[String]
+      def render_strings_for_report: () -> Array[String]
+
+      # @rbs () -> String
+      def render_for_report: () -> String
+
+      private
+
+      # @rbs (Derivation derivation, Integer offset, Array[String] strings, Integer index) -> Integer
+      def _render_for_report: (Derivation derivation, Integer offset, Array[String] strings, Integer index) -> Integer
+    end
+  end
+end

data/sig/generated/lrama/counterexamples/example.rbs

@@ -0,0 +1,58 @@
+# Generated from lib/lrama/counterexamples/example.rb with RBS::Inline
+
+module Lrama
+  class Counterexamples
+    class Example
+      @path1: ::Array[StateItem]
+
+      @path2: ::Array[StateItem]
+
+      @conflict: State::conflict
+
+      @conflict_symbol: Grammar::Symbol
+
+      @counterexamples: Counterexamples
+
+      @derivations1: Derivation
+
+      @derivations2: Derivation
+
+      attr_reader path1: ::Array[StateItem]
+
+      attr_reader path2: ::Array[StateItem]
+
+      attr_reader conflict: State::conflict
+
+      attr_reader conflict_symbol: Grammar::Symbol
+
+      # path1 is shift conflict when S/R conflict
+      # path2 is always reduce conflict
+      #
+      # @rbs (Array[StateItem]? path1, Array[StateItem]? path2, State::conflict conflict, Grammar::Symbol conflict_symbol, Counterexamples counterexamples) -> void
+      def initialize: (Array[StateItem]? path1, Array[StateItem]? path2, State::conflict conflict, Grammar::Symbol conflict_symbol, Counterexamples counterexamples) -> void
+
+      # @rbs () -> (:shift_reduce | :reduce_reduce)
+      def type: () -> (:shift_reduce | :reduce_reduce)
+
+      # @rbs () -> State::Item
+      def path1_item: () -> State::Item
+
+      # @rbs () -> State::Item
+      def path2_item: () -> State::Item
+
+      # @rbs () -> Derivation
+      def derivations1: () -> Derivation
+
+      # @rbs () -> Derivation
+      def derivations2: () -> Derivation
+
+      private
+
+      # @rbs (Array[StateItem] state_items) -> Derivation
+      def _derivations: (Array[StateItem] state_items) -> Derivation
+
+      # @rbs (StateItem state_item, Grammar::Symbol sym) -> Derivation?
+      def find_derivation_for_symbol: (StateItem state_item, Grammar::Symbol sym) -> Derivation?
+    end
+  end
+end

data/sig/generated/lrama/counterexamples/node.rbs

@@ -0,0 +1,18 @@
+# Generated from lib/lrama/counterexamples/node.rb with RBS::Inline
+
+module Lrama
+  class Counterexamples
+    # @rbs generic E < Object -- Type of an element
+    class Node[E < Object]
+      attr_reader elem: E
+
+      attr_reader next_node: Node[E]?
+
+      # @rbs [E < Object] (Node[E] node) -> Array[E]
+      def self.to_a: [E < Object] (Node[E] node) -> Array[E]
+
+      # @rbs (E elem, Node[E]? next_node) -> void
+      def initialize: (E elem, Node[E]? next_node) -> void
+    end
+  end
+end

data/sig/generated/lrama/counterexamples/path.rbs

@@ -0,0 +1,23 @@
+# Generated from lib/lrama/counterexamples/path.rb with RBS::Inline
+
+module Lrama
+  class Counterexamples
+    class Path
+      @state_item: StateItem
+
+      @parent: Path?
+
+      attr_reader state_item: StateItem
+
+      attr_reader parent: Path?
+
+      # @rbs (StateItem state_item, Path? parent) -> void
+      def initialize: (StateItem state_item, Path? parent) -> void
+
+      # @rbs () -> ::String
+      def to_s: () -> ::String
+
+      alias inspect to_s
+    end
+  end
+end

data/sig/generated/lrama/counterexamples/state_item.rbs

@@ -0,0 +1,19 @@
+# Generated from lib/lrama/counterexamples/state_item.rb with RBS::Inline
+
+module Lrama
+  class Counterexamples
+    class StateItem
+      attr_reader id: Integer
+
+      attr_reader state: State
+
+      attr_reader item: State::Item
+
+      # @rbs (Integer id, State state, State::Item item) -> void
+      def initialize: (Integer id, State state, State::Item item) -> void
+
+      # @rbs () -> (:start | :transition | :production)
+      def type: () -> (:start | :transition | :production)
+    end
+  end
+end

data/sig/generated/lrama/counterexamples/triple.rbs

@@ -0,0 +1,32 @@
+# Generated from lib/lrama/counterexamples/triple.rb with RBS::Inline
+
+module Lrama
+  class Counterexamples
+    class Triple
+      attr_reader precise_lookahead_set: Bitmap::bitmap
+
+      alias l precise_lookahead_set
+
+      # @rbs (StateItem state_item, Bitmap::bitmap precise_lookahead_set) -> void
+      def initialize: (StateItem state_item, Bitmap::bitmap precise_lookahead_set) -> void
+
+      # @rbs () -> State
+      def state: () -> State
+
+      alias s state
+
+      # @rbs () -> State::Item
+      def item: () -> State::Item
+
+      alias itm item
+
+      # @rbs () -> StateItem
+      def state_item: () -> StateItem
+
+      # @rbs () -> ::String
+      def inspect: () -> ::String
+
+      alias to_s inspect
+    end
+  end
+end

data/sig/generated/lrama/counterexamples.rbs

@@ -0,0 +1,98 @@
+# Generated from lib/lrama/counterexamples.rb with RBS::Inline
+
+module Lrama
+  # See: https://www.cs.cornell.edu/andru/papers/cupex/cupex.pdf
+  #      4. Constructing Nonunifying Counterexamples
+  class Counterexamples
+    PathSearchTimeLimit: ::Integer
+
+    CumulativeTimeLimit: ::Integer
+
+    @states: States
+
+    @iterate_count: Integer
+
+    @total_duration: Float
+
+    @exceed_cumulative_time_limit: bool
+
+    @state_items: Hash[[ State, State::Item ], StateItem]
+
+    @triples: Hash[Integer, Triple]
+
+    @transitions: Hash[[ StateItem, Grammar::Symbol ], StateItem]
+
+    @reverse_transitions: Hash[[ StateItem, Grammar::Symbol ], Set[StateItem]]
+
+    @productions: Hash[StateItem, Set[StateItem]]
+
+    @reverse_productions: Hash[[ State, Grammar::Symbol ], Set[StateItem]]
+
+    @state_item_shift: Integer
+
+    attr_reader transitions: Hash[[ StateItem, Grammar::Symbol ], StateItem]
+
+    attr_reader productions: Hash[StateItem, Set[StateItem]]
+
+    # @rbs (States states) -> void
+    def initialize: (States states) -> void
+
+    # @rbs () -> "#<Counterexamples>"
+    def to_s: () -> "#<Counterexamples>"
+
+    alias inspect to_s
+
+    # @rbs (State conflict_state) -> Array[Example]
+    def compute: (State conflict_state) -> Array[Example]
+
+    private
+
+    # @rbs (State state, State::Item item) -> StateItem
+    def get_state_item: (State state, State::Item item) -> StateItem
+
+    # For optimization, create all StateItem in advance
+    # and use them by fetching an instance from `@state_items`.
+    # Do not create new StateItem instance in the shortest path search process
+    # to avoid miss hash lookup.
+    #
+    # @rbs () -> void
+    def setup_state_items: () -> void
+
+    # @rbs () -> void
+    def setup_transitions: () -> void
+
+    # @rbs () -> void
+    def setup_productions: () -> void
+
+    # For optimization, use same Triple if it's already created.
+    # Do not create new Triple instance anywhere else
+    # to avoid miss hash lookup.
+    #
+    # @rbs (StateItem state_item, Bitmap::bitmap precise_lookahead_set) -> Triple
+    def get_triple: (StateItem state_item, Bitmap::bitmap precise_lookahead_set) -> Triple
+
+    # @rbs (State conflict_state, State::ShiftReduceConflict conflict) -> Example
+    def shift_reduce_example: (State conflict_state, State::ShiftReduceConflict conflict) -> Example
+
+    # @rbs (State conflict_state, State::ReduceReduceConflict conflict) -> Example
+    def reduce_reduce_examples: (State conflict_state, State::ReduceReduceConflict conflict) -> Example
+
+    # @rbs (Array[StateItem]? reduce_state_items, State conflict_state, State::Item conflict_item) -> Array[StateItem]
+    def find_shift_conflict_shortest_path: (Array[StateItem]? reduce_state_items, State conflict_state, State::Item conflict_item) -> Array[StateItem]
+
+    # @rbs (StateItem target) -> Set[StateItem]
+    def reachable_state_items: (StateItem target) -> Set[StateItem]
+
+    # @rbs (State conflict_state, State::Item conflict_reduce_item, Grammar::Symbol conflict_term) -> ::Array[StateItem]?
+    def shortest_path: (State conflict_state, State::Item conflict_reduce_item, Grammar::Symbol conflict_term) -> ::Array[StateItem]?
+
+    # @rbs (State::Item item, Bitmap::bitmap current_l) -> Bitmap::bitmap
+    def follow_l: (State::Item item, Bitmap::bitmap current_l) -> Bitmap::bitmap
+
+    # @rbs [T] (String message) { -> T } -> T
+    def with_timeout: [T] (String message) { () -> T } -> T
+
+    # @rbs (Float|Integer duration) -> void
+    def increment_total_duration: (Float | Integer duration) -> void
+  end
+end

data/sig/generated/lrama/diagram.rbs

@@ -0,0 +1,34 @@
+# Generated from lib/lrama/diagram.rb with RBS::Inline
+
+module Lrama
+  class Diagram
+    # @rbs (IO out, Grammar grammar, String template_name) -> void
+    def self.render: (IO out, Grammar grammar, String template_name) -> void
+
+    # @rbs () -> bool
+    def self.require_railroad_diagrams: () -> bool
+
+    # @rbs (IO out, Grammar grammar, String template_name) -> void
+    def initialize: (IO out, Grammar grammar, String template_name) -> void
+
+    # @rbs () -> void
+    def render: () -> void
+
+    # @rbs () -> string
+    def default_style: () -> string
+
+    # @rbs () -> string
+    def diagrams: () -> string
+
+    private
+
+    # @rbs () -> string
+    def template_dir: () -> string
+
+    # @rbs () -> string
+    def template_file: () -> string
+
+    # @rbs (String name, RailroadDiagrams::Diagram diagram, String result) -> void
+    def add_diagram: (String name, RailroadDiagrams::Diagram diagram, String result) -> void
+  end
+end

data/sig/generated/lrama/digraph.rbs

@@ -1,10 +1,30 @@
 # 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)
+  # Digraph Algorithm 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`
+  # Digraph is an algorithm for graph data structure.
+  # The algorithm efficiently traverses SCC (Strongly Connected Component) of graph
+  # and merges nodes attributes within the same SCC.
+  #
+  # `compute_read_sets` and `compute_follow_sets` have the same structure.
+  # Graph of gotos and attributes of gotos are given then compute propagated attributes for each node.
+  #
+  # In the case of `compute_read_sets`:
+  #
+  # * Set of gotos is nodes of graph
+  # * `reads_relation` is edges of graph
+  # * `direct_read_sets` is nodes attributes
+  #
+  # In the case of `compute_follow_sets`:
+  #
+  # * Set of gotos is nodes of graph
+  # * `includes_relation` is edges of graph
+  # * `read_sets` is nodes attributes
+  #
+  #
+  # @rbs generic X < Object -- Type of a node
+  # @rbs generic Y < _Or    -- Type of attribute sets assigned to a node which should support merge operation (#| method)
   class Digraph[X < Object, Y < _Or]
     interface _Or
       def |: (self) -> self
@@ -22,9 +42,9 @@ module Lrama
 
     @result: Hash[X, Y]
 
-    # @rbs sets: Array[X]
-    # @rbs relation: Hash[X, Array[X]]
-    # @rbs base_function: Hash[X, Y]
+    # @rbs sets: Array[X] -- Nodes of graph
+    # @rbs relation: Hash[X, Array[X]] -- Edges of graph
+    # @rbs base_function: Hash[X, Y] -- Attributes of nodes
     # @rbs return: void
     def initialize: (Array[X] sets, Hash[X, Array[X]] relation, Hash[X, Y] base_function) -> void
 

data/sig/generated/lrama/erb.rbs

@@ -0,0 +1,14 @@
+# Generated from lib/lrama/erb.rb with RBS::Inline
+
+module Lrama
+  class ERB
+    # @rbs (String file, **untyped kwargs) -> String
+    def self.render: (String file, **untyped kwargs) -> String
+
+    # @rbs (String file) -> void
+    def initialize: (String file) -> void
+
+    # @rbs (**untyped kwargs) -> String
+    def render: (**untyped kwargs) -> String
+  end
+end

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

@@ -0,0 +1,16 @@
+# Generated from lib/lrama/grammar/auxiliary.rb with RBS::Inline
+
+module Lrama
+  class Grammar
+    # Grammar file information not used by States but by Output
+    class Auxiliary
+      attr_accessor prologue_first_lineno: Integer?
+
+      attr_accessor prologue: String?
+
+      attr_accessor epilogue_first_lineno: Integer?
+
+      attr_accessor epilogue: String?
+    end
+  end
+end

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

@@ -3,29 +3,35 @@
 module Lrama
   class Grammar
     class Binding
-      @actual_args: Array[Lexer::Token]
+      @actual_args: Array[Lexer::Token::Base]
 
-      @param_to_arg: Hash[String, Lexer::Token]
+      @param_to_arg: Hash[String, Lexer::Token::Base]
 
-      # @rbs (Array[Lexer::Token] params, Array[Lexer::Token] actual_args) -> void
-      def initialize: (Array[Lexer::Token] params, Array[Lexer::Token] actual_args) -> void
+      # @rbs (Array[Lexer::Token::Base] params, Array[Lexer::Token::Base] actual_args) -> void
+      def initialize: (Array[Lexer::Token::Base] params, Array[Lexer::Token::Base] actual_args) -> void
 
-      # @rbs (Lexer::Token sym) -> Lexer::Token
-      def resolve_symbol: (Lexer::Token sym) -> Lexer::Token
+      # @rbs (Lexer::Token::Base sym) -> Lexer::Token::Base
+      def resolve_symbol: (Lexer::Token::Base sym) -> Lexer::Token::Base
 
       # @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) -> Lexer::Token::InstantiateRule
+      def create_instantiate_rule: (Lexer::Token::InstantiateRule sym) -> Lexer::Token::InstantiateRule
 
-      # @rbs (Lexer::Token::InstantiateRule sym) -> Array[Lexer::Token]
-      def resolved_args: (Lexer::Token::InstantiateRule sym) -> Array[Lexer::Token]
+      # @rbs (Array[Lexer::Token::Base]) -> Array[Lexer::Token::Base]
+      def resolve_args: (Array[Lexer::Token::Base]) -> Array[Lexer::Token::Base]
 
-      # @rbs (Lexer::Token sym) -> Lexer::Token
-      def param_to_arg: (Lexer::Token sym) -> Lexer::Token
+      # @rbs (Lexer::Token::Base sym) -> Lexer::Token::Base
+      def find_arg_for_param: (Lexer::Token::Base sym) -> Lexer::Token::Base
+
+      # @rbs (Array[Lexer::Token::Base] params, Array[Lexer::Token::Base] actual_args) -> Hash[String, Lexer::Token::Base?]
+      def build_param_to_arg: (Array[Lexer::Token::Base] params, Array[Lexer::Token::Base] actual_args) -> Hash[String, Lexer::Token::Base?]
+
+      # @rbs (Lexer::Token::InstantiateRule token) -> String
+      def format_args: (Lexer::Token::InstantiateRule token) -> String
 
       # @rbs (Lexer::Token::InstantiateRule token) -> Array[String]
       def token_to_args_s_values: (Lexer::Token::InstantiateRule token) -> Array[String]

data/sig/generated/lrama/grammar/code/destructor_code.rbs

@@ -0,0 +1,26 @@
+# Generated from lib/lrama/grammar/code/destructor_code.rb with RBS::Inline
+
+module Lrama
+  class Grammar
+    class Code
+      class DestructorCode < Code
+        @tag: Lexer::Token::Tag
+
+        # @rbs (type: ::Symbol, token_code: Lexer::Token::UserCode, tag: Lexer::Token::Tag) -> void
+        def initialize: (type: ::Symbol, token_code: Lexer::Token::UserCode, tag: Lexer::Token::Tag) -> void
+
+        private
+
+        # * ($$) *yyvaluep
+        # * (@$) *yylocationp
+        # * ($:$) error
+        # * ($1) error
+        # * (@1) error
+        # * ($:1) error
+        #
+        # @rbs (Reference ref) -> (String | bot)
+        def reference_to_c: (Reference ref) -> (String | bot)
+      end
+    end
+  end
+end

data/sig/{lrama → generated/lrama}/grammar/code/initial_action_code.rbs

@@ -1,3 +1,5 @@
+# Generated from lib/lrama/grammar/code/initial_action_code.rb with RBS::Inline
+
 module Lrama
   class Grammar
     class Code
@@ -6,8 +8,12 @@ module Lrama
 
         # * ($$) yylval
         # * (@$) yylloc
+        # * ($:$) error
         # * ($1) error
         # * (@1) error
+        # * ($:1) error
+        #
+        # @rbs (Reference ref) -> (String | bot)
         def reference_to_c: (Reference ref) -> (String | bot)
       end
     end

data/sig/{lrama → generated/lrama}/grammar/code/no_reference_code.rbs

@@ -1,3 +1,5 @@
+# Generated from lib/lrama/grammar/code/no_reference_code.rb with RBS::Inline
+
 module Lrama
   class Grammar
     class Code
@@ -6,8 +8,12 @@ module Lrama
 
         # * ($$) error
         # * (@$) error
+        # * ($:$) error
         # * ($1) error
         # * (@1) error
+        # * ($:1) error
+        #
+        # @rbs (Reference ref) -> bot
         def reference_to_c: (Reference ref) -> bot
       end
     end

data/sig/generated/lrama/grammar/code/printer_code.rbs

@@ -0,0 +1,26 @@
+# Generated from lib/lrama/grammar/code/printer_code.rb with RBS::Inline
+
+module Lrama
+  class Grammar
+    class Code
+      class PrinterCode < Code
+        @tag: Lexer::Token::Tag
+
+        # @rbs (type: ::Symbol, token_code: Lexer::Token::UserCode, tag: Lexer::Token::Tag) -> void
+        def initialize: (type: ::Symbol, token_code: Lexer::Token::UserCode, tag: Lexer::Token::Tag) -> void
+
+        private
+
+        # * ($$) *yyvaluep
+        # * (@$) *yylocationp
+        # * ($:$) error
+        # * ($1) error
+        # * (@1) error
+        # * ($:1) error
+        #
+        # @rbs (Reference ref) -> (String | bot)
+        def reference_to_c: (Reference ref) -> (String | bot)
+      end
+    end
+  end
+end