ruby_mod_kit 0.0.1 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e3a08a3d1865aa1abd27922326dc12e4cfc6c9a621f0c73882a64c12a80cc3d4
-  data.tar.gz: d30dd20e654a68c233f33925f6f27938a3920675df07dea1377f31ba8fa42ab6
+  metadata.gz: 36509ee4c00db1106b7447ba1d4fe09ee2fd2a8f8ce763c40b1da185f19cfc61
+  data.tar.gz: eccbdb68bb6159aa95c7fda5d171e4089b9dfa9b262ef136caf019fa3c339d7f
 SHA512:
-  metadata.gz: cc67818cecc1c39a1aaf1f925a8ebd59dab9220a77e0d1e2dd19be99ea7b8b72e582e4a8d794966ab411125b229084f339f85cd427eebf33e29f88ee576eb111
-  data.tar.gz: ed11c866fba06fe283e1957ba41c2138194cdc3d5049dfe9cefdee662519d3e222ef5ac8b9b5f491e579fef4db049c11b3b46074f5f7fe8585c7cf2c84ab94d5
+  metadata.gz: a8b12f06259193345becd29a14a1c6397481c41b390daed390cf4ed0bc7016afe0fbcf9ba95a9c3639b37150c98791d3e501cf2490725bfc5cf3c405fdc99f94
+  data.tar.gz: 684d9b858ac50e78b40f92a2d1cb8ddaafb99983bbdafc7788d786878af5b03c2187995bbe312de59495c9e4f796c352a9e203428d91018075a88791a79320eb

data/README.md

@@ -20,20 +20,26 @@ If bundler is not being used to manage dependencies, install the gem by executin
 #### `transpile`
 
 You can get transpiled ruby script from .rbm file by `ruby_mod_kit transpile` command.
+`transpile` command outputs script to stdout by default. `--output` can change output target.
+`--output=.rb` is a special pattern that means "Output the original script file name with the extension changed to .rb".
 
-```
-ruby_mod_kit transpile path/to/script.rbm
-```
+These below have the same meaning: "Output ruby script to stdout".
+
+    $ ruby_mod_kit transpile path/to/script.rbm
+    $ ruby_mod_kit transpile --output=- path/to/script.rbm
+    $ ruby_mod_kit transpile --output=/dev/stdout path/to/script.rbm
+
+These below have the same meaning: "Output ruby script to `path/to/script.rb`".
+
+    $ ruby_mod_kit transpile path/to/script.rbm > path/to/script.rb
+    $ ruby_mod_kit transpile --output=path/to/script.rb path/to/script.rbm
+    $ ruby_mod_kit transpile --output=.rb path/to/script.rbm
 
 #### `exec`
 
 You can run transpiled ruby script by `ruby_mod_kit exec` command.
 
-```
-ruby_mod_kit transpile path/to/script.rbm
-```
-
-The command also creates/updates ruby script before running.
+    $ ruby_mod_kit exec path/to/script.rbm
 
 ## Feature
 

data/lib/ruby_mod_kit/cli.rb

@@ -16,11 +16,20 @@ module RubyModKit
     end
 
     desc "transpile", "transpile rbm files"
+    method_option :output, type: :string
     # @rbs *args: String
     # @rbs return: void
     def transpile(*args)
+      output = case options[:output]
+      when nil, "-", "/dev/stdout"
+        $stdout
+      when ".rb"
+        nil
+      else
+        options[:output]
+      end
       args.each do |path|
-        RubyModKit.transpile_file(path)
+        RubyModKit.transpile_file(path, output: output || RubyModKit.rb_path(path))
       end
     end
   end

data/lib/ruby_mod_kit/core_ext/eval.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+# rbs_inline: enabled
+
+require "ruby_mod_kit"
+
+# Define RubyMotKit.eval
+module RubyModKit
+  module CoreExt
+    # the extension for eval
+    module Eval
+      module_function
+
+      # @rbs expr: String
+      # @rbs *rest: Object
+      # @rbs transpile: bool
+      # @rbs return: Object
+      def eval(expr, *rest, transpile: true)
+        if transpile
+          fname = rest[1].is_a?(String) ? rest[1] : "(eval)"
+          expr = RubyModKit.transpile(expr, filename: fname)
+        end
+
+        case rest
+        in [] | [Binding] | [Binding, String] | [Binding, String, Integer]
+          super(expr, *rest)
+        end
+      end
+    end
+  end
+
+  class << self
+    include(CoreExt::Eval)
+    public :eval
+  end
+end

