ruby_mod_kit 0.0.3 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 36509ee4c00db1106b7447ba1d4fe09ee2fd2a8f8ce763c40b1da185f19cfc61
-  data.tar.gz: eccbdb68bb6159aa95c7fda5d171e4089b9dfa9b262ef136caf019fa3c339d7f
+  metadata.gz: bb9b6cf5cb887308d1237eb07d40b4b2b2514173c5e76d19e13a27687f2c107f
+  data.tar.gz: 418e2d01aec4c8f8b4f0b6241625a0b550aec118a3dbd0618987171bb270e4f7
 SHA512:
-  metadata.gz: a8b12f06259193345becd29a14a1c6397481c41b390daed390cf4ed0bc7016afe0fbcf9ba95a9c3639b37150c98791d3e501cf2490725bfc5cf3c405fdc99f94
-  data.tar.gz: 684d9b858ac50e78b40f92a2d1cb8ddaafb99983bbdafc7788d786878af5b03c2187995bbe312de59495c9e4f796c352a9e203428d91018075a88791a79320eb
+  metadata.gz: 17a8efaedb26b0b3256fd0b24501298a1f56fdf4dc8d5c33adc8cb6005abf6c5fcca4c0d1d634b34784dd2528ec57c8d2effdaf4042bc522a15359c86b01b804
+  data.tar.gz: 73758c1ef48bcb7884a6f37859115b952474084abca4b6560f7d21c5380ec4bece1f97e165e6ef27b8270b0f5209877f5b2b63f1cd408ed5b4b6f5cb517d8dc1

data/.ruby_mod_kit.yml

@@ -0,0 +1,5 @@
+features:
+  - instance_variable_parameter
+  - overload
+  - type
+  - type/rbs_inline

data/lib/ruby_mod_kit/cli.rb

@@ -12,7 +12,7 @@ module RubyModKit
     # @rbs *args: String
     # @rbs return: void
     def exec(*args)
-      RubyModKit.execute_file(*args)
+      RubyModKit.execute_file(*args, config: config)
     end
 
     desc "transpile", "transpile rbm files"
@@ -28,9 +28,24 @@ module RubyModKit
       else
         options[:output]
       end
+      config = self.config
       args.each do |path|
-        RubyModKit.transpile_file(path, output: output || RubyModKit.rb_path(path))
+        RubyModKit.transpile_file(path, output: output || RubyModKit.rb_path(path), config: config)
       end
     end
+
+    private
+
+    # @rbs return: Config | nil
+    def config
+      if options[:config]
+        config_path = options[:config]
+        if_none = :raise
+      else
+        config_path = "."
+        if_none = nil
+      end
+      Config.load(config_path, if_none: if_none)
+    end
   end
 end

data/lib/ruby_mod_kit/config.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+# rbs_inline: enabled
+
+require "yaml"
+
+module RubyModKit
+  # config class
+  class Config
+    # @rbs @features: Array[Config]
+
+    attr_reader :features #: Array[Config]
+
+    DEFAULT_FEATURES = %w[instance_variable_parameter overload type type/rbs_inline].freeze #: Array[String]
+
+    # @rbs features: Array[String]
+    # @rbs return: void
+    def initialize(features: DEFAULT_FEATURES)
+      @features = features.sort.map do |feature_name|
+        raise ArgumentError, "invalid feature: #{feature_name}" if feature_name.include?(".")
+
+        require "ruby_mod_kit/feature/#{feature_name}"
+        const_name = feature_name
+          .gsub(/[A-Za-z0-9]+/) { (::Regexp.last_match(0) || "").capitalize }
+          .gsub("_", "").gsub("/", "::")
+        Feature.const_get(const_name).new
+      end
+    end
+
+    class << self
+      # @rbs path: String
+      # @rbs if_none: nil | Symbol
+      # @rbs return: Config | nil
+      def load(path, if_none: nil)
+        return load(File.join(path, ".ruby_mod_kit.yml"), if_none: if_none) if File.directory?(path)
+
+        unless File.exist?(path)
+          case if_none
+          when nil
+            return nil
+          when :raise
+            raise LoadError, "Can't load #{path}"
+          else
+            raise ArgumentError, "unexpected if_none: #{if_none.inspect}"
+          end
+        end
+
+        options = YAML.safe_load(File.read(path), symbolize_names: true)
+        new(**options) if options.is_a?(Hash)
+      end
+    end
+  end
+end

data/lib/ruby_mod_kit/corrector.rb

@@ -12,10 +12,8 @@ module RubyModKit
 
     # @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)
