ruby_mod_kit 0.0.2 → 0.0.4

data/lib/ruby_mod_kit/memo/{method.rb → method_memo.rb}

@@ -3,15 +3,15 @@
 # rbs_inline: enabled
 
 module RubyModKit
-  class Memo
+  module Memo
     # The memo for parameter type
-    class Method < OffsetMemo
+    class MethodMemo < OffsetMemo
       # @rbs @name: Symbol
-      # @rbs @parameters: Set[Memo::Parameter]
+      # @rbs @parameters: Set[Memo::ParameterMemo]
       # @rbs @type: String
 
       attr_reader :name #: Symbol
-      attr_reader :parameters #: Set[Memo::Parameter]
+      attr_reader :parameters #: Set[Memo::ParameterMemo]
       attr_reader :type #: String
 
       UNTYPED = "untyped"
@@ -27,8 +27,8 @@ module RubyModKit
         super(node.offset)
       end
 
-      # @rbs parameter_memo: Memo::Parameter
-      # @rbs return: Memo::Parameter
+      # @rbs parameter_memo: Memo::ParameterMemo
+      # @rbs return: Memo::ParameterMemo
       def add_parameter(parameter_memo)
         @parameters << parameter_memo
         parameter_memo
@@ -42,7 +42,7 @@ module RubyModKit
       # @rbs type: String
       # @rbs return: void
       def type=(type)
-        @type = Memo.unify_type(type)
+        @type = RubyModKit.unify_type(type)
       end
     end
   end

data/lib/ruby_mod_kit/memo/offset_memo.rb

@@ -3,7 +3,7 @@
 # rbs_inline: enabled
 
 module RubyModKit
-  class Memo
+  module Memo
     # The base class for located memo
     class OffsetMemo
       # @rbs @offset: Integer

data/lib/ruby_mod_kit/memo/overload_memo.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+# rbs_inline: enabled
+
+module RubyModKit
+  module Memo
+    # The memo for parameter type
+    class OverloadMemo < OffsetMemo
+      # @rbs @name: Symbol
+      # @rbs @overload_types: [[Array[String], String]]
+      # @rbs @offset_corrected: bool
+      # @rbs @offset: Integer
+
+      attr_reader :name #: Symbol
+      attr_reader :overload_types #: [[Array[String], String]]
+
+      # @rbs offset: Integer
+      # @rbs name: Symbol
+      # @rbs return: void
+      def initialize(offset, name)
+        @name = name
+        @overload_types = []
+        @offset_corrected = false
+        super(offset)
+      end
+
+      # @rbs root_node: Node::ProgramNode
+      # @rbs return: Integer
+      def correct_offset(root_node)
+        return @offset if @offset_corrected
+
+        node = root_node.def_node_at(@offset)&.prev
+        raise RubyModKit::Error unless node.is_a?(Node::DefNode)
+
+        @offset_corrected = true
+        @offset = node.offset
+      end
+
+      # @rbs parameter_types: Array[String]
+      # @rbs return_value_type: String
+      # @rbs return: void
+      def add_overload_type(parameter_types, return_value_type)
+        @overload_types << [parameter_types, return_value_type]
+      end
+    end
+  end
+end

data/lib/ruby_mod_kit/memo/{parameter.rb → parameter_memo.rb}

@@ -3,9 +3,9 @@
 # rbs_inline: enabled
 
 module RubyModKit
-  class Memo
+  module Memo
     # The memo for parameter type
-    class Parameter < OffsetMemo
+    class ParameterMemo < OffsetMemo
       # @rbs @type: String
       # @rbs @ivar_parameter: bool
       # @rbs @qualifier: String
@@ -32,7 +32,7 @@ module RubyModKit
       # @rbs type: String
       # @rbs return: void
       def type=(type)
-        @type = Memo.unify_type(type)
+        @type = RubyModKit.unify_type(type)
       end
     end
   end

data/lib/ruby_mod_kit/memo.rb

@@ -1,73 +1,14 @@
 # frozen_string_literal: true
 
-# rbs_inline: enabled
-
 module RubyModKit