data/lib/ruby_mod_kit/core_ext/load.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+# rbs_inline: enabled
+
+require "ruby_mod_kit"
+require_relative "eval"
+
+# Define RubyMotKit.load/require
+module RubyModKit
+  module CoreExt
+    # the extension for load/require
+    module Load
+      LOADABLE_EXTS = %w[.rb .rbm .so .o .dll].freeze #: Array[String]
+
+      module_function
+
+      # @rbs path: String
+      # @rbs wrap: bool
+      # @rbs return: bool
+      def load(path, wrap = false) # rubocop:disable Style/OptionalBooleanParameter
+        return super unless path.end_with?(".rbm")
+
+        b = wrap ? binding : TOPLEVEL_BINDING
+        RubyModKit::CoreExt::Eval.eval(File.read(path), b, path)
+        true
+      end
+
+      # @rbs path: String
+      # @rbs return: bool
+      def require(path)
+        require_path = Load.require_path(path)
+        return super unless require_path&.end_with?(".rbm")
+        return false if Load.loaded_features.include?(require_path)
+
+        Load.loaded_features << require_path
+        load(require_path)
+        true
+      end
+
+      class << self
+        # @rbs return: Array[String]
+        def loaded_features
+          $LOADED_FEATURES
+        end
+
+        # @rbs return: Array[String]
+        def load_path
+          $LOAD_PATH
+        end
+
+        # @rbs path: String
+        # @rbs expanded: bool
+        # @rbs return: String | nil
+        def require_path(path, expanded: false)
+          if !expanded && !File.absolute_path?(path)
+            return load_path.each.lazy.map { require_path(File.join(_1, path), expanded: true) }.find(&:itself)
+          end
+
+          pathes = if path.end_with?(*LOADABLE_EXTS)
+            [path]
+          else
+            LOADABLE_EXTS.map { "#{path}#{_1}" }
+          end
+          pathes.find { File.exist?(_1) }
+        end
+      end
+    end
+  end
+
+  class << self
+    include(CoreExt::Load)
+    public :load, :require, :require_relative
+  end
+end

data/lib/ruby_mod_kit/core_ext.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require_relative "core_ext/eval"
+require_relative "core_ext/load"
+
+Object.prepend(RubyModKit::CoreExt::Eval)
+Object.prepend(RubyModKit::CoreExt::Load)

data/lib/ruby_mod_kit/corrector.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+# rbs_inline: enabled
+
+module RubyModKit
+  # the base class of corrector
+  class Corrector
+    # @rbs return: Array[Symbol]
+    def correctable_error_types
+      []
+    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)
+      raise RubyModKit::Error, "Unexpected type #{self.class}"
+    end
+  end
+end

data/lib/ruby_mod_kit/corrector_manager.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+# rbs_inline: enabled
+
+module RubyModKit
+  # the class to manege parse error correctors
+  class CorrectorManager
+    # @rbs @previous_error_messages: Array[String]
+    # @rbs @correctors_error_map: Hash[Symbol, Array[Corrector]]
+
+    # @rbs features: Array[Feature]
+    # @rbs return: void
+    def initialize(features)
+      @previous_error_messages = []
+      @correctors_error_map = {}
+      features.each do |feature|
+        feature.create_correctors.each do |corrector|
+          corrector.correctable_error_types.each do |error_type|
+            (@correctors_error_map[error_type] ||= []) << corrector
+          end
+        end
+      end
+    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?
+
+      check_prev_errors(generation, parse_result)
+      @previous_error_messages = parse_result.errors.map(&:message)
+
+      parse_result.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)
+        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})"
+        line = parse_result.source.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}"
+        end
+      end
+      raise RubyModKit::SyntaxError, message
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+# rbs_inline: enabled
+
+module RubyModKit
+  class Feature
+    class InstanceVariableParameter
+      # the class to correct `def foo(@bar) ...` -> `def foo(bar) ...`
+      class InstanceVariableParameterCorrector < Corrector
+        # @rbs return: Array[Symbol]
+        def correctable_error_types
+          %i[argument_formal_ivar]
+        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)
+          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_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
+          parameter_memo.type = ivar_memo_type
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+# rbs_inline: enabled
+
+module RubyModKit
+  class Feature
+    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|
+            next unless parameter_memo.ivar_parameter
+
+            offset = parameter_memo.offset
+            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"
+          end
+          true
+        end
+      end
+    end
+  end
+end

