ruby_mod_kit 0.0.1 → 0.0.3

data/lib/ruby_mod_kit/feature/type/rbs_inline/type_instance_variable_mission.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+# rbs_inline: enabled
+
+module RubyModKit
+  class Feature
+    class Type
+      class RbsInline
+        # The mission for instance variable types
+        class TypeInstanceVariableMission < Mission
+          # @rbs generation: Generation
+          # @rbs root_node: Node::ProgramNode
+          # @rbs parse_result: Prism::ParseResult
+          # @rbs memo_pad: MemoPad
+          # @rbs return: bool
+          def perform(generation, root_node, parse_result, memo_pad)
+            memo_pad.def_parents_memo.each_value do |def_parent_memo|
+              def_parent_memo.ivars_memo.each do |name, ivar_memo|
+                offset = ivar_memo.offset || next
+                def_parent_node = root_node.def_parent_node_at(offset) || next
+                body_line_offset = parse_result.source.offsets[def_parent_node.prism_node.location.start_line]
+                generation[body_line_offset, 0] = "#{ivar_memo.indent}# @rbs @#{name}: #{ivar_memo.type}\n"
+              end
+            end
+            true
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ruby_mod_kit/feature/type/rbs_inline/type_overload_mission.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+# rbs_inline: enabled
+
+module RubyModKit
+  class Feature
+    class Type
+      class RbsInline
+        # The mission for parameter types
+        class TypeOverloadMission < Mission
+          # @rbs generation: Generation
+          # @rbs root_node: Node::ProgramNode
+          # @rbs parse_result: Prism::ParseResult
+          # @rbs memo_pad: MemoPad
+          # @rbs return: bool
+          def perform(generation, root_node, parse_result, memo_pad)
+            memo_pad.overloads_memo.each_value do |overload_memo|
+              overload_memo.correct_offset(root_node)
+              offset = overload_memo.offset
+              def_node = root_node.def_node_at(offset) || raise(RubyModKit::Error)
+              start_line = def_node.location.start_line - 1
+              indent = parse_result.source.lines[start_line][/\A */] || ""
+              offset -= indent.length
+
+              annotation = +""
+              overload_memo.overload_types.each do |parameter_types, return_type|
+                annotation << if annotation.empty?
+                  "# @rbs"
+                else
+                  "#    |"
+                end
+                annotation << " (#{parameter_types.join(", ")}) -> #{return_type}\n"
+              end
+              annotation.gsub!(/^/, indent)
+              generation[offset, 0] = annotation
+            end
+            true
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ruby_mod_kit/feature/type/rbs_inline/type_parameter_mission.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+# rbs_inline: enabled
+
+module RubyModKit
+  class Feature
+    class Type
+      class RbsInline
+        # The mission for parameter types
+        class TypeParameterMission < Mission
+          # @rbs generation: Generation
+          # @rbs root_node: Node::ProgramNode
+          # @rbs parse_result: Prism::ParseResult
+          # @rbs memo_pad: MemoPad
+          # @rbs return: bool
+          def perform(generation, root_node, parse_result, memo_pad)
+            memo_pad.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
+  end
+end

data/lib/ruby_mod_kit/feature/type/rbs_inline/type_return_mission.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+# rbs_inline: enabled
+
+module RubyModKit
+  class Feature
+    class Type
+      class RbsInline
+        # The mission for parameter types
+        class TypeReturnMission < Mission
+          # @rbs generation: Generation
+          # @rbs root_node: Node::ProgramNode
+          # @rbs parse_result: Prism::ParseResult
+          # @rbs memo_pad: MemoPad
+          # @rbs return: bool
+          def perform(generation, root_node, parse_result, memo_pad)
+            memo_pad.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
+  end
+end

data/lib/ruby_mod_kit/feature/type/rbs_inline.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+# rbs_inline: enabled
+
+module RubyModKit
+  class Feature
+    class Type
+      # namespace for type with rbs-line feature
+      class RbsInline < Feature
+        # @rbs return: Array[Mission]
+        def create_missions
+          [
+            TypeInstanceVariableMission.new,
+            TypeAttrMission.new,
+            TypeOverloadMission.new,
+            TypeParameterMission.new,
+            TypeReturnMission.new,
+          ]
+        end
+      end
+    end
+  end
+end
+
+require_relative "rbs_inline/type_attr_mission"
+require_relative "rbs_inline/type_instance_variable_mission"
+require_relative "rbs_inline/type_overload_mission"
+require_relative "rbs_inline/type_parameter_mission"
+require_relative "rbs_inline/type_return_mission"