-  # The class of transpiler generation.
-  class Memo
-    # @rbs @def_parents_memo: Hash[Integer, Memo::DefParent]
-    # @rbs @methods_memo: Hash[Integer, Memo::Method]
-    # @rbs @parameters_memo: Hash[Integer, Memo::Parameter]
-
-    attr_reader :def_parents_memo #: Hash[Integer, Memo::DefParent]
-    attr_reader :methods_memo #: Hash[Integer, Memo::Method]
-    attr_reader :parameters_memo #: Hash[Integer, Memo::Parameter]
-
-    # @rbs return: void
-    def initialize
-      @def_parents_memo = {}
-      @methods_memo = {}
-      @parameters_memo = {}
-    end
-
-    # @rbs offset_diff: OffsetDiff
-    # @rbs return: void
-    def succ(offset_diff)
-      [@methods_memo, @parameters_memo, @def_parents_memo].each do |offset_node_memo|
-        new_offset_node_memo = {}
-        offset_node_memo.each_value do |node_memo|
-          node_memo.succ(offset_diff)
-          new_offset_node_memo[node_memo.offset] = node_memo
-        end
-        offset_node_memo.replace(new_offset_node_memo)
-      end
-      self
-    end
-
-    # @rbs def_parent_node: Node::DefParentNode
-    # @rbs return: Memo::DefParent
-    def def_parent_memo(def_parent_node)
-      @def_parents_memo[def_parent_node.offset] ||= Memo::DefParent.new(def_parent_node)
-    end
-
-    # @rbs def_node: Node::DefNode
-    # @rbs return: Memo::Method
-    def method_memo(def_node)
-      @methods_memo[def_node.offset] ||= Memo::Method.new(def_node)
-    end
-
-    # @rbs node: Node
-    # @rbs return: Memo::Parameter
-    def parameter_memo(node)
-      memo = @parameters_memo[node.offset] ||= Memo::Parameter.new(node.offset)
-      def_node = node.def_node_at(node.offset)
-      raise RubyModKit::Error unless def_node.is_a?(Node::DefNode)
-
-      method_memo(def_node).add_parameter(memo)
-    end
-
-    class << self
-      # @rbs type: String
-      # @rbs return: String
-      def unify_type(type)
-        type[/\A\(([^()]*)\)\z/, 1] || type
-      end
-    end
+  # The namespace of transpiler memo.
+  module Memo
   end
 end
 
 require_relative "memo/offset_memo"
-require_relative "memo/def_parent"
-require_relative "memo/ivar"
-require_relative "memo/method"
-require_relative "memo/parameter"
+require_relative "memo/def_parent_memo"
+require_relative "memo/ivar_memo"
+require_relative "memo/method_memo"
+require_relative "memo/overload_memo"
+require_relative "memo/parameter_memo"

data/lib/ruby_mod_kit/memo_pad.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+# rbs_inline: enabled
+
+module RubyModKit
+  # The class for bundling memos.
+  class MemoPad
+    # @rbs @def_parents_memo: Hash[Integer, Memo::DefParentMemo]
+    # @rbs @methods_memo: Hash[Integer, Memo::MethodMemo]
+    # @rbs @parameters_memo: Hash[Integer, Memo::ParameterMemo]
+    # @rbs @overloads_memo: Hash[Integer, Memo::OverloadMemo]
+    # @rbs @flags: Hash[Symbol, bool]
+
+    attr_reader :def_parents_memo #: Hash[Integer, Memo::DefParentMemo]
+    attr_reader :methods_memo #: Hash[Integer, Memo::MethodMemo]
+    attr_reader :parameters_memo #: Hash[Integer, Memo::ParameterMemo]
+    attr_reader :overloads_memo #: Hash[Integer, Memo::OverloadMemo]
+    attr_accessor :flags #: Hash[Symbol, bool]
+
+    # @rbs return: void
+    def initialize
+      @def_parents_memo = {}
+      @methods_memo = {}
+      @parameters_memo = {}
+      @overloads_memo = {}
+      @flags = Hash.new(false)
+    end
+
+    # @rbs offset_diff: OffsetDiff
+    # @rbs return: void
+    def succ(offset_diff)
+      [@methods_memo, @parameters_memo, @def_parents_memo, @overloads_memo].each do |offset_node_memo|
+        new_offset_node_memo = {}
+        offset_node_memo.each_value do |node_memo|
+          node_memo.succ(offset_diff)
+          new_offset_node_memo[node_memo.offset] = node_memo
+        end
+        offset_node_memo.replace(new_offset_node_memo)
+      end
+      self
+    end
+
+    # @rbs def_parent_node: Node::DefParentNode
+    # @rbs return: Memo::DefParentMemo
+    def def_parent_memo(def_parent_node)
+      @def_parents_memo[def_parent_node.offset] ||= Memo::DefParentMemo.new(def_parent_node)
+    end
+
+    # @rbs def_node: Node::DefNode
+    # @rbs return: Memo::MethodMemo
+    def method_memo(def_node)
+      @methods_memo[def_node.offset] ||= Memo::MethodMemo.new(def_node)
+    end
+
+    # @rbs offset: Integer
+    # @rbs name: Symbol
+    # @rbs return: Memo::OverloadMemo
+    def overload_memo(offset, name)
+      @overloads_memo[offset] ||= Memo::OverloadMemo.new(offset, name)
+    end
+
+    # @rbs node: Node::BaseNode
+    # @rbs return: Memo::ParameterMemo
+    def parameter_memo(node)
+      memo = @parameters_memo[node.offset] ||= Memo::ParameterMemo.new(node.offset)
+      def_node = node.def_node_at(node.offset)
+      raise RubyModKit::Error unless def_node.is_a?(Node::DefNode)
+
+      method_memo(def_node).add_parameter(memo)
+    end
+  end
+end

