ruby_mod_kit 0.0.1

data/lib/ruby_mod_kit/memo.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+# 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
+  end
+end
+
+require_relative "memo/offset_memo"
+require_relative "memo/class"
+require_relative "memo/ivar"
+require_relative "memo/method"
+require_relative "memo/parameter"

data/lib/ruby_mod_kit/mission/fix_parse_error.rb

@@ -0,0 +1,213 @@
+# frozen_string_literal: true
+
+# rbs_inline: enabled
+
+module RubyModKit
+  class Mission
+    # The mission for parameter types
+    class FixParseError < Mission
+      # @rbs @previous_error_messages: Array[String]
+
+      # @rbs return: void
+      def initialize
+        super(0)
+        @previous_error_messages = []
+      end
+
+      # @rbs generation: Generation
+      # @rbs root_node: Node
+      # @rbs parse_result: Prism::ParseResult
+      # @rbs memo: Memo
+      # @rbs return: bool
+      def perform(generation, root_node, parse_result, memo)
+        return true if parse_result.errors.empty?
+
+        check_prev_errors(generation, parse_result)
+        @previous_error_messages = parse_result.errors.map(&:message)
+
+        parse_result.errors.each do |parse_error|
+          case parse_error.type
+          when :argument_formal_ivar
+            fix_argument_formal_ivar(parse_error, generation, root_node, memo)
+          when :argument_formal_constant
+            fix_argument_formal_constant(parse_error, generation)
+          when :unexpected_token_ignore
+            case parse_error.location.slice
+            when "=>"
+              fix_unexpected_assoc(parse_error, generation, root_node, memo)
+            when ":"
+              fix_unexpected_colon(parse_error, generation, root_node, memo)
+            end
+          when :def_params_term_paren
+            fix_def_params_term_paren(parse_error, generation, root_node, memo)
+          end
+        end
+
+        false
+      end
+
+      # @rbs generation: Generation
+      # @rbs parse_result: Prism::ParseResult
+      # @rbs return: void
+      def check_prev_errors(generation, parse_result)
+        return if @previous_error_messages.empty?
+        return if parse_result.errors.empty?
+        return if @previous_error_messages != parse_result.errors.map(&:message)
+
+        message = +""
+        parse_result.errors.each do |parse_error|
+          message << "\n" unless message.empty?
+          message << "#{generation.name}:#{parse_error.location.start_line}:#{parse_error.message} "
+          message << "(#{parse_error.type})\n"
+          message << parse_result.source.lines[parse_error.location.start_line - 1].chomp << "\n"
+          message << "#{" " * parse_error.location.start_column}^#{"~" * [parse_error.location.length - 1, 0].max}"
+        end
+        raise RubyModKit::SyntaxError, message
+      end
+
+      # @rbs parse_error: Prism::ParseError
+      # @rbs generation: Generation
+      # @rbs root_node: Node
+      # @rbs memo: Memo
+      # @rbs return: void
+      def fix_def_params_term_paren(parse_error, generation, root_node, memo)
+        column = parse_error.location.start_column - 1
+        return if column < 0
+
+        line = generation.line(parse_error)[column..] || return
+        line =~ /\A\*(.*?)\s*=>\s*/
+        length = ::Regexp.last_match(0)&.length || return
+        type = ::Regexp.last_match(1) || return
+        offset = parse_error.location.start_offset - 1
+        parameter_position_node = root_node.node_at(offset + length) || return
+
+        generation[parse_error.location.start_offset, length - 1] = ""
+        parameter_memo = memo.parameter_memo(parameter_position_node)
+        parameter_memo.type = type
+        parameter_memo.qualifier = "*"
+      end
+
+      # @rbs parse_error: Prism::ParseError
+      # @rbs generation: Generation
+      # @rbs root_node: Node
+      # @rbs memo: Memo
+      # @rbs return: void
+      def fix_argument_formal_ivar(parse_error, generation, root_node, memo)
+        src_offset = parse_error.location.start_offset
+
+        name = parse_error.location.slice[1..]
+        raise RubyModKit::Error unless name
+
+        parameter_position_node = root_node.node_at(src_offset)
+        raise RubyModKit::Error unless parameter_position_node
+
+        generation[src_offset, parse_error.location.length] = name
+        parameter_memo = memo.parameter_memo(parameter_position_node)
+        parameter_memo.ivar_parameter = true
+        generation.add_mission(Mission::IvarArg.new(src_offset))
+
+        return unless parameter_memo.untyped?
+
+        class_node = root_node.class_node_at(parse_error.location.start_offset) || return
+        ivar_memo_type = memo.class_memo(class_node).ivar_memo(name.to_sym).type || return
+        parameter_memo.type = ivar_memo_type
+      end
+
+      # @rbs parse_error: Prism::ParseError
+      # @rbs generation: Generation
+      # @rbs return: void
+      def fix_argument_formal_constant(parse_error, generation)
+        line = generation.line(parse_error)
+        line = line[parse_error.location.start_column..] || return
+        parameter_type = line[/(\A[A-Z]\w*(?:::[A-Z]\w*)+)(?:\s*=>\s*)/, 1] || return
+        src_offset = parse_error.location.start_offset
+        generation[src_offset, parameter_type.length] = "(#{parameter_type})"
+      end
+
+      # @rbs parse_error: Prism::ParseError
+      # @rbs generation: Generation
+      # @rbs root_node: Node
+      # @rbs memo: Memo
+      # @rbs return: void
+      def fix_unexpected_assoc(parse_error, generation, root_node, memo)
+        def_node = root_node.def_node_at(parse_error.location.start_offset) || return
+        def_parent_node = def_node.parent
+        parameters_node, body_node, = def_node.children
+        return if !def_parent_node || !parameters_node || !body_node
+
+        last_parameter_node = parameters_node.children.max_by(&:offset) || return
+        last_parameter_offset = last_parameter_node.offset
+
+        right_node = body_node.children.find { _1.offset >= parse_error.location.end_offset } || return
+        right_offset = right_node.offset
+        parameter_type = generation[last_parameter_offset...right_offset] || raise(RubyModKit::Error)
+        parameter_type = parameter_type.sub(/\s*=>\s*\z/, "")
+        generation[last_parameter_offset, right_offset - last_parameter_offset] = ""
+        memo.parameter_memo(last_parameter_node).type = parameter_type
+      end
+
+      # @rbs parse_error: Prism::ParseError
+      # @rbs generation: Generation
+      # @rbs root_node: Node
+      # @rbs memo: Memo
+      # @rbs return: void
+      def fix_unexpected_colon(parse_error, generation, root_node, memo)
+        parent_node = root_node.statements_node_at(parse_error.location.start_offset)&.parent
+        case parent_node
+        when Node::DefNode
+          fix_unexpected_colon_in_def(parse_error, generation, root_node, parent_node, memo)
+        when Node::ClassNode
+          fix_unexpected_colon_in_module(parse_error, generation, parent_node, memo)
+        end
+      end
+
+      # @rbs parse_error: Prism::ParseError
+      # @rbs generation: Generation
+      # @rbs root_node: Node
+      # @rbs def_node: Node::DefNode
+      # @rbs memo: Memo
+      # @rbs return: void
+      def fix_unexpected_colon_in_def(parse_error, generation, root_node, def_node, memo)
+        lparen_loc = def_node.lparen_loc
+        rparen_loc = def_node.rparen_loc
+        if !lparen_loc && !rparen_loc
+          src_offset = def_node.name_loc.end_offset
+        elsif lparen_loc && rparen_loc && lparen_loc.slice == "(" && rparen_loc.slice == ")"
+          src_offset = rparen_loc.end_offset
+        else
+          return
+        end
+        return if generation[src_offset...parse_error.location.start_offset] !~ /\A\s*\z/
+
+        return_type_location = root_node.node_at(parse_error.location.end_offset + 1)&.location || return_type_location
+        generation[src_offset, return_type_location.end_offset - src_offset] = ""
+        memo.method_memo(def_node).type = return_type_location.slice
+      end
+
+      # @rbs parse_error: Prism::ParseError
+      # @rbs generation: Generation
+      # @rbs class_node: Node::ClassNode
+      # @rbs memo: Memo
+      # @rbs return: void
+      def fix_unexpected_colon_in_module(parse_error, generation, class_node, memo)
+        line = generation.line(parse_error)
+        line_offset = generation.src_offset(parse_error) || return
+        attr_patterns = %i[attr_reader reader getter attr_writer writer setter attr_accessor accessor property]
+        return if line !~ /(\A\s*)(?:(#{attr_patterns.join("|")}) )?@(\w*)\s*:\s*(.*)/
+
+        length = ::Regexp.last_match(0)&.length
+        indent = ::Regexp.last_match(1)
+        attr_kind = ::Regexp.last_match(2)
+        ivar_name = ::Regexp.last_match(3)
+        type = ::Regexp.last_match(4)
+        return if !length || !indent || !ivar_name || !type
+
+        ivar_memo = memo.class_memo(class_node).ivar_memo(ivar_name.to_sym)
+        ivar_memo.type = type
+        ivar_memo.attr_kind = attr_kind if attr_kind
+
+        generation[line_offset, length] = "#{indent}# @rbs @#{ivar_name}: #{Memo.unify_type(type)}"
+      end
+    end
+  end
+end

data/lib/ruby_mod_kit/mission/ivar_arg.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+# rbs_inline: enabled
+
+module RubyModKit
+  class Mission
+    # The mission for instance variable arguments
+    class IvarArg < Mission
+      # @rbs @assignment: String
+
+      attr_reader :assignment #: String
+
+      # @rbs generation: Generation
+      # @rbs root_node: Node
+      # @rbs _parse_result: Prism::ParseResult
+      # @rbs _memo: Memo
+      # @rbs return: bool
+      def perform(generation, root_node, _parse_result, _memo)
+        parameter_node = root_node.parameter_node_at(@offset)
+        raise RubyModKit::Error unless parameter_node
+
+        def_node = root_node.def_node_at(@offset)
+        raise RubyModKit::Error, "DefNode not found" unless def_node
+
+        def_body_location = def_node.body_location
+        end_loc = def_node.end_keyword_loc
+        if def_body_location
+          indent = def_body_location.start_column
+          src_offset = def_body_location.start_offset - indent
+        elsif end_loc
+          indent = end_loc.start_column + 2
+          src_offset = end_loc.start_offset - indent + 2
+        end
+        raise RubyModKit::Error if !src_offset || !indent
+
+        name = parameter_node.name
+        generation[src_offset, 0] = "#{" " * indent}@#{name} = #{name}\n"
+        true
+      end
+    end
+  end
+end

data/lib/ruby_mod_kit/mission/overload.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+# rbs_inline: enabled
+
+module RubyModKit
+  class Mission
+    # The mission for overload
+    class Overload < Mission
+      OVERLOAD_METHOD_MAP = {
+        "*": "_mul",
+      }.freeze #: Hash[Symbol, String]
+
+      # @rbs return: void
+      def initialize
+        super(0)
+      end
+
+      # @rbs generation: Generation
+      # @rbs root_node: Node
+      # @rbs parse_result: Prism::ParseResult
+      # @rbs memo: Memo
+      # @rbs return: bool
+      def perform(generation, root_node, parse_result, memo)
+        method_memo_groups = memo.methods_memo.each_value.group_by do |method_memo|
+          [root_node.class_node_at(method_memo.offset), method_memo.name]
+        end
+        method_memo_groups.each_value do |method_memos|
+          next if method_memos.length <= 1
+
+          first_method_memo = method_memos.first
+          name = first_method_memo.name
+          first_def_node = root_node.def_node_at(first_method_memo.offset)
+          raise RubyModKit::Error unless first_def_node.is_a?(Node::DefNode)
+          raise RubyModKit::Error unless name.is_a?(Symbol)
+
+          start_line = first_def_node.location.start_line - 1
+          indent = parse_result.source.lines[start_line][/\A */] || ""
+          start_line -= 1 while parse_result.source.lines[start_line - 1] =~ /^ *# *@rbs /
+          src_offset = parse_result.source.offsets[start_line]
+          script = +""
+
+          method_memos.each do |method_memo|
+            script << if script.empty?
+              "# @rbs"
+            else
+              "#    |"
+            end
+            type = method_memo.type
+            type = "(#{type})" if type.include?(" ")
+            script << " (#{method_memo.parameters.map(&:type).join(", ")}) -> #{type}\n"
+          end
+          script << "def #{name}(*args)\n  case args\n"
+          overload_prefix = +"#{OVERLOAD_METHOD_MAP[name] || name}_"
+          method_memos.each_with_index do |method_memo, i|
+            overload_name = "#{overload_prefix}_overload#{i}"
+            def_node = root_node.def_node_at(method_memo.offset)
+            raise RubyModKit::Error if !def_node || !def_node.is_a?(Node::DefNode)
+
+            name_loc = def_node.name_loc
+            generation[name_loc.start_offset, name_loc.length] = overload_name
+            script << "  in [#{method_memo.parameters.map(&:type).join(", ")}]\n"
+            script << "    #{overload_name}(*args)\n"
+          end
+          script << "  end\nend\n\n"
+
+          script.gsub!(/^(?=.)/, indent)
+          generation[src_offset, 0] = script
+        end
+        true
+      end
+    end
+  end
+end

data/lib/ruby_mod_kit/mission/type_attr.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+# rbs_inline: enabled
+
+module RubyModKit
+  class Mission
+    # The mission for parameter types
+    class TypeAttr < Mission
+      # @rbs return: void
+      def initialize
+        super(0)
+      end
+
+      # @rbs generation: Generation
+      # @rbs root_node: Node
+      # @rbs _parse_result: Prism::ParseResult
+      # @rbs memo: Memo
+      # @rbs return: bool
+      def perform(generation, root_node, _parse_result, memo)
+        memo.classes_memo.each_value do |class_memo|
+          ivars_memo = class_memo.ivars_memo.dup
+          class_node = root_node.class_node_at(class_memo.offset) || raise(RubyModKit::Error)
+          attr_adding_line = 0
+          class_node.body_node&.children&.each do |call_node|
+            break if ivars_memo.empty?
+            next unless call_node.is_a?(Node::CallNode)
+            next unless %i[attr_reader attr_writer attr_accessor].include?(call_node.name)
+
+            attr_adding_line = call_node.location.end_line
+            argument_nodes = call_node.children[0].children
+            next if argument_nodes.size != 1 || !argument_nodes[0].is_a?(Node::SymbolNode)
+
+            name = argument_nodes[0].value || next
+            ivar_memo = ivars_memo.delete(name) || next
+            line = generation.line(call_node)
+            length = line[/\A\s*(#{call_node.name}\s+:#{name})(?=\n\z)/, 1]&.length || next
+            generation[call_node.location.start_offset + length, 0] = " #: #{ivar_memo.type}"
+          end
+
+          ivars_memo.keep_if { |_, ivar_memo| ivar_memo.attr_kind }
+          next if ivars_memo.empty?
+
+          add_first_separator_line = false
+          if attr_adding_line == 0
+            attr_adding_line = class_node.location.start_line
+            prev_line = nil
+            while generation.line(attr_adding_line) =~ /\A\s*#.*|\A$/
+              prev_line = ::Regexp.last_match(0)
+              attr_adding_line += 1
+            end
+            add_first_separator_line = prev_line != ""
+          end
+          line = generation.line(attr_adding_line) || next
+          add_separator_line = line != "\n" && line !~ /\A\s*end$/
+          offset = generation.src_offset(attr_adding_line) || next
+
+          if class_node.body_node
+            first_line = generation.line(class_node.body_node)
+            indent = first_line[/\A\s*/] || raise(RubyModKit::Error)
+          else
+            class_line = generation.line(class_node)
+            indent = "  #{class_line[/\A\s*/]}"
+          end
+
+          generation[offset, 0] = "\n" if add_first_separator_line
+          ivars_memo.each do |name, ivar_memo|
+            generation[offset, 0] = "#{indent}#{ivar_memo.attr_kind} :#{name} #: #{ivar_memo.type}\n"
+          end
+          generation[offset, 0] = "\n" if add_separator_line
+        end
+        true
+      end
+    end
+  end
+end

data/lib/ruby_mod_kit/mission/type_parameter.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+# rbs_inline: enabled
+
+module RubyModKit
+  class Mission
+    # The mission for parameter types
+    class TypeParameter < Mission
+      # @rbs return: void
+      def initialize
+        super(0)
+      end
+
+      # @rbs generation: Generation
+      # @rbs root_node: Node
+      # @rbs parse_result: Prism::ParseResult
+      # @rbs memo: Memo
+      # @rbs return: bool
+      def perform(generation, root_node, parse_result, memo)
+        memo.parameters_memo.each do |offset, parameter_memo|
+          next if parameter_memo.untyped?
+
+          def_node = root_node.def_node_at(offset)
+          raise RubyModKit::Error, "DefNode not found" if !def_node || !def_node.is_a?(Node::DefNode)
+
+          parameter_node = root_node.parameter_node_at(offset)
+          raise RubyModKit::Error, "ParameterNode not found" unless parameter_node
+
+          type = parameter_memo.type
+          src_offset = parse_result.source.offsets[def_node.location.start_line - 1]
+          indent = def_node.offset - src_offset
+          qualified_name = "#{parameter_memo.qualifier}#{parameter_node.name}"
+          generation[src_offset, 0] = "#{" " * indent}# @rbs #{qualified_name}: #{type}\n"
+        end
+        true
+      end
+    end
+  end
+end

data/lib/ruby_mod_kit/mission/type_return.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+# rbs_inline: enabled
+
+module RubyModKit
+  class Mission
+    # The mission for parameter types
+    class TypeReturn < Mission
+      # @rbs return: void
+      def initialize
+        super(0)
+      end
+
+      # @rbs generation: Generation
+      # @rbs root_node: Node
+      # @rbs parse_result: Prism::ParseResult
+      # @rbs memo: Memo
+      # @rbs return: bool
+      def perform(generation, root_node, parse_result, memo)
+        memo.methods_memo.each do |offset, method_memo|
+          def_node = root_node.def_node_at(offset)
+          raise RubyModKit::Error, "DefNode not found" if !def_node || !def_node.is_a?(Node::DefNode)
+          next if method_memo.untyped?
+
+          src_offset = parse_result.source.offsets[def_node.location.start_line - 1]
+          indent = offset - src_offset
+          generation[src_offset, 0] = "#{" " * indent}# @rbs return: #{method_memo.type}\n"
+        end
+        true
+      end
+    end
+  end
+end

data/lib/ruby_mod_kit/mission.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+# rbs_inline: enabled
+
+module RubyModKit
+  # The 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)
+      raise RubyModKit::Error, "Unexpected type #{self.class}"
+    end
+
+    # @rbs offset_diff: OffsetDiff
+    # @rbs return: void
+    def succ(offset_diff)
+      @offset = offset_diff[@offset]
+    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/call_node.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+# rbs_inline: enabled
+
+module RubyModKit
+  class Node
+    # Transpiler method call node
+    class CallNode < Node
+      # @rbs @prism_node: Prism::CallNode
+      # @rbs @name: Symbol
+      # @rbs @parent: Node
+
+      attr_reader :prism_node #: Prism::CallNode
+      attr_reader :name #: Symbol
+      attr_reader :parent #: Node
+
+      # @rbs prism_node: Prism::CallNode
+      # @rbs parent: Node
+      # @rbs return: void
+      def initialize(prism_node, parent:)
+        @prism_node = prism_node
+        @parent = parent
+        raise RubyModKit::Error unless prism_node.is_a?(Prism::CallNode)
+
+        @name = prism_node.name.to_sym
+        super()
+      end
+    end
+  end
+end

data/lib/ruby_mod_kit/node/class_node.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+# rbs_inline: enabled
+
+module RubyModKit
+  class Node
+    # Transpiler program node
+    class ClassNode < Node
+      # @rbs @prism_node: Prism::ClassNode
+      # @rbs @body_node: nil | Node::StatementsNode
+      # @rbs @parent: Node
+
+      attr_reader :prism_node #: Prism::ClassNode
+      attr_reader :body_node #: nil | Node::StatementsNode
+      attr_reader :parent #: Node
+
+      # @rbs prism_node: Prism::ClassNode
+      # @rbs parent: Node
+      # @rbs return: void
+      def initialize(prism_node, parent:)
+        @prism_node = prism_node
+        @parent = parent
+        raise RubyModKit::Error unless prism_node.is_a?(Prism::ClassNode)
+
+        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
+      end
+    end
+  end
+end