data/lib/ruby_mod_kit/feature/instance_variable_parameter.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+# rbs_inline: enabled
+
+module RubyModKit
+  class Feature
+    # namespace for instance_variable parameter feature
+    class InstanceVariableParameter < Feature
+      # @rbs return: Array[Corrector]
+      def create_correctors
+        [
+          InstanceVariableParameterCorrector.new,
+        ]
+      end
+
+      # @rbs return: Array[Mission]
+      def create_missions
+        [
+          InstanceVariableParameterMission.new,
+        ]
+      end
+    end
+  end
+end
+
+require_relative "instance_variable_parameter/instance_variable_parameter_corrector"
+require_relative "instance_variable_parameter/instance_variable_parameter_mission"

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

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+# rbs_inline: enabled
+
+module RubyModKit
+  class Feature
+    class Overload
+      # The mission for overload
+      class OverloadMission < Mission
+        # @rbs @modified: bool
+
+        OVERLOAD_METHOD_MAP = {
+          "*": "_mul",
+        }.freeze #: Hash[Symbol, String]
+
+        # @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
+
+          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]
+          end
+          method_memo_groups.each_value do |method_memos|
+            next if method_memos.length <= 1
+
+            @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)
+            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]
+            script = +""
+
+            overload_memo = memo_pad.overload_memo(first_method_memo.offset, name)
+
+            method_memos.each do |method_memo|
+              type = method_memo.type
+              type = "(#{type})" if type.include?(" ")
+              overload_memo.add_overload_type(method_memo.parameters.map(&:type), type)
+            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
+
+          # if script has been changed, request reparsing before proceeding to the next mission
+          !@modified
+        end
+      end
+    end
+  end
+end

data/lib/ruby_mod_kit/feature/overload.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+# rbs_inline: enabled
+
+module RubyModKit
+  class Feature
+    # namespace for overload feature
+    class Overload < Feature
+      # @rbs return: Array[Mission]
+      def create_missions
+        [
+          OverloadMission.new,
+        ]
+      end
+    end
+  end
+end
+
+require_relative "overload/overload_mission"

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

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+# rbs_inline: enabled
+
+module RubyModKit
+  class Feature
+    class Type
+      # the class to correct `@var: Type` -> `# @rbs @var: Type`
+      class InstanceVariableColonCorrector < 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_parent_node = 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/
+
+          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_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
+
+          generation[line_offset, length] = ""
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+# rbs_inline: enabled
+
+module RubyModKit
+  class Feature
+    class Type
+      # the class to correct `def foo(Bar => bar, *Buz => buz)` -> `def foo(bar, *buz)`
+      class ParameterArrowCorrector < Corrector
+        # @rbs return: Array[Symbol]
+        def correctable_error_types
+          %i[unexpected_token_ignore def_params_term_paren argument_formal_constant]
+        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)
+          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)
+          when :def_params_term_paren
+            remove_arrow_after_quailifier(parse_error, generation, root_node, memo_pad)
+          when :argument_formal_constant
+            wrap_parameter_type_for_next_parse(parse_error, generation)
+          end
+        end
+
+        # @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_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_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)
+          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_pad.parameter_memo(parameter_position_node)
+          parameter_memo.type = type
+          parameter_memo.qualifier = "*"
+        end
+
+        # @rbs parse_error: Prism::ParseError
+        # @rbs generation: Generation
+        # @rbs return: void
+        def wrap_parameter_type_for_next_parse(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
+      end
+    end
+  end
+end

data/lib/ruby_mod_kit/feature/type/rbs_inline/type_attr_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 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|
+              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.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)
+
+                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
+            end
+            true
+          end
+        end
+      end
+    end
+  end
+end