lrama 0.7.0 → 0.7.1

data/lib/lrama/grammar/{parameterizing_rule → parameterized}/resolver.rb

@@ -1,40 +1,49 @@
+# rbs_inline: enabled
 # frozen_string_literal: true
 
 module Lrama
   class Grammar
-    class ParameterizingRule
+    class Parameterized
       class Resolver
-        attr_accessor :rules, :created_lhs_list
+        attr_accessor :rules #: Array[Rule]
+        attr_accessor :created_lhs_list #: Array[Lexer::Token::Base]
 
+        # @rbs () -> void
         def initialize
           @rules = []
           @created_lhs_list = []
         end
 
-        def add_parameterizing_rule(rule)
+        # @rbs (Rule rule) -> Array[Rule]
+        def add_rule(rule)
           @rules << rule
         end
 
+        # @rbs (Lexer::Token::InstantiateRule token) -> Rule?
         def find_rule(token)
           select_rules(@rules, token).last
         end
 
+        # @rbs (Lexer::Token::Base token) -> Rule?
         def find_inline(token)
-          @rules.reverse.find { |rule| rule.name == token.s_value && rule.is_inline }
+          @rules.reverse.find { |rule| rule.name == token.s_value && rule.inline? }
         end
 
+        # @rbs (String lhs_s_value) -> Lexer::Token::Base?
         def created_lhs(lhs_s_value)
           @created_lhs_list.reverse.find { |created_lhs| created_lhs.s_value == lhs_s_value }
         end
 
+        # @rbs () -> Array[Rule]
         def redefined_rules
           @rules.select { |rule| @rules.count { |r| r.name == rule.name && r.required_parameters_count == rule.required_parameters_count } > 1 }
         end
 
         private
 
+        # @rbs (Array[Rule] rules, Lexer::Token::InstantiateRule token) -> Array[Rule]
         def select_rules(rules, token)
-          rules = select_not_inline_rules(rules)
+          rules = reject_inline_rules(rules)
           rules = select_rules_by_name(rules, token.rule_name)
           rules = rules.select { |rule| rule.required_parameters_count == token.args_count }
           if rules.empty?
@@ -44,14 +53,16 @@ module Lrama
           end
         end
 
-        def select_not_inline_rules(rules)
-          rules.select { |rule| !rule.is_inline }
+        # @rbs (Array[Rule] rules) -> Array[Rule]
+        def reject_inline_rules(rules)
+          rules.reject(&:inline?)
         end
 
+        # @rbs (Array[Rule] rules, String rule_name) -> Array[Rule]
         def select_rules_by_name(rules, rule_name)
           rules = rules.select { |rule| rule.name == rule_name }
           if rules.empty?
-            raise "Parameterizing rule does not exist. `#{rule_name}`"
+            raise "Parameterized rule does not exist. `#{rule_name}`"
           else
             rules
           end

data/lib/lrama/grammar/{parameterizing_rule → parameterized}/rhs.rb

@@ -1,17 +1,22 @@
+# rbs_inline: enabled
 # frozen_string_literal: true
 
 module Lrama
   class Grammar
-    class ParameterizingRule
+    class Parameterized
       class Rhs
-        attr_accessor :symbols, :user_code, :precedence_sym
+        attr_accessor :symbols #: Array[Lexer::Token::Base]
+        attr_accessor :user_code #: Lexer::Token::UserCode?
+        attr_accessor :precedence_sym #: Grammar::Symbol?
 
+        # @rbs () -> void
         def initialize
           @symbols = []
           @user_code = nil
           @precedence_sym = nil
         end
 
+        # @rbs (Grammar::Binding bindings) -> Lexer::Token::UserCode?
         def resolve_user_code(bindings)
           return unless user_code
 

data/lib/lrama/grammar/parameterized/rule.rb

@@ -0,0 +1,36 @@
+# rbs_inline: enabled
+# frozen_string_literal: true
+
+module Lrama
+  class Grammar
+    class Parameterized
+      class Rule
+        attr_reader :name #: String
+        attr_reader :parameters #: Array[Lexer::Token::Base]
+        attr_reader :rhs #: Array[Rhs]
+        attr_reader :required_parameters_count #: Integer
+        attr_reader :tag #: Lexer::Token::Tag?
+
+        # @rbs (String name, Array[Lexer::Token::Base] parameters, Array[Rhs] rhs, tag: Lexer::Token::Tag?, is_inline: bool) -> void
+        def initialize(name, parameters, rhs, tag: nil, is_inline: false)
+          @name = name
+          @parameters = parameters
+          @rhs = rhs
+          @tag = tag
+          @is_inline = is_inline
+          @required_parameters_count = parameters.count
+        end
+
+        # @rbs () -> String
+        def to_s
+          "#{@name}(#{@parameters.map(&:s_value).join(', ')})"
+        end
+
+        # @rbs () -> bool
+        def inline?
+          @is_inline
+        end
+      end
+    end
+  end
+end