+    def correct(_parse_error, _generation)
       raise RubyModKit::Error, "Unexpected type #{self.class}"
     end
   end

data/lib/ruby_mod_kit/corrector_manager.rb

@@ -23,20 +23,17 @@ module RubyModKit
     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 parse_result.errors.empty?
+    def perform(generation)
+      return true if generation.errors.empty?
 
-      check_prev_errors(generation, parse_result)
-      @previous_error_messages = parse_result.errors.map(&:message)
+      check_prev_errors(generation)
+      @previous_error_messages = generation.errors.map(&:message)
 
-      parse_result.errors.each do |parse_error|
+      generation.errors.each do |parse_error|
         correctors = @correctors_error_map[parse_error.type] || next
         correctors.each do |corrector|
-          corrector.correct(parse_error, generation, root_node, memo_pad)
+          corrector.correct(parse_error, generation)
         end
       end
 
@@ -44,19 +41,18 @@ module RubyModKit
     end
 
     # @rbs generation: Generation
-    # @rbs parse_result: Prism::ParseResult
     # @rbs return: void
-    def check_prev_errors(generation, parse_result)
+    def check_prev_errors(generation)
       return if @previous_error_messages.empty?
-      return if parse_result.errors.empty?
-      return if @previous_error_messages != parse_result.errors.map(&:message)
+      return if generation.errors.empty?
+      return if @previous_error_messages != generation.errors.map(&:message)
 
       message = +""
-      parse_result.errors.each do |parse_error|
+      generation.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})"
-        line = parse_result.source.lines[parse_error.location.start_line - 1]
+        line = generation.lines[parse_error.location.start_line - 1]
         if line
           message << "\n#{line.chomp}\n"
           message << "#{" " * parse_error.location.start_column}^#{"~" * [parse_error.location.length - 1, 0].max}"

data/lib/ruby_mod_kit/feature/instance_variable_parameter/instance_variable_parameter_corrector.rb

@@ -14,26 +14,24 @@ module RubyModKit
 
         # @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)
+        def correct(parse_error, generation)
           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)
+          parameter_position_node = generation.root_node.node_at(src_offset)
           raise RubyModKit::Error unless parameter_position_node
 
           generation[src_offset, parse_error.location.length] = name
-          parameter_memo = memo_pad.parameter_memo(parameter_position_node)
+          parameter_memo = generation.memo_pad.parameter_memo(parameter_position_node)
           parameter_memo.ivar_parameter = true
 
           return unless parameter_memo.untyped?
 
-          def_parent_node = root_node.def_parent_node_at(parse_error.location.start_offset) || return
-          ivar_memo_type = memo_pad.def_parent_memo(def_parent_node).ivar_memo(name.to_sym).type || return
+          def_parent_node = generation.root_node.def_parent_node_at(parse_error.location.start_offset) || return
+          ivar_memo_type = generation.memo_pad.def_parent_memo(def_parent_node).ivar_memo(name.to_sym).type || return
           parameter_memo.type = ivar_memo_type
         end
       end

data/lib/ruby_mod_kit/feature/instance_variable_parameter/instance_variable_parameter_mission.rb

@@ -7,24 +7,17 @@ module RubyModKit
     class InstanceVariableParameter
       # The mission for instance variable arguments
       class InstanceVariableParameterMission < Mission
-        # @rbs @assignment: String
-
-        attr_reader :assignment #: String
-
         # @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_value do |parameter_memo|
+        def perform(generation)
+          generation.memo_pad.parameters_memo.each_value do |parameter_memo|
             next unless parameter_memo.ivar_parameter
 
             offset = parameter_memo.offset
-            parameter_node = root_node.parameter_node_at(offset)
+            parameter_node = generation.root_node.parameter_node_at(offset)
             raise RubyModKit::Error unless parameter_node
 
-            def_node = root_node.def_node_at(offset)
+            def_node = generation.root_node.def_node_at(offset)
             raise RubyModKit::Error, "DefNode not found" unless def_node
 
             def_body_location = def_node.body_location

data/lib/ruby_mod_kit/feature/overload/overload_mission.rb

@@ -20,15 +20,12 @@ module RubyModKit
         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)
+        def perform(generation)
           return true if @modified
 
-          method_memo_groups = memo_pad.methods_memo.each_value.group_by do |method_memo|
-            [root_node.def_parent_node_at(method_memo.offset), method_memo.name]
+          method_memo_groups = generation.memo_pad.methods_memo.each_value.group_by do |method_memo|
+            [generation.root_node.def_parent_node_at(method_memo.offset), method_memo.name]
           end
           method_memo_groups.each_value do |method_memos|
             next if method_memos.length <= 1
