ruby_mod_kit 0.0.2 → 0.0.4

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+# rbs_inline: enabled
+
+module RubyModKit
+  class Feature
+    class Type
+      class RbsInline
+        # The mission for parameter types
+        class TypeAttrMission < Mission
+          # @rbs generation: Generation
+          # @rbs return: bool
+          def perform(generation)
+            generation.memo_pad.def_parents_memo.each_value do |def_parent_memo|
+              ivars_memo = def_parent_memo.ivars_memo.dup
+              def_parent_node = generation.root_node.def_parent_node_at(def_parent_memo.offset)
+              raise(RubyModKit::Error) unless def_parent_node
+
+              def_parent_node.body_node&.children&.each do |call_node|
+                break if ivars_memo.empty?
+
+                if call_node.is_a?(Node::CallNode) && %i[public private protected].include?(call_node.name)
+                  call_node = call_node.children[0]
+                  call_node = call_node.children[0] if call_node
+                end
+                next unless call_node.is_a?(Node::CallNode)
+                next unless %i[attr_reader attr_writer attr_accessor].include?(call_node.name)
+
+                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.*(#{call_node.name}\s+:#{name})(?=\n\z)/, 1]&.length || next
+                generation.memo_pad.flags[:rbs_annotated] = true
+                generation[call_node.location.start_offset + length, 0] = " #: #{ivar_memo.type}"
+              end
+            end
+            true
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+# 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 return: bool
+          def perform(generation)
+            generation.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 = generation.root_node.def_parent_node_at(offset) || next
+                body_line_offset = generation.offsets[def_parent_node.location.start_line]
+                generation.memo_pad.flags[:rbs_annotated] = true
+                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,41 @@
+# 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 return: bool
+          def perform(generation)
+            generation.memo_pad.overloads_memo.each_value do |overload_memo|
+              overload_memo.correct_offset(generation.root_node)
+              offset = overload_memo.offset
+              def_node = generation.root_node.def_node_at(offset) || raise(RubyModKit::Error)
+              start_line = def_node.location.start_line - 1
+              indent = generation.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.memo_pad.flags[:rbs_annotated] = true
+              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,36 @@
+# 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 return: bool
+          def perform(generation)
+            generation.memo_pad.parameters_memo.each do |offset, parameter_memo|
+              next if parameter_memo.untyped?
+
+              def_node = generation.root_node.def_node_at(offset)
+              raise RubyModKit::Error, "DefNode not found" if !def_node || !def_node.is_a?(Node::DefNode)
+
+              parameter_node = generation.root_node.parameter_node_at(offset)
+              raise RubyModKit::Error, "ParameterNode not found" unless parameter_node
+
+              type = parameter_memo.type
+              src_offset = generation.offsets[def_node.location.start_line - 1]
+              indent = def_node.offset - src_offset
+              qualified_name = "#{parameter_memo.qualifier}#{parameter_node.name}"
+              generation.memo_pad.flags[:rbs_annotated] = true
+              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,30 @@
+# 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 return: bool
+          def perform(generation)
+            generation.memo_pad.methods_memo.each do |offset, method_memo|
+              def_node = generation.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 = generation.offsets[def_node.location.start_line - 1]
+              indent = offset - src_offset
+              generation.memo_pad.flags[:rbs_annotated] = true
+              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,32 @@
+# 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,
+            # This mission must be the last
+            AddMagicCommentMission.new,
+          ]
+        end
+      end
+    end
+  end
+end
+
+require_relative "rbs_inline/add_magic_comment_mission"
+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,43 @@
+# 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 return: void
+        def correct(parse_error, generation)
+          return if parse_error.location.slice != ":"
+
+          def_node = generation.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 = generation.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] = ""
+          generation.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,69 @@
+# frozen_string_literal: true
+
+# rbs_inline: enabled
+
+module RubyModKit
+  class Feature
+    class Type
+      # The mission for parameter attributes
+      class TypeAttrMission < Mission
+        # @rbs @modified: bool
+
+        # @rbs return: void
+        def initialize
+          super
+          @modified = false
+        end
+
+        # @rbs generation: Generation
+        # @rbs return: bool
+        def perform(generation)
+          return true if @modified
+
+          generation.memo_pad.def_parents_memo.each_value do |def_parent_memo|
+            attr_adding_line = 0
+            ivars_memo = def_parent_memo.ivars_memo.dup
+            def_parent_node = generation.root_node.def_parent_node_at(def_parent_memo.offset)
+            raise(RubyModKit::Error) unless def_parent_node
+
+            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|
+              attr = ivar_memo.attr_kind
+              attr = "#{ivar_memo.visibility} #{attr}" if ivar_memo.visibility
+              generation[offset, 0] = "#{indent}#{attr} :#{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,18 @@
+# frozen_string_literal: true
+
+# rbs_inline: enabled
+
+module RubyModKit
+  # the base class of feature
+  class Feature
+    # @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