data/lib/ruby_mod_kit/feature/type/return_value_colon_corrector.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+# rbs_inline: enabled
+
+module RubyModKit
+  class Feature
+    class Type
+      # the class to correct `def foo: Some ...` -> `def foo ...`
+      class ReturnValueColonCorrector < Corrector
+        # @rbs return: Array[Symbol]
+        def correctable_error_types
+          %i[unexpected_token_ignore]
+        end
+
+        # @rbs parse_error: Prism::ParseError
+        # @rbs generation: Generation
+        # @rbs root_node: Node::ProgramNode
+        # @rbs memo_pad: MemoPad
+        # @rbs return: void
+        def correct(parse_error, generation, root_node, memo_pad)
+          return if parse_error.location.slice != ":"
+
+          def_node = root_node.statements_node_at(parse_error.location.start_offset)&.parent
+          return unless def_node.is_a?(Node::DefNode)
+
+          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/
+
+          right_node = root_node.node_at(parse_error.location.end_offset + 1)
+          return_type_location = right_node&.location || return_type_location
+          generation[src_offset, return_type_location.end_offset - src_offset] = ""
+          memo_pad.method_memo(def_node).type = return_type_location.slice
+        end
+      end
+    end
+  end
+end

data/lib/ruby_mod_kit/feature/type/type_attr_mission.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+# rbs_inline: enabled
+
+module RubyModKit
+  class Feature
+    class Type
+      # The mission for parameter attributes
+      class TypeAttrMission < Mission
+        # @rbs return: void
+        def initialize
+          super
+          @modified = false
+        end
+
+        # @rbs generation: Generation
+        # @rbs root_node: Node::ProgramNode
+        # @rbs _parse_result: Prism::ParseResult
+        # @rbs memo_pad: MemoPad
+        # @rbs return: bool
+        def perform(generation, root_node, _parse_result, memo_pad)
+          return true if @modified
+
+          memo_pad.def_parents_memo.each_value do |def_parent_memo|
+            ivars_memo = def_parent_memo.ivars_memo.dup
+            def_parent_node = root_node.def_parent_node_at(def_parent_memo.offset) || raise(RubyModKit::Error)
+            attr_adding_line = 0
+
+            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 = def_parent_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
+
+            body_node = def_parent_node.body_node
+            if body_node
+              first_line = generation.line(body_node)
+              indent = first_line[/\A\s*/] || raise(RubyModKit::Error)
+            else
+              def_parent_line = generation.line(def_parent_node)
+              indent = "  #{def_parent_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}\n"
+            end
+            @modified = true
+            generation[offset, 0] = "\n" if add_separator_line
+          end
+          !@modified
+        end
+      end
+    end
+  end
+end

data/lib/ruby_mod_kit/feature/type.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+# rbs_inline: enabled
+
+module RubyModKit
+  class Feature
+    # namespace for type feature
+    class Type < Feature
+      # @rbs return: Array[Corrector]
+      def create_correctors
+        [
+          InstanceVariableColonCorrector.new,
+          ParameterArrowCorrector.new,
+          ReturnValueColonCorrector.new,
+        ]
+      end
+
+      # @rbs return: Array[Mission]
+      def create_missions
+        [
+          TypeAttrMission.new,
+        ]
+      end
+    end
+  end
+end
+
+require_relative "type/instance_variable_colon_corrector"
+require_relative "type/parameter_arrow_corrector"
+require_relative "type/return_value_colon_corrector"
+require_relative "type/type_attr_mission"

data/lib/ruby_mod_kit/feature.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+# rbs_inline: enabled
+
+module RubyModKit
+  # the base class of feature
+  class Feature
+    # @rbs other: Feature
+    # @rbs return: -1 | 0 | 1 | nil
+    def <=>(other)
+      self.class.name <=> other.class.name
+    end
+
+    # @rbs return: Array[Corrector]
+    def create_correctors
+      []
+    end
+
+    # @rbs return: Array[Mission]
+    def create_missions
+      []
+    end
+  end
+end