@@ -36,16 +33,16 @@ module RubyModKit
             @modified = true
             first_method_memo = method_memos.first
             name = first_method_memo.name
-            first_def_node = root_node.def_node_at(first_method_memo.offset)
+            first_def_node = generation.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 */] || ""
-            src_offset = parse_result.source.offsets[start_line]
+            indent = generation.lines[start_line][/\A */] || ""
+            src_offset = generation.offsets[start_line]
             script = +""
 
-            overload_memo = memo_pad.overload_memo(first_method_memo.offset, name)
+            overload_memo = generation.memo_pad.overload_memo(first_method_memo.offset, name)
 
             method_memos.each do |method_memo|
               type = method_memo.type
@@ -57,7 +54,7 @@ module RubyModKit
             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)
+              def_node = generation.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

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

@@ -7,6 +7,10 @@ module RubyModKit
     class Type
       # the class to correct `@var: Type` -> `# @rbs @var: Type`
       class InstanceVariableColonCorrector < Corrector
+        VISIBILITIES = %i[private public protected].freeze #: Array[Symbol]
+        ATTR_PATTERNS = %i[attr_reader reader getter attr_writer writer setter attr_accessor accessor property].freeze #: Array[Symbol]
+        REGEXP = /(\A\s*)(?:(#{VISIBILITIES.join("|")}) )?(?:(#{ATTR_PATTERNS.join("|")}) )?@(\w*)\s*:\s*(.*)\n/.freeze #: Regexp
+
         # @rbs return: Array[Symbol]
         def correctable_error_types
           %i[unexpected_token_ignore]
@@ -14,32 +18,31 @@ module RubyModKit
 
         # @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)
+        def correct(parse_error, generation)
           return if parse_error.location.slice != ":"
 
-          def_parent_node = root_node.statements_node_at(parse_error.location.start_offset)&.parent
+          def_parent_node = generation.root_node.statements_node_at(parse_error.location.start_offset)&.parent
           return unless def_parent_node.is_a?(Node::DefParentNode)
 
           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*(.*)\n/
+          return if line !~ REGEXP
 
           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)
+          visibility = ::Regexp.last_match(2)
+          attr_kind = ::Regexp.last_match(3)
+          ivar_name = ::Regexp.last_match(4)
+          type = ::Regexp.last_match(5)
           return if !length || !indent || !ivar_name || !type
 
-          ivar_memo = memo_pad.def_parent_memo(def_parent_node).ivar_memo(ivar_name.to_sym)
+          ivar_memo = generation.memo_pad.def_parent_memo(def_parent_node).ivar_memo(ivar_name.to_sym)
           ivar_memo.type = type
           ivar_memo.offset = line_offset
           ivar_memo.indent = indent
           ivar_memo.attr_kind = attr_kind if attr_kind
+          ivar_memo.visibility = visibility.to_sym if visibility
 
           generation[line_offset, length] = ""
         end

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

@@ -14,17 +14,15 @@ module RubyModKit
 
         # @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)
+        def correct(parse_error, generation)
           case parse_error.type
           when :unexpected_token_ignore
             return if parse_error.location.slice != "=>"
 
-            remove_arrow_before_parameter(parse_error, generation, root_node, memo_pad)
+            remove_arrow_before_parameter(parse_error, generation)
           when :def_params_term_paren
-            remove_arrow_after_quailifier(parse_error, generation, root_node, memo_pad)
+            remove_arrow_after_quailifier(parse_error, generation)
           when :argument_formal_constant
             wrap_parameter_type_for_next_parse(parse_error, generation)
           end
@@ -32,11 +30,9 @@ module RubyModKit
 
         # @rbs parse_error: Prism::ParseError
         # @rbs generation: Generation
-        # @rbs root_node: Node::ProgramNode
-        # @rbs memo_pad: MemoPad
         # @rbs return: void
-        def remove_arrow_before_parameter(parse_error, generation, root_node, memo_pad)
-          def_node = root_node.def_node_at(parse_error.location.start_offset) || return
+        def remove_arrow_before_parameter(parse_error, generation)
+          def_node = generation.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
@@ -49,15 +45,13 @@ module RubyModKit
           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_pad.parameter_memo(last_parameter_node).type = parameter_type
+          generation.memo_pad.parameter_memo(last_parameter_node).type = parameter_type
         end
 
         # @rbs parse_error: Prism::ParseError
         # @rbs generation: Generation
-        # @rbs root_node: Node::ProgramNode
-        # @rbs memo_pad: MemoPad
         # @rbs return: void
-        def remove_arrow_after_quailifier(parse_error, generation, root_node, memo_pad)
+        def remove_arrow_after_quailifier(parse_error, generation)
           column = parse_error.location.start_column - 1
           return if column < 0
 
@@ -66,10 +60,10 @@ module RubyModKit
           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
+          parameter_position_node = generation.root_node.node_at(offset + length) || return
 
           generation[parse_error.location.start_offset, length - 1] = ""
-          parameter_memo = memo_pad.parameter_memo(parameter_position_node)
+          parameter_memo = generation.memo_pad.parameter_memo(parameter_position_node)
           parameter_memo.type = type
           parameter_memo.qualifier = "*"
         end

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

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+# rbs_inline: enabled
+
+module RubyModKit
+  class Feature
+    class Type
+      class RbsInline
+        # The mission to add magic comment
+        class AddMagicCommentMission < Mission
+          # @rbs @reloaded: bool
+
+          # @rbs return: void
+          def initialize
+            super
+            @reloaded = false
+          end
+
+          # @rbs generation: Generation
+          # @rbs return: bool
+          def perform(generation)
+            return true unless generation.memo_pad.flags[:rbs_annotated]
+
+            unless @reloaded
+              @reloaded = true
+              return false
+            end
+
+            offset = 0
+            separated = false
+            generation.lines.each do |line|
+              break if line =~ /^# @rbs/
+              break if line !~ /^#( rbs_inline: enabled)?|(^$)/
+              return true if ::Regexp.last_match(1)
+
+              separated = !::Regexp.last_match(2).nil?
+
+              offset += line.length
+            end
+            script = +""
+            script << "\n" unless separated
+            generation[offset, 0] = "# rbs_inline: enabled\n\n"
+            true
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -9,16 +9,20 @@ module RubyModKit
         # The mission for parameter types
         class TypeAttrMission < 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 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 = root_node.def_parent_node_at(def_parent_memo.offset) || raise(RubyModKit::Error)
+              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)
 
