lrama 0.7.0 → 0.7.1

data/lib/lrama/diagram.rb

@@ -0,0 +1,77 @@
+# rbs_inline: enabled
+# frozen_string_literal: true
+
+module Lrama
+  class Diagram
+    class << self
+      # @rbs (IO out, Grammar grammar, String template_name) -> void
+      def render(out:, grammar:, template_name: 'diagram/diagram.html')
+        return unless require_railroad_diagrams
+        new(out: out, grammar: grammar, template_name: template_name).render
+      end
+
+      # @rbs () -> bool
+      def require_railroad_diagrams
+        require "railroad_diagrams"
+        true
+      rescue LoadError
+        warn "railroad_diagrams is not installed. Please run `bundle install`."
+        false
+      end
+    end
+
+    # @rbs (IO out, Grammar grammar, String template_name) -> void
+    def initialize(out:, grammar:, template_name: 'diagram/diagram.html')
+      @grammar = grammar
+      @out = out
+      @template_name = template_name
+    end
+
+    # @rbs () -> void
+    def render
+      RailroadDiagrams::TextDiagram.set_formatting(RailroadDiagrams::TextDiagram::PARTS_UNICODE)
+      @out << ERB.render(template_file, output: self)
+    end
+
+    # @rbs () -> string
+    def default_style
+      RailroadDiagrams::Style::default_style
+    end
+
+    # @rbs () -> string
+    def diagrams
+      result = +''
+      @grammar.unique_rule_s_values.each do |s_value|
+        diagrams =
+          @grammar.select_rules_by_s_value(s_value).map { |r| r.to_diagrams }
+        add_diagram(
+          s_value,
+          RailroadDiagrams::Diagram.new(
+            RailroadDiagrams::Choice.new(0, *diagrams),
+          ),
+          result
+        )
+      end
+      result
+    end
+
+    private
+
+    # @rbs () -> string
+    def template_dir
+      File.expand_path('../../template', __dir__)
+    end
+
+    # @rbs () -> string
+    def template_file
+      File.join(template_dir, @template_name)
+    end
+
+    # @rbs (String name, RailroadDiagrams::Diagram diagram, String result) -> void
+    def add_diagram(name, diagram, result)
+      result << "\n<h2 class=\"diagram-header\">#{RailroadDiagrams.escape_html(name)}</h2>"
+      diagram.write_svg(result.method(:<<))
+      result << "\n"
+    end
+  end
+end

data/lib/lrama/digraph.rb

@@ -2,13 +2,34 @@
 # frozen_string_literal: true
 
 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
-    # TODO: rbs-inline 0.10.0 doesn't support instance variables.
+    # 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!
     #   interface _Or
@@ -21,9 +42,9 @@ module Lrama
     #   @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 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(sets, relation, base_function)
 

data/lib/lrama/erb.rb

@@ -0,0 +1,29 @@
+# rbs_inline: enabled
+# frozen_string_literal: true
+
+require "erb"
+
+module Lrama
+  class ERB
+    # @rbs (String file, **untyped kwargs) -> String
+    def self.render(file, **kwargs)
+      new(file).render(**kwargs)
+    end
+
+    # @rbs (String file) -> void
+    def initialize(file)
+      input = File.read(file)
+      if ::ERB.instance_method(:initialize).parameters.last.first == :key
+        @erb = ::ERB.new(input, trim_mode: '-')
+      else
+        @erb = ::ERB.new(input, nil, '-') # steep:ignore UnexpectedPositionalArgument
+      end
+      @erb.filename = file
+    end
+
+    # @rbs (**untyped kwargs) -> String
+    def render(**kwargs)
+      @erb.result_with_hash(kwargs)
+    end
+  end
+end

data/lib/lrama/grammar/auxiliary.rb

@@ -1,9 +1,14 @@
+# rbs_inline: enabled
 # frozen_string_literal: true
 
 module Lrama
   class Grammar
     # Grammar file information not used by States but by Output
-    class Auxiliary < Struct.new(:prologue_first_lineno, :prologue, :epilogue_first_lineno, :epilogue, keyword_init: true)
+    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/lib/lrama/grammar/binding.rb

@@ -4,51 +4,63 @@
 module Lrama
   class Grammar
     class Binding
-      # @rbs @actual_args: Array[Lexer::Token]
-      # @rbs @param_to_arg: Hash[String, Lexer::Token]
+      # @rbs @actual_args: Array[Lexer::Token::Base]
+      # @rbs @param_to_arg: Hash[String, Lexer::Token::Base]
 
-      # @rbs (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(params, actual_args)
         @actual_args = actual_args
-        @param_to_arg = map_params_to_args(params, @actual_args)
+        @param_to_arg = build_param_to_arg(params, @actual_args)
       end
 