data/lib/ruby_mod_kit/generation.rb

@@ -8,27 +8,40 @@ module RubyModKit
     # @rbs @parse_result: Prism::ParseResult
     # @rbs @script: String
     # @rbs @missions: Array[Mission]
-    # @rbs @memo: Memo
+    # @rbs @memo_pad: MemoPad
     # @rbs @root_node: Node::ProgramNode
     # @rbs @offset_diff: OffsetDiff
     # @rbs @generation_num: Integer
     # @rbs @filename: String | nil
+    # @rbs @corrector_manager: CorrectorManager
+    # @rbs @features: Array[Feature]
 
     attr_reader :parse_result #: Prism::ParseResult
     attr_reader :script #: String
 
     # @rbs script: String
     # @rbs missions: Array[Mission]
-    # @rbs memo: Memo
+    # @rbs memo_pad: MemoPad | nil
     # @rbs generation_num: Integer
     # @rbs filename: String | nil
+    # @rbs corrector_manager: CorrectorManager | nil
+    # @rbs features: Array[Feature] | nil
     # @rbs return: void
-    def initialize(script, missions: [], memo: Memo.new, generation_num: 0, filename: nil)
+    def initialize(script, missions: [], memo_pad: nil, generation_num: 0,
+                   filename: nil, corrector_manager: nil, features: nil)
       @script = script
       @missions = missions
-      @memo = memo
       @generation_num = generation_num
       @filename = filename
+      @features = features || [
+        Feature::InstanceVariableParameter.new,
+        Feature::Overload.new,
+        Feature::Type.new,
+        Feature::Type::RbsInline.new,
+      ].sort
+
+      @memo_pad = memo_pad || MemoPad.new
+      @corrector_manager = corrector_manager || CorrectorManager.new(@features)
       @offset_diff = OffsetDiff.new
       @parse_result = Prism.parse(@script)
       @root_node = Node::ProgramNode.new(@parse_result.value)
@@ -39,11 +52,11 @@ module RubyModKit
     def init_missions
       return unless first_generation?
 
-      add_mission(Mission::FixParseError.new)
-      add_mission(Mission::TypeAttr.new)
-      add_mission(Mission::Overload.new)
-      add_mission(Mission::TypeParameter.new)
-      add_mission(Mission::TypeReturn.new)
+      @features.each do |feature|
+        feature.create_missions.each do |mission|
+          add_mission(mission)
+        end
+      end
     end
 
     # @rbs return: bool
@@ -53,16 +66,24 @@ module RubyModKit
 
     # @rbs return: Generation
     def succ
+      if @parse_result.errors.empty?
+        perform_missions
+      else
+        perform_corrector
+      end
       @missions.each do |mission|
         mission.succ(@offset_diff)
       end
-      @memo.succ(@offset_diff)
+      @memo_pad.succ(@offset_diff)
+
       Generation.new(
         @script,
         missions: @missions,
-        memo: @memo,
+        memo_pad: @memo_pad,
         generation_num: @generation_num + 1,
         filename: @filename,
+        corrector_manager: @corrector_manager,
+        features: @features,
       )
     end
 
@@ -71,11 +92,6 @@ module RubyModKit
       "#{@filename || "(eval)"}[gen #{@generation_num}]"
     end
 
-    # @rbs return: void
-    def resolve
-      perform_missions
-    end
-
     # @rbs return: bool
     def completed?
       @parse_result.errors.empty? && @missions.empty?
@@ -98,14 +114,21 @@ module RubyModKit
       @script[dst_range] || raise(RubyModKit::Error, "Invalid range")
     end
 
+    # @rbs offset: Integer
+    # @rbs return: String
+    def line_by_offset(offset)
+      offset = @offset_diff[offset]
+      (@script.match(/.*\n?/, offset) && Regexp.last_match(0)) || raise(RubyModKit::Error)
+    end
+
     # @rbs (Integer) -> String
-    #    | (Node) -> String
+    #    | (Node::BaseNode) -> String
     #    | (Prism::ParseError) -> String
     def line(*args)
       case args
       in [Integer]
         line__overload0(*args)