@@ -5,33 +5,53 @@
 module RubyModKit
   # The class of transpiler generation.
   class Generation
-    # @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]
+    # @rbs @config: Config
+    # @rbs @errors: Array[Prism::ParseError]
+    # @rbs @lines: Array[String]
+    # @rbs @offsets: Array[Integer]
 
-    attr_reader :parse_result #: Prism::ParseResult
     attr_reader :script #: String
+    attr_reader :memo_pad #: MemoPad
+    attr_reader :root_node #: Node::ProgramNode
+    attr_reader :errors #: Array[Prism::ParseError]
+    attr_reader :lines #: Array[String]
+    attr_reader :offsets #: Array[Integer]
 
     # @rbs script: String
     # @rbs missions: Array[Mission]
-    # @rbs memo: Memo
+    # @rbs memo_pad: MemoPad | nil
     # @rbs generation_num: Integer
+    # @rbs config: Config | nil
     # @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, config: nil,
+                   filename: nil, corrector_manager: nil, features: nil)
       @script = script
       @missions = missions
-      @memo = memo
       @generation_num = generation_num
       @filename = filename
+      @config = config || Config.new
+      @features = features || @config.features
+
+      @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)
+      parse_result = Prism.parse(@script)
+      @errors = parse_result.errors
+      @lines = parse_result.source.lines
+      @offsets = parse_result.source.offsets
+      @root_node = Node::ProgramNode.new(parse_result.value)
       init_missions
     end
 
@@ -39,11 +59,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 +73,25 @@ module RubyModKit
 
     # @rbs return: Generation
     def succ
+      if @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,
+        config: @config,
       )
     end
 
@@ -71,14 +100,9 @@ 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?
+      @errors.empty? && @missions.empty?
     end
 
     # @rbs src_offset: Integer
@@ -98,14 +122,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,14 +146,13 @@ 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(@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)
+      line(node.location.start_line - 1)
     end
 
     # @rbs parse_error: Prism::ParseError
@@ -145,7 +175,7 @@ module RubyModKit
     # @rbs line_num: Integer
     # @rbs return: Integer | nil
     def src_offset__overload0(line_num)
-      parse_result.source.offsets[line_num]
+      @offsets[line_num]
     end
 
     # @rbs parse_error: Prism::ParseError
@@ -154,10 +184,15 @@ module RubyModKit
       src_offset(parse_error.location.start_line - 1)
     end
 
+    # @rbs return: void
+    def perform_corrector
+      @corrector_manager.perform(self)
+    end
+
     # @rbs return: void
     def perform_missions
       @missions.delete_if do |mission|
-        mission.perform(self, @root_node, @parse_result, @memo) || break
+        mission.perform(self) || break
       end
     end
 
@@ -166,5 +201,17 @@ module RubyModKit
     def add_mission(mission)
       @missions << mission
     end
+
+    class << self
+      # @rbs src: String
+      # @rbs filename: String | nil
+      # @rbs config: Config | nil
+      # @rbs return: Generation
+      def resolve(src, filename: nil, config: nil)
+        generation = Generation.new(src.dup, filename: filename, config: config)
+        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,33 @@
 # 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
+      # @rbs @visibility: nil | Symbol
 
       attr_reader :type #: nil | String
       attr_reader :attr_kind #: nil | Symbol
+      attr_accessor :offset #: nil | Integer
+      attr_accessor :indent #: String
+      attr_accessor :visibility #: nil | Symbol
 
       # @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 +44,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