-      # @rbs (Lexer::Token sym) -> Lexer::Token
+      # @rbs (Lexer::Token::Base sym) -> Lexer::Token::Base
       def resolve_symbol(sym)
-        if sym.is_a?(Lexer::Token::InstantiateRule)
-          Lrama::Lexer::Token::InstantiateRule.new(
-            s_value: sym.s_value, location: sym.location, args: resolved_args(sym), lhs_tag: sym.lhs_tag
-          )
-        else
-          param_to_arg(sym)
-        end
+        return create_instantiate_rule(sym) if sym.is_a?(Lexer::Token::InstantiateRule)
+        find_arg_for_param(sym)
       end
 
       # @rbs (Lexer::Token::InstantiateRule token) -> String
       def concatenated_args_str(token)
-        "#{token.rule_name}_#{token_to_args_s_values(token).join('_')}"
+        "#{token.rule_name}_#{format_args(token)}"
       end
 
       private
 
-      # @rbs (Array[Lexer::Token] params, Array[Lexer::Token] actual_args) -> Hash[String, Lexer::Token]
-      def map_params_to_args(params, actual_args)
-        params.zip(actual_args).map do |param, arg|
-          [param.s_value, arg]
-        end.to_h
+      # @rbs (Lexer::Token::InstantiateRule sym) -> Lexer::Token::InstantiateRule
+      def create_instantiate_rule(sym)
+        Lrama::Lexer::Token::InstantiateRule.new(
+          s_value: sym.s_value,
+          location: sym.location,
+          args: resolve_args(sym.args),
+          lhs_tag: sym.lhs_tag
+        )
       end
 
-      # @rbs (Lexer::Token::InstantiateRule sym) -> Array[Lexer::Token]
-      def resolved_args(sym)
-        sym.args.map { |arg| resolve_symbol(arg) }
+      # @rbs (Array[Lexer::Token::Base]) -> Array[Lexer::Token::Base]
+      def resolve_args(args)
+        args.map { |arg| resolve_symbol(arg) }
       end
 
-      # @rbs (Lexer::Token sym) -> Lexer::Token
-      def param_to_arg(sym)
-        if (arg = @param_to_arg[sym.s_value].dup)
+      # @rbs (Lexer::Token::Base sym) -> Lexer::Token::Base
+      def find_arg_for_param(sym)
+        if (arg = @param_to_arg[sym.s_value]&.dup)
           arg.alias_name = sym.alias_name
+          arg
+        else
+          sym
         end
-        arg || sym
+      end
+
+      # @rbs (Array[Lexer::Token::Base] params, Array[Lexer::Token::Base] actual_args) -> Hash[String, Lexer::Token::Base?]
+      def build_param_to_arg(params, actual_args)
+        params.zip(actual_args).map do |param, arg|
+          [param.s_value, arg]
+        end.to_h
+      end
+
+      # @rbs (Lexer::Token::InstantiateRule token) -> String
+      def format_args(token)
+        token_to_args_s_values(token).join('_')
       end
 
       # @rbs (Lexer::Token::InstantiateRule token) -> Array[String]

data/lib/lrama/grammar/code/destructor_code.rb

@@ -1,9 +1,18 @@
+# rbs_inline: enabled
 # frozen_string_literal: true
 
 module Lrama
   class Grammar
     class Code
       class DestructorCode < 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!
+        #   @tag: Lexer::Token::Tag
+
+        # @rbs (type: ::Symbol, token_code: Lexer::Token::UserCode, tag: Lexer::Token::Tag) -> void
         def initialize(type:, token_code:, tag:)
           super(type: type, token_code: token_code)
           @tag = tag
@@ -17,6 +26,8 @@ module Lrama
         # * ($1) error
         # * (@1) error
         # * ($:1) error
+        #
+        # @rbs (Reference ref) -> (String | bot)
         def reference_to_c(ref)
           case
           when ref.type == :dollar && ref.name == "$" # $$

data/lib/lrama/grammar/code/initial_action_code.rb

@@ -1,3 +1,4 @@
+# rbs_inline: enabled
 # frozen_string_literal: true
 
 module Lrama
@@ -12,6 +13,8 @@ module Lrama
         # * ($1) error
         # * (@1) error
         # * ($:1) error
+        #
+        # @rbs (Reference ref) -> (String | bot)
         def reference_to_c(ref)
           case
           when ref.type == :dollar && ref.name == "$" # $$

data/lib/lrama/grammar/code/no_reference_code.rb

@@ -1,3 +1,4 @@
+# rbs_inline: enabled
 # frozen_string_literal: true
 
 module Lrama
@@ -12,6 +13,8 @@ module Lrama
         # * ($1) error
         # * (@1) error
         # * ($:1) error