data/lib/lrama/grammar/parameterized.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require_relative 'parameterized/resolver'
+require_relative 'parameterized/rhs'
+require_relative 'parameterized/rule'

data/lib/lrama/grammar/percent_code.rb

@@ -1,10 +1,21 @@
+# rbs_inline: enabled
 # frozen_string_literal: true
 
 module Lrama
   class Grammar
     class PercentCode
-      attr_reader :name, :code
+      # 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!
+      #   @name: String
+      #   @code: String
 
+      attr_reader :name #: String
+      attr_reader :code #: String
+
+      # @rbs (String name, String code) -> void
       def initialize(name, code)
         @name = name
         @code = code

data/lib/lrama/grammar/precedence.rb

@@ -1,13 +1,55 @@
+# rbs_inline: enabled
 # frozen_string_literal: true
 
 module Lrama
   class Grammar
-    class Precedence < Struct.new(:type, :precedence, keyword_init: true)
+    class Precedence < Struct.new(:type, :symbol, :precedence, :s_value, :lineno, keyword_init: true)
       include Comparable
+      # @rbs!
+      #   type type_enum = :left | :right | :nonassoc | :precedence
+      #
+      #   attr_accessor type: type_enum
+      #   attr_accessor symbol: Grammar::Symbol
+      #   attr_accessor precedence: Integer
+      #   attr_accessor s_value: String
+      #   attr_accessor lineno: Integer
+      #
+      #   def initialize: (?type: type_enum, ?symbol: Grammar::Symbol, ?precedence: Integer, ?s_value: ::String, ?lineno: Integer) -> void
 
+      attr_reader :used_by_lalr #: Array[State::ResolvedConflict]
+      attr_reader :used_by_ielr #: Array[State::ResolvedConflict]
+
+      # @rbs (Precedence other) -> Integer
       def <=>(other)
         self.precedence <=> other.precedence
       end
+
+      # @rbs (State::ResolvedConflict resolved_conflict) -> void
+      def mark_used_by_lalr(resolved_conflict)
+        @used_by_lalr ||= [] #: Array[State::ResolvedConflict]
+        @used_by_lalr << resolved_conflict
+      end
+
+      # @rbs (State::ResolvedConflict resolved_conflict) -> void
+      def mark_used_by_ielr(resolved_conflict)
+        @used_by_ielr ||= [] #: Array[State::ResolvedConflict]
+        @used_by_ielr << resolved_conflict
+      end
+
+      # @rbs () -> bool
+      def used_by?
+        used_by_lalr? || used_by_ielr?
+      end
+
+      # @rbs () -> bool
+      def used_by_lalr?
+        !@used_by_lalr.nil? && !@used_by_lalr.empty?
+      end
+
+      # @rbs () -> bool
+      def used_by_ielr?
+        !@used_by_ielr.nil? && !@used_by_ielr.empty?
+      end
     end
   end
 end

data/lib/lrama/grammar/printer.rb

@@ -1,8 +1,17 @@
+# rbs_inline: enabled
 # frozen_string_literal: true
 
 module Lrama
   class Grammar
     class Printer < Struct.new(:ident_or_tags, :token_code, :lineno, keyword_init: true)
+      # @rbs!
+      #   attr_accessor ident_or_tags: Array[Lexer::Token::Ident|Lexer::Token::Tag]
+      #   attr_accessor token_code: Lexer::Token::UserCode
+      #   attr_accessor lineno: Integer
+      #
+      #   def initialize: (?ident_or_tags: Array[Lexer::Token::Ident|Lexer::Token::Tag], ?token_code: Lexer::Token::UserCode, ?lineno: Integer) -> void
+
+      # @rbs (Lexer::Token::Tag tag) -> String
       def translated_code(tag)
         Code::PrinterCode.new(type: :printer, token_code: token_code, tag: tag).translated_code
       end

data/lib/lrama/grammar/reference.rb

@@ -1,3 +1,4 @@
+# rbs_inline: enabled
 # frozen_string_literal: true
 
 module Lrama
@@ -8,6 +9,18 @@ module Lrama
     # index: Integer
     # ex_tag: "$<tag>1" (Optional)
     class Reference < Struct.new(:type, :name, :number, :index, :ex_tag, :first_column, :last_column, keyword_init: true)
+      # @rbs!
+      #   attr_accessor type: ::Symbol
+      #   attr_accessor name: String
+      #   attr_accessor number: Integer
+      #   attr_accessor index: Integer
+      #   attr_accessor ex_tag: Lexer::Token::Base?
+      #   attr_accessor first_column: Integer
+      #   attr_accessor last_column: Integer
+      #
+      #   def initialize: (type: ::Symbol, ?name: String, ?number: Integer, ?index: Integer, ?ex_tag: Lexer::Token::Base?, first_column: Integer, last_column: Integer) -> void
+
+      # @rbs () -> (String|Integer)
       def value
         name || number
       end

