ruby_mod_kit 0.0.1 → 0.0.3

data/lib/ruby_mod_kit/memo/overload_memo.rb

@@ -0,0 +1,46 @@
+# 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
+
+      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

@@ -3,71 +3,14 @@
 # rbs_inline: enabled
 
 module RubyModKit
-  # The class of transpiler generation.
-  class Memo
-    # @rbs @classes_memo: Hash[Integer, Memo::Class]
-    # @rbs @methods_memo: Hash[Integer, Memo::Method]
-    # @rbs @parameters_memo: Hash[Integer, Memo::Parameter]
-
-    attr_reader :classes_memo #: Hash[Integer, Memo::Class]
-    attr_reader :methods_memo #: Hash[Integer, Memo::Method]
-    attr_reader :parameters_memo #: Hash[Integer, Memo::Parameter]
-
-    # @rbs return: void
-    def initialize
-      @classes_memo = {}
-      @methods_memo = {}
-      @parameters_memo = {}
-    end
-
-    # @rbs offset_diff: OffsetDiff
-    # @rbs return: void
-    def succ(offset_diff)
-      [@methods_memo, @parameters_memo, @classes_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 class_node: Node::ClassNode
-    # @rbs return: Memo::Class
-    def class_memo(class_node)
-      @classes_memo[class_node.offset] ||= Memo::Class.new(class_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/class"
-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,69 @@
+# 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]
+
+    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]
+
+    # @rbs return: void
+    def initialize
+      @def_parents_memo = {}
+      @methods_memo = {}
+      @parameters_memo = {}
+      @overloads_memo = {}
+    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,19 @@
 # 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 _root_node: Node::ProgramNode
     # @rbs _parse_result: Prism::ParseResult
-    # @rbs _memo: Memo
+    # @rbs _memo_pad: MemoPad
     # @rbs return: void
-    def perform(_generation, _root_node, _parse_result, _memo)
+    def perform(_generation, _root_node, _parse_result, _memo_pad)
       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,137 @@
+# 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 :location #: Prism::Location
+      attr_reader :prev #: Node::BaseNode | nil
+
+      # @rbs return: void
+      def initialize
+        @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 = Node.wrap(prism_child_node, parent: self, prev: prev)
+        end
+      end
+
+      # @rbs return: Array[Node::BaseNode]
+      def ancestors
+        return @ancestors if @ancestors
+
+        parent = @parent
+        @ancestors = if parent
+          [parent] + parent.ancestors
+        else
+          []
+        end
+      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: Prism::Node & Prism::_Node
+      def prism_node
+        raise RubyModKit::Error
+      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
+    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
       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
+      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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+# rbs_inline: enabled
+
+module RubyModKit
+  module Node
+    # Transpiler program node
+    class DefParentNode < Node::BaseNode
+      # @rbs @prism_node: Prism::ClassNode | Prism::ModuleNode
+      # @rbs @body_node: nil | Node::StatementsNode
+      # @rbs @parent: Node::BaseNode
+      # @rbs @prev: Node::BaseNode | nil
+
+      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::BaseNode
+      # @rbs prev: Node::BaseNode | nil
+      # @rbs return: void
+      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 return: nil | Node::StatementsNode
+      def body_node
+        return @body_node if defined?(@body_node)
+
+        body_node = children.find { |node| node.prism_node == @prism_node.body }
+        body_node = nil unless body_node.is_a?(Node::StatementsNode)
+        @body_node = body_node
+      end
+    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
+      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,9 +3,9 @@
 # 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

data/lib/ruby_mod_kit/node/statements_node.rb

@@ -3,21 +3,25 @@
 # rbs_inline: enabled
 
 module RubyModKit
-  class Node
+  module Node
     # Transpiler program node
-    class StatementsNode < Node
+    class StatementsNode < Node::BaseNode
       # @rbs @prism_node: Prism::StatementsNode
-      # @rbs @parent: Node
+      # @rbs @parent: Node::BaseNode
+      # @rbs @prev: Node::BaseNode | nil
 
       attr_reader :prism_node #: Prism::StatementsNode
-      attr_reader :parent #: Node
+      attr_reader :parent #: Node::BaseNode
+      attr_reader :prev #: Node::BaseNode | nil
 
       # @rbs prism_node: Prism::StatementsNode
-      # @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::StatementsNode)
 
         super()

data/lib/ruby_mod_kit/node/symbol_node.rb

@@ -3,21 +3,25 @@
 # rbs_inline: enabled
 
 module RubyModKit
-  class Node
+  module Node
     # Transpiler program node
-    class SymbolNode < Node
+    class SymbolNode < Node::BaseNode
       # @rbs @prism_node: Prism::SymbolNode
-      # @rbs @parent: Node
+      # @rbs @parent: Node::BaseNode
+      # @rbs @prev: Node::BaseNode | nil
 
       attr_reader :prism_node #: Prism::SymbolNode
-      attr_reader :parent #: Node
+      attr_reader :parent #: Node::BaseNode
+      attr_reader :prev #: Node::BaseNode | nil
 
       # @rbs prism_node: Prism::SymbolNode
-      # @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::SymbolNode)
 
         super()

data/lib/ruby_mod_kit/node/untyped_node.rb

@@ -3,21 +3,25 @@
 # rbs_inline: enabled
 
 module RubyModKit
-  class Node
+  module Node
     # Transpiler program node
-    class UntypedNode < Node
+    class UntypedNode < Node::BaseNode
       # @rbs @prism_node: Prism::Node
-      # @rbs @parent: Node
+      # @rbs @parent: Node::BaseNode
+      # @rbs @prev: Node::BaseNode | nil
 
       attr_reader :prism_node #: Prism::Node
-      attr_reader :parent #: 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
         super()
       end
     end