+        #
+        # @rbs (Reference ref) -> bot
         def reference_to_c(ref)
           case
           when ref.type == :dollar # $$, $n

data/lib/lrama/grammar/code/printer_code.rb

@@ -1,9 +1,18 @@
+# rbs_inline: enabled
 # frozen_string_literal: true
 
 module Lrama
   class Grammar
     class Code
       class PrinterCode < 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!
+        #   @tag: Lexer::Token::Tag
+
+        # @rbs (type: ::Symbol, token_code: Lexer::Token::UserCode, tag: Lexer::Token::Tag) -> void
         def initialize(type:, token_code:, tag:)
           super(type: type, token_code: token_code)
           @tag = tag
@@ -17,6 +26,8 @@ module Lrama
         # * ($1) error
         # * (@1) error
         # * ($:1) error
+        #
+        # @rbs (Reference ref) -> (String | bot)
         def reference_to_c(ref)
           case
           when ref.type == :dollar && ref.name == "$" # $$

data/lib/lrama/grammar/code/rule_action.rb

@@ -1,9 +1,18 @@
+# rbs_inline: enabled
 # frozen_string_literal: true
 
 module Lrama
   class Grammar
     class Code
       class RuleAction < 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!
+        #   @rule: Rule
+
+        # @rbs (type: ::Symbol, token_code: Lexer::Token::UserCode, rule: Rule) -> void
         def initialize(type:, token_code:, rule:)
           super(type: type, token_code: token_code)
           @rule = rule
@@ -38,6 +47,8 @@ module Lrama
         # "Position in grammar"                   $1
         # "Index for yyvsp"                        0
         # "$:n"                                  $:1
+        #
+        # @rbs (Reference ref) -> String
         def reference_to_c(ref)
           case
           when ref.type == :dollar && ref.name == "$" # $$
@@ -66,6 +77,7 @@ module Lrama
           end
         end
 
+        # @rbs () -> Integer
         def position_in_rhs
           # If rule is not derived rule, User Code is only action at
           # the end of rule RHS. In such case, the action is located on
@@ -74,15 +86,20 @@ module Lrama
         end
 
         # If this is midrule action, RHS is an RHS of the original rule.
+        #
+        # @rbs () -> Array[Grammar::Symbol]
         def rhs
           (@rule.original_rule || @rule).rhs
         end
 
         # Unlike `rhs`, LHS is always an LHS of the rule.
+        #
+        # @rbs () -> Grammar::Symbol
         def lhs
           @rule.lhs
         end
 
+        # @rbs (Reference ref) -> bot
         def raise_tag_not_found_error(ref)
           raise "Tag is not specified for '$#{ref.value}' in '#{@rule.display_name}'"
         end

data/lib/lrama/grammar/code.rb

@@ -1,3 +1,4 @@
+# rbs_inline: enabled
 # frozen_string_literal: true
 
 require "forwardable"
@@ -10,17 +11,28 @@ require_relative "code/rule_action"
 module Lrama
   class Grammar
     class Code
+      # @rbs!
+      #
+      #  # delegated
+      #  def s_value: -> String
+      #  def line: -> Integer
+      #  def column: -> Integer
+      #  def references: -> Array[Lrama::Grammar::Reference]
+
       extend Forwardable
 
       def_delegators "token_code", :s_value, :line, :column, :references
 
-      attr_reader :type, :token_code
+      attr_reader :type #: ::Symbol
+      attr_reader :token_code #: Lexer::Token::UserCode
 
+      # @rbs (type: ::Symbol, token_code: Lexer::Token::UserCode) -> void
       def initialize(type:, token_code:)
         @type = type
         @token_code = token_code
       end
 
+      # @rbs (Code other) -> bool
       def ==(other)
         self.class == other.class &&
         self.type == other.type &&
@@ -28,6 +40,8 @@ module Lrama
       end
 
       # $$, $n, @$, @n are translated to C code
+      #
+      # @rbs () -> String
       def translated_code
         t_code = s_value.dup
 
@@ -45,6 +59,7 @@ module Lrama
 
       private
 
+      # @rbs (Lrama::Grammar::Reference ref) -> bot
       def reference_to_c(ref)
         raise NotImplementedError.new("#reference_to_c is not implemented")
       end

data/lib/lrama/grammar/counter.rb

@@ -1,12 +1,22 @@
+# rbs_inline: enabled
 # frozen_string_literal: true
 
 module Lrama
   class Grammar
     class Counter
+      # 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!
+      #   @number: Integer
+
+      # @rbs (Integer number) -> void
       def initialize(number)
         @number = number
       end
 
+      # @rbs () -> Integer
       def increment
         n = @number
         @number += 1