data/lib/ruby_mod_kit/mission.rb

@@ -3,38 +3,16 @@
 # rbs_inline: enabled
 
 module RubyModKit
-  # The class of transpiler mission.
+  # The base class of transpiler mission.
   class Mission
-    # @rbs @offset: Integer
-
-    attr_accessor :offset #: Integer
-
-    # @rbs offset: Integer
-    # @rbs return: void
-    def initialize(offset)
-      @offset = offset
-    end
-
     # @rbs _generation: Generation
-    # @rbs _root_node: Node
-    # @rbs _parse_result: Prism::ParseResult
-    # @rbs _memo: Memo
     # @rbs return: void
-    def perform(_generation, _root_node, _parse_result, _memo)
+    def perform(_generation)
       raise RubyModKit::Error, "Unexpected type #{self.class}"
     end
 
     # @rbs offset_diff: OffsetDiff
     # @rbs return: void
-    def succ(offset_diff)
-      @offset = offset_diff[@offset]
-    end
+    def succ(offset_diff); end
   end
 end
-
-require_relative "mission/ivar_arg"
-require_relative "mission/type_attr"
-require_relative "mission/type_parameter"
-require_relative "mission/type_return"
-require_relative "mission/fix_parse_error"
-require_relative "mission/overload"

data/lib/ruby_mod_kit/node/base_node.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+# rbs_inline: enabled
+
+module RubyModKit
+  module Node
+    # The class of transpile node.
+    class BaseNode
+      # @rbs @location: Prism::Location
+      # @rbs @children: Array[Node::BaseNode]
+      # @rbs @ancestors: Array[Node::BaseNode]
+      # @rbs @prev: Node::BaseNode | nil
+
+      attr_reader :prev #: Node::BaseNode | nil
+
+      # @rbs return: Prism::Location
+      def location
+        return @location if defined?(@location)
+
+        @location = prism_node.location
+      end
+
+      # @rbs return: Array[Node::BaseNode]
+      def children
+        return @children if @children
+
+        prev = nil
+        @children = prism_node.child_nodes.compact.map do |prism_child_node|
+          prev = wrap(prism_child_node, prev: prev)
+        end
+      end
+
+      # @rbs prism_node: Prism::Node
+      # @rbs prev: Node::BaseNode | nil
+      # @rbs return: Node::BaseNode
+      def wrap(prism_node, prev: nil)
+        Node.wrap(prism_node, parent: self, prev: prev)
+      end
+
+      # @rbs return: Array[Node::BaseNode]
+      def ancestors
+        return @ancestors if @ancestors
+
+        parent = self.parent
+        @ancestors = if parent
+          [parent] + parent.ancestors
+        else
+          []
+        end
+      end
+
+      # @rbs return: nil | BaseNode
+      def parent
+        raise(RubyModKit::Error)
+      end
+
+      # @rbs return: Symbol
+      def name
+        raise(RubyModKit::Error, "Expected ParameterNode but #{self.class}:#{prism_node.inspect}")
+      end
+
+      # @rbs offset: Integer
+      # @rbs return: Node::BaseNode | nil
+      def node_at(offset)
+        return nil unless include?(offset)
+
+        child = children.find { _1.include?(offset) }
+        child&.node_at(offset) || self
+      end
+
+      # @rbs offset: Integer
+      # @rbs return: Node::StatementsNode | nil
+      def statements_node_at(offset)
+        node = node_at(offset) || return
+        [node, *node.ancestors].each { return _1 if _1.is_a?(Node::StatementsNode) }
+        nil
+      end
+
+      # @rbs offset: Integer
+      # @rbs return: Node::DefNode | nil
+      def def_node_at(offset)
+        node = node_at(offset) || return
+        [node, *node.ancestors].each { return _1 if _1.is_a?(Node::DefNode) }
+        nil
+      end
+
+      # @rbs offset: Integer
+      # @rbs return: Node::ParameterNode | nil
+      def parameter_node_at(offset)
+        node = node_at(offset) || return
+        [node, *node.ancestors].each { return _1 if _1.is_a?(Node::ParameterNode) }
+        nil
+      end
+
+      # @rbs offset: Integer
+      # @rbs return: Node::DefParentNode | nil
+      def def_parent_node_at(offset)
+        node = node_at(offset) || return
+        [node, *node.ancestors].each { return _1 if _1.is_a?(Node::DefParentNode) }
+        nil
+      end
+
+      # @rbs offset: Integer
+      # @rbs return: bool
+      def include?(offset)
+        self.offset <= offset && offset <= prism_node.location.end_offset
+      end
+
+      # @rbs return: Integer
+      def offset
+        location.start_offset
+      end
+
+      # @rbs return: String
+      def inspect
+        str = +"#<#{self.class} "
+        first = true
+        instance_variables.each do |ivar_name|
+          case ivar_name
+          when :@children, :@ancestors, :@parent
+            next
+          end
+
+          if first
+            first = false
+          else
+            str << ", "
+          end
+          str << "#{ivar_name}="
+          value = instance_variable_get(ivar_name)
+          str << (
+            case value
+            when Prism::Node
+              "#<#{value.class} location=#{value.location.inspect}>"
+            else
+              value.inspect
+            end
+          )
+        end
+        str << ">"
+        str
+      end
+
+      private
+
+      # :nocov:
+      # This is just for interface definition, must not be called
+      # @rbs return: Prism::Node & Prism::_Node
+      def prism_node
+        raise RubyModKit::Error
+      end
+      # :nocov:
+    end
+  end
+end