-      in [Node]
+      in [Node::BaseNode]
         line__overload1(*args)
       in [Prism::ParseError]
         line__overload2(*args)
@@ -115,11 +138,10 @@ module RubyModKit
     # @rbs line_num: Integer
     # @rbs return: String
     def line__overload0(line_num)
-      offset = @offset_diff[@parse_result.source.offsets[line_num]]
-      (@script.match(/.*\n?/, offset) && Regexp.last_match(0)) || raise(RubyModKit::Error)
+      line_by_offset(@parse_result.source.offsets[line_num])
     end
 
-    # @rbs node: Node
+    # @rbs node: Node::BaseNode
     # @rbs return: String
     def line__overload1(node)
       line(node.prism_node.location.start_line - 1)
@@ -154,10 +176,15 @@ module RubyModKit
       src_offset(parse_error.location.start_line - 1)
     end
 
+    # @rbs return: void
+    def perform_corrector
+      @corrector_manager.perform(self, @root_node, @parse_result, @memo_pad)
+    end
+
     # @rbs return: void
     def perform_missions
       @missions.delete_if do |mission|
-        mission.perform(self, @root_node, @parse_result, @memo) || break
+        mission.perform(self, @root_node, @parse_result, @memo_pad) || break
       end
     end
 
@@ -166,5 +193,16 @@ module RubyModKit
     def add_mission(mission)
       @missions << mission
     end
+
+    class << self
+      # @rbs src: String
+      # @rbs filename: String | nil
+      # @rbs return: Generation
+      def resolve(src, filename: nil)
+        generation = Generation.new(src.dup, filename: filename)
+        generation = generation.succ until generation.completed?
+        generation
+      end
+    end
   end
 end

data/lib/ruby_mod_kit/memo/def_parent_memo.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+# rbs_inline: enabled
+
+module RubyModKit
+  module Memo
+    # The memo for def parent (class, module)
+    class DefParentMemo < OffsetMemo
+      # @rbs @ivars_memo: Hash[Symbol, Memo::IvarMemo]
+
+      attr_reader :ivars_memo #: Hash[Symbol, Memo::IvarMemo]
+
+      # @rbs def_parent_node: Node::DefParentNode
+      # @rbs return: void
+      def initialize(def_parent_node)
+        @ivars_memo = {}
+        super(def_parent_node.offset)
+      end
+
+      # @rbs name: Symbol
+      # @rbs return: Memo::IvarMemo
+      def ivar_memo(name)
+        @ivars_memo[name] ||= Memo::IvarMemo.new(name)
+      end
+
+      # @rbs offset_diff: OffsetDiff
+      # @rbs return: void
+      def succ(offset_diff)
+        @ivars_memo.each_value do |ivar_memo|
+          ivar_memo.succ(offset_diff)
+        end
+        super
+      end
+    end
+  end
+end

data/lib/ruby_mod_kit/memo/{ivar.rb → ivar_memo.rb}

@@ -3,26 +3,31 @@
 # rbs_inline: enabled
 
 module RubyModKit
-  class Memo
+  module Memo
     # The memo for parameter type
-    class Ivar
+    class IvarMemo
       # @rbs @type: nil | String
       # @rbs @attr_kind: nil | Symbol
+      # @rbs @offset: nil | Integer
+      # @rbs @indent: String
       # @rbs @name: Symbol
 
       attr_reader :type #: nil | String
       attr_reader :attr_kind #: nil | Symbol
+      attr_accessor :offset #: nil | Integer
+      attr_accessor :indent #: String
 
       # @rbs name: Symbol
       # @rbs return: void
       def initialize(name)
         @name = name
+        @indent = ""
       end
 
       # @rbs type: String
       # @rbs return: void
       def type=(type)
-        @type = Memo.unify_type(type)
+        @type = RubyModKit.unify_type(type)
       end
 
       # @rbs kind: Symbol | String
@@ -37,6 +42,15 @@ module RubyModKit
           @attr_kind = :attr_accessor
         end
       end
+
+      # @rbs offset_diff: OffsetDiff
+      # @rbs return: void
+      def succ(offset_diff)
+        offset = @offset
+        return unless offset
+
+        @offset = offset_diff[offset]
+      end
     end
   end
 end

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