data/lib/lrama/grammar/rule.rb

@@ -1,11 +1,38 @@
+# rbs_inline: enabled
 # frozen_string_literal: true
 
 module Lrama
   class Grammar
     # _rhs holds original RHS element. Use rhs to refer to Symbol.
     class Rule < Struct.new(:id, :_lhs, :lhs, :lhs_tag, :_rhs, :rhs, :token_code, :position_in_original_rule_rhs, :nullable, :precedence_sym, :lineno, keyword_init: true)
-      attr_accessor :original_rule
+      # @rbs!
+      #
+      #   interface _DelegatedMethods
+      #     def lhs: -> Grammar::Symbol
+      #     def rhs: -> Array[Grammar::Symbol]
+      #   end
+      #
+      #   attr_accessor id: Integer
+      #   attr_accessor _lhs: Lexer::Token::Base
+      #   attr_accessor lhs: Grammar::Symbol
+      #   attr_accessor lhs_tag: Lexer::Token::Tag?
+      #   attr_accessor _rhs: Array[Lexer::Token::Base]
+      #   attr_accessor rhs: Array[Grammar::Symbol]
+      #   attr_accessor token_code: Lexer::Token::UserCode?
+      #   attr_accessor position_in_original_rule_rhs: Integer
+      #   attr_accessor nullable: bool
+      #   attr_accessor precedence_sym: Grammar::Symbol?
+      #   attr_accessor lineno: Integer?
+      #
+      #   def initialize: (
+      #     ?id: Integer, ?_lhs: Lexer::Token::Base?, ?lhs: Lexer::Token::Base, ?lhs_tag: Lexer::Token::Tag?, ?_rhs: Array[Lexer::Token::Base], ?rhs: Array[Grammar::Symbol],
+      #     ?token_code: Lexer::Token::UserCode?, ?position_in_original_rule_rhs: Integer?, ?nullable: bool,
+      #     ?precedence_sym: Grammar::Symbol?, ?lineno: Integer?
+      #   ) -> void
 
+      attr_accessor :original_rule #: Rule
+
+      # @rbs (Rule other) -> bool
       def ==(other)
         self.class == other.class &&
         self.lhs == other.lhs &&
@@ -18,12 +45,14 @@ module Lrama
         self.lineno == other.lineno
       end
 
+      # @rbs () -> String
       def display_name
         l = lhs.id.s_value
         r = empty_rule? ? "ε" : rhs.map {|r| r.id.s_value }.join(" ")
         "#{l} -> #{r}"
       end
 
+      # @rbs () -> String
       def display_name_without_action
         l = lhs.id.s_value
         r = empty_rule? ? "ε" : rhs.map do |r|
@@ -33,7 +62,18 @@ module Lrama
         "#{l} -> #{r}"
       end
 
+      # @rbs () -> (RailroadDiagrams::Skip | RailroadDiagrams::Sequence)
+      def to_diagrams
+        if rhs.empty?
+          RailroadDiagrams::Skip.new
+        else
+          RailroadDiagrams::Sequence.new(*rhs_to_diagram)
+        end
+      end
+
       # Used by #user_actions
+      #
+      # @rbs () -> String
       def as_comment
         l = lhs.id.s_value
         r = empty_rule? ? "%empty" : rhs.map(&:display_name).join(" ")
@@ -41,35 +81,55 @@ module Lrama
         "#{l}: #{r}"
       end
 
+      # @rbs () -> String
       def with_actions
         "#{display_name} {#{token_code&.s_value}}"
       end
 
       # opt_nl: ε     <-- empty_rule
       #       | '\n'  <-- not empty_rule
+      #
+      # @rbs () -> bool
       def empty_rule?
         rhs.empty?
       end
 
+      # @rbs () -> Precedence?
       def precedence
         precedence_sym&.precedence
       end
 
+      # @rbs () -> bool
       def initial_rule?
         id == 0
       end
 
+      # @rbs () -> String?
       def translated_code
         return nil unless token_code
 
         Code::RuleAction.new(type: :rule_action, token_code: token_code, rule: self).translated_code
       end
 
+      # @rbs () -> bool
       def contains_at_reference?
         return false unless token_code
 
         token_code.references.any? {|r| r.type == :at }
       end
+
+      private
+
+      # @rbs () -> Array[(RailroadDiagrams::Terminal | RailroadDiagrams::NonTerminal)]
+      def rhs_to_diagram
+        rhs.map do |r|
+          if r.term
+            RailroadDiagrams::Terminal.new(r.id.s_value)
+          else
+            RailroadDiagrams::NonTerminal.new(r.id.s_value)
+          end
+        end
+      end
     end
   end
 end