data/lib/ruby_mod_kit/node/call_node.rb

@@ -3,23 +3,27 @@
 # rbs_inline: enabled
 
 module RubyModKit
-  class Node
+  module Node
     # Transpiler method call node
-    class CallNode < Node
+    class CallNode < Node::BaseNode
       # @rbs @prism_node: Prism::CallNode
       # @rbs @name: Symbol
-      # @rbs @parent: Node
+      # @rbs @parent: Node::BaseNode
+      # @rbs @prev: Node::BaseNode | nil
 
-      attr_reader :prism_node #: Prism::CallNode
+      private attr_reader :prism_node #: Prism::CallNode
       attr_reader :name #: Symbol
-      attr_reader :parent #: Node
+      attr_reader :parent #: Node::BaseNode
+      attr_reader :prev #: Node::BaseNode | nil
 
       # @rbs prism_node: Prism::CallNode
-      # @rbs parent: Node
+      # @rbs parent: Node::BaseNode
+      # @rbs prev: Node::BaseNode | nil
       # @rbs return: void
-      def initialize(prism_node, parent:)
+      def initialize(prism_node, parent:, prev: nil)
         @prism_node = prism_node
         @parent = parent
+        @prev = prev
         raise RubyModKit::Error unless prism_node.is_a?(Prism::CallNode)
 
         @name = prism_node.name.to_sym

data/lib/ruby_mod_kit/node/def_node.rb

@@ -3,21 +3,25 @@
 # rbs_inline: enabled
 
 module RubyModKit
-  class Node
+  module Node
     # Transpiler program node
-    class DefNode < Node
+    class DefNode < Node::BaseNode
       # @rbs @prism_node: Prism::DefNode
-      # @rbs @parent: Node
+      # @rbs @parent: Node::BaseNode
+      # @rbs @prev: Node::BaseNode | nil
 
-      attr_reader :prism_node #: Prism::DefNode
-      attr_reader :parent #: Node
+      private attr_reader :prism_node #: Prism::DefNode
+      attr_reader :parent #: Node::BaseNode
+      attr_reader :prev #: Node::BaseNode | nil
 
       # @rbs prism_node: Prism::DefNode
-      # @rbs parent: Node
+      # @rbs parent: Node::BaseNode
+      # @rbs prev: Node::BaseNode | nil
       # @rbs return: void
-      def initialize(prism_node, parent:)
+      def initialize(prism_node, parent:, prev: nil)
         @prism_node = prism_node
         @parent = parent
+        @prev = prev
         raise RubyModKit::Error unless prism_node.is_a?(Prism::DefNode)
 
         super()

data/lib/ruby_mod_kit/node/def_parent_node.rb

@@ -3,34 +3,45 @@
 # rbs_inline: enabled
 
 module RubyModKit