data/lib/lrama/grammar/destructor.rb

@@ -1,8 +1,21 @@
+# rbs_inline: enabled
 # frozen_string_literal: true
 
 module Lrama
   class Grammar
-    class Destructor < Struct.new(:ident_or_tags, :token_code, :lineno, keyword_init: true)
+    class Destructor
+      attr_reader :ident_or_tags #: Array[Lexer::Token::Ident|Lexer::Token::Tag]
+      attr_reader :token_code #: Lexer::Token::UserCode
+      attr_reader :lineno #: Integer
+
+      # @rbs (ident_or_tags: Array[Lexer::Token::Ident|Lexer::Token::Tag], token_code: Lexer::Token::UserCode, lineno: Integer) -> void
+      def initialize(ident_or_tags:, token_code:, lineno:)
+        @ident_or_tags = ident_or_tags
+        @token_code = token_code
+        @lineno = lineno
+      end
+
+      # @rbs (Lexer::Token::Tag tag) -> String
       def translated_code(tag)
         Code::DestructorCode.new(type: :destructor, token_code: token_code, tag: tag).translated_code
       end

data/lib/lrama/grammar/error_token.rb

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

data/lib/lrama/grammar/inline/resolver.rb

@@ -0,0 +1,80 @@
+# rbs_inline: enabled
+# frozen_string_literal: true
+
+module Lrama
+  class Grammar
+    class Inline
+      class Resolver
+        # @rbs (Lrama::Grammar::RuleBuilder rule_builder) -> void
+        def initialize(rule_builder)
+          @rule_builder = rule_builder
+        end
+
+        # @rbs () -> Array[Lrama::Grammar::RuleBuilder]
+        def resolve
+          resolved_builders = []  #: Array[Lrama::Grammar::RuleBuilder]
+          @rule_builder.rhs.each_with_index do |token, i|
+            if (rule = @rule_builder.parameterized_resolver.find_inline(token))
+              rule.rhs.each do |rhs|
+                builder = build_rule(rhs, token, i, rule)
+                resolved_builders << builder
+              end
+              break
+            end
+          end
+          resolved_builders
+        end
+
+        private
+
+        # @rbs (Lrama::Grammar::Parameterized::Rhs rhs, Lrama::Lexer::Token token, Integer index, Lrama::Grammar::Parameterized::Rule rule) -> Lrama::Grammar::RuleBuilder
+        def build_rule(rhs, token, index, rule)
+          builder = RuleBuilder.new(
+            @rule_builder.rule_counter,
+            @rule_builder.midrule_action_counter,
+            @rule_builder.parameterized_resolver,
+            lhs_tag: @rule_builder.lhs_tag
+          )
+          resolve_rhs(builder, rhs, index, token, rule)
+          builder.lhs = @rule_builder.lhs
+          builder.line = @rule_builder.line
+          builder.precedence_sym = @rule_builder.precedence_sym
+          builder.user_code = replace_user_code(rhs, index)
+          builder
+        end
+
+        # @rbs (Lrama::Grammar::RuleBuilder builder, Lrama::Grammar::Parameterized::Rhs rhs, Integer index, Lrama::Lexer::Token token, Lrama::Grammar::Parameterized::Rule rule) -> void
+        def resolve_rhs(builder, rhs, index, token, rule)
+          @rule_builder.rhs.each_with_index do |tok, i|
+            if i == index
+              rhs.symbols.each do |sym|
+                if token.is_a?(Lexer::Token::InstantiateRule)
+                  bindings = Binding.new(rule.parameters, token.args)
+                  builder.add_rhs(bindings.resolve_symbol(sym))
+                else
+                  builder.add_rhs(sym)
+                end
+              end
+            else
+              builder.add_rhs(tok)
+            end
+          end
+        end
+
+        # @rbs (Lrama::Grammar::Parameterized::Rhs rhs, Integer index) -> Lrama::Lexer::Token::UserCode
+        def replace_user_code(rhs, index)
+          user_code = @rule_builder.user_code
+          return user_code if rhs.user_code.nil? || user_code.nil?
+
+          code = user_code.s_value.gsub(/\$#{index + 1}/, rhs.user_code.s_value)
+          user_code.references.each do |ref|
+            next if ref.index.nil? || ref.index <= index # nil は $$ の場合
+            code = code.gsub(/\$#{ref.index}/, "$#{ref.index + (rhs.symbols.count - 1)}")
+            code = code.gsub(/@#{ref.index}/, "@#{ref.index + (rhs.symbols.count - 1)}")
+          end
+          Lrama::Lexer::Token::UserCode.new(s_value: code, location: user_code.location)
+        end
+      end
+    end
+  end
+end

data/lib/lrama/grammar/inline.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative 'inline/resolver'