@@ -28,7 +32,8 @@ module RubyModKit
                 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
+                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

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

@@ -9,16 +9,14 @@ module RubyModKit
         # 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 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 = root_node.def_parent_node_at(offset) || next
-                body_line_offset = parse_result.source.offsets[def_parent_node.prism_node.location.start_line]
+                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

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

@@ -9,17 +9,14 @@ module RubyModKit
         # 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)
+          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 = root_node.def_node_at(offset) || raise(RubyModKit::Error)
+              def_node = generation.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 */] || ""
+              indent = generation.lines[start_line][/\A */] || ""
               offset -= indent.length
 
               annotation = +""
@@ -32,6 +29,7 @@ module RubyModKit
                 annotation << " (#{parameter_types.join(", ")}) -> #{return_type}\n"
               end
               annotation.gsub!(/^/, indent)
+              generation.memo_pad.flags[:rbs_annotated] = true
               generation[offset, 0] = annotation
             end
             true

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

@@ -9,24 +9,22 @@ module RubyModKit
         # 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|
+          def perform(generation)
+            generation.memo_pad.parameters_memo.each do |offset, parameter_memo|
               next if parameter_memo.untyped?
 
-              def_node = root_node.def_node_at(offset)
+              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 = root_node.parameter_node_at(offset)
+              parameter_node = generation.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]
+              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

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

@@ -9,18 +9,16 @@ module RubyModKit
         # 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)
+          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 = parse_result.source.offsets[def_node.location.start_line - 1]
+              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

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

@@ -15,6 +15,8 @@ module RubyModKit
             TypeOverloadMission.new,
             TypeParameterMission.new,
             TypeReturnMission.new,
+            # This mission must be the last
+            AddMagicCommentMission.new,
           ]
         end
       end
@@ -22,6 +24,7 @@ module RubyModKit
   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"

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

@@ -14,13 +14,11 @@ module RubyModKit
 
         # @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)
+        def correct(parse_error, generation)
           return if parse_error.location.slice != ":"
 
-          def_node = root_node.statements_node_at(parse_error.location.start_offset)&.parent
+          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
@@ -34,10 +32,10 @@ module RubyModKit
           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)
+          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] = ""
-          memo_pad.method_memo(def_node).type = return_type_location.slice
+          generation.memo_pad.method_memo(def_node).type = return_type_location.slice
         end
       end
     end