-  class Node
+  module Node
     # Transpiler program node
-    class DefParentNode < Node
+    class DefParentNode < Node::BaseNode
       # @rbs @prism_node: Prism::ClassNode | Prism::ModuleNode
       # @rbs @body_node: nil | Node::StatementsNode
-      # @rbs @parent: Node
+      # @rbs @parent: Node::BaseNode
+      # @rbs @prev: Node::BaseNode | nil
 
-      attr_reader :prism_node #: Prism::ClassNode | Prism::ModuleNode
-      attr_reader :body_node #: nil | Node::StatementsNode
-      attr_reader :parent #: Node
+      private attr_reader :prism_node #: Prism::ClassNode | Prism::ModuleNode
+      attr_reader :parent #: Node::BaseNode
+      attr_reader :prev #: Node::BaseNode | nil
 
       # @rbs prism_node: Prism::ClassNode | Prism::ModuleNode
-      # @rbs parent: Node
+      # @rbs parent: Node::BaseNode
+      # @rbs prev: Node::BaseNode | nil
       # @rbs return: void
-      def initialize(prism_node, parent:)
+      def initialize(prism_node, parent:, prev: nil)
         @prism_node = prism_node
         @parent = parent
+        @prev = prev
         raise RubyModKit::Error if !prism_node.is_a?(Prism::ClassNode) && !prism_node.is_a?(Prism::ModuleNode)
 
         super()
       end
 
-      # @rbs child_prism_node: Prism::Node
-      # @rbs return: Node
-      def wrap(child_prism_node)
-        node = super
-        @body_node = node if child_prism_node == prism_node.body && node.is_a?(Node::StatementsNode)
-        node
+      # @rbs prism_child_node: Prism::Node
+      # @rbs prev: Node::BaseNode | nil
+      # @rbs return: Node::BaseNode
+      def wrap(prism_child_node, prev: nil)
+        child_node = super
+        @body_node = child_node if prism_child_node == @prism_node.body && child_node.is_a?(Node::StatementsNode)
+        child_node
+      end
+
+      # @rbs return: nil | Node::StatementsNode
+      def body_node
+        # body_node will be set in #children
+        children
+        @body_node
       end
     end
   end

data/lib/ruby_mod_kit/node/parameter_node.rb

@@ -3,26 +3,30 @@
 # rbs_inline: enabled
 
 module RubyModKit
-  class Node
+  module Node
     # Transpiler program node
-    class ParameterNode < Node
+    class ParameterNode < Node::BaseNode
+      # @rbs @prism_node: prism_node
+      # @rbs @parent: Node::BaseNode
+      # @rbs @prev: Node::BaseNode | nil
+
       # @rbs!
       #   type prism_node = Prism::RequiredParameterNode | Prism::OptionalKeywordParameterNode
       #                   | Prism::OptionalParameterNode | Prism::RequiredKeywordParameterNode
       #                   | Prism::RestParameterNode
 
-      # @rbs @prism_node: prism_node
-      # @rbs @parent: Node
-
-      attr_reader :prism_node #: prism_node
-      attr_reader :parent #: Node
+      private attr_reader :prism_node #: prism_node
+      attr_reader :parent #: Node::BaseNode
+      attr_reader :prev #: Node::BaseNode | nil
 
       # @rbs prism_node: prism_node
-      # @rbs parent: Node
+      # @rbs parent: Node::BaseNode
+      # @rbs prev: Node::BaseNode | nil
       # @rbs return: void
-      def initialize(prism_node, parent:)
+      def initialize(prism_node, parent:, prev: nil)
         @prism_node = prism_node
         @parent = parent
+        @prev = prev
         case prism_node
         when Prism::RequiredParameterNode, Prism::OptionalKeywordParameterNode,
              Prism::OptionalParameterNode, Prism::RequiredKeywordParameterNode,

data/lib/ruby_mod_kit/node/program_node.rb

@@ -3,12 +3,12 @@
 # rbs_inline: enabled
 
 module RubyModKit
-  class Node
+  module Node
     # Transpiler program node
-    class ProgramNode < Node
+    class ProgramNode < Node::BaseNode
       # @rbs @prism_node: Prism::ProgramNode
 
-      attr_reader :prism_node #: Prism::ProgramNode
+      private attr_reader :prism_node #: Prism::ProgramNode
 
       # @rbs prism_node: Prism::ProgramNode
       # @rbs return: void
@@ -18,6 +18,11 @@ module RubyModKit
 
         super()
       end
+
+      # @rbs return: nil
+      def parent
+        nil
+      end
     end
   end
 end