typeprof 0.31.1 → 0.33.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 937e0870f11951c34a3c7903f0c6e02b2ba0b557d327999a8ce807e195409088
-  data.tar.gz: ab8eca2e1cbb24729bbc0274bce7ed3ddd59917accd81285069ebc0086fe0208
+  metadata.gz: 8dc7b580d84d82c2a49d4a2d24ddf32ddcafc938d4f9511fc4b6d4543f0b8e19
+  data.tar.gz: eed64be210440c2ea2627a7b21c95c7eedee374b760e9e6aa479dfa4c27df54f
 SHA512:
-  metadata.gz: 40b2629987ea3feed461c74c279cabb25ad462c0e0118d3d451c12387de4cdbab39b1dd1301ee86ceb6f6f5bbb25b4c5425a72749a11eabe2485a35ea463e5a3
-  data.tar.gz: c8704511e6507f9e50df4b626fb9b481e945954688df4d6c26ecd233b530eb4f1e2e038589c2538f209e9f6cec15c26401d854f48d8ea346325507f29246a475
+  metadata.gz: b314eccaecb06cac94df1af7ab96084b06d1d70710c9ece6934c98ca5379ca98e82ab93838322081357d13c0200681beb24d6108f699aac4a8904952333a7d83
+  data.tar.gz: 7ebcd55f8c8d91b1eac583c7d585723de31a83da5fa85c7485cda77e520e24d09f1652b1dde7657db62c8151166cbfdc71d3563647ccd60871bb31e74fc6055a

data/README.md

@@ -37,7 +37,8 @@ $ bundle exec rake test
 
 ## More details
 
-https://speakerdeck.com/mame/good-first-issues-of-typeprof
+- [Good first issues of TypeProf](https://speakerdeck.com/mame/good-first-issues-of-typeprof) (slides)
+- [How to report bugs / propose features](doc/report_guide.md)
 
 ## LICENSE
 

data/doc/report_guide.md

@@ -0,0 +1,88 @@
+# How to Report Bugs and Propose Features
+
+Thank you for your interest in improving TypeProf! When reporting a bug or proposing a feature, including a **scenario file** is very helpful (but not mandatory).
+
+## What is a Scenario File?
+
+A scenario file describes TypeProf's behavior — the input code and the expected type inference result. You can find many examples in the [`scenario/`](../scenario/) directory.
+
+## Writing a Scenario File
+
+### Basic pattern
+
+A minimal scenario file has two sections: `## update` (input code) and `## assert` (expected type signatures in [RBS](https://github.com/ruby/rbs) syntax).
+
+```ruby
+## update
+def foo(n)
+  n.to_s
+end
+
+foo(42)
+
+## assert
+class Object
+  def foo: (Integer) -> String
+end
+```
+
+### Multiple updates
+
+You can include multiple `## update` / `## assert` pairs to test how TypeProf handles code changes:
+
+```ruby
+## update
+def foo = "symbol#{ 42 }"
+
+## assert
+class Object
+  def foo: -> String
+end
+
+## update
+def foo = :"symbol#{ 42 }"
+
+## assert
+class Object
+  def foo: -> Symbol
+end
+```
+
+### Diagnostics
+
+Use `## diagnostics` to verify that TypeProf reports type errors at the expected locations:
+
+```ruby
+## update
+def foo(x)
+  x
+end
+
+foo(1, 2)
+
+## diagnostics
+(5,0)-(5,3): wrong number of arguments (2 for 1)
+```
+
+## Running a Scenario File
+
+Run a single scenario file:
+
+```sh
+$ ruby tool/scenario_runner.rb path/to/your_scenario.rb
+```
+
+Run all tests:
+
+```sh
+$ bundle exec rake test
+```
+
+## Reporting a Bug
+
+1. Create a scenario file that reproduces the issue.
+2. Run it with `ruby tool/scenario_runner.rb your_scenario.rb` to confirm the problem.
+3. Open an issue and include:
+   - Your TypeProf version (`typeprof --version`)
+   - The scenario file content
+   - What you expected vs. what actually happened

data/lib/typeprof/cli/cli.rb

@@ -12,6 +12,7 @@ module TypeProf::CLI
       output = nil
       rbs_collection_path = nil
       initialize_config_file = false
+      exclude_patterns = []
 
       opt.separator ""
       opt.separator "Options:"
@@ -25,6 +26,7 @@ module TypeProf::CLI
       opt.on("--version", "Display typeprof version") { cli_options[:display_version] = true }
       opt.on("--collection PATH", "File path of collection configuration") { |v| rbs_collection_path = v }
       opt.on("--no-collection", "Ignore collection configuration") { rbs_collection_path = :no }
+      opt.on("--exclude PATTERN", "Exclude files matching glob PATTERN (can be specified multiple times)") { |v| exclude_patterns << v }
       opt.on("--lsp", "LSP server mode") do |v|
         core_options[:display_indicator] = false
         cli_options[:lsp] = true
@@ -36,6 +38,7 @@ module TypeProf::CLI
       opt.on("--[no-]show-errors", "Display possible errors found during the analysis") {|v| core_options[:output_diagnostics] = v }
       opt.on("--[no-]show-parameter-names", "Display parameter names for methods") {|v| core_options[:output_parameter_names] = v }
       opt.on("--[no-]show-source-locations", "Display definition source locations for methods") {|v| core_options[:output_source_locations] = v }
+      opt.on("--[no-]show-stats", "Display type inference statistics after analysis (for debugging purpose)") {|v| core_options[:output_stats] = v }
 
       opt.separator ""
       opt.separator "Advanced options:"
@@ -65,6 +68,8 @@ module TypeProf::CLI
         output_errors: false,
         output_parameter_names: false,
         output_source_locations: false,
+        output_stats: false,
+        exclude_patterns: exclude_patterns,
       }.merge(core_options)
 
       @lsp_options = {
@@ -120,7 +125,7 @@ module TypeProf::CLI
       if @lsp_options[:stdio]
         TypeProf::LSP::Server.start_stdio(@core_options)
       else
-        TypeProf::LSP::Server.start_socket(@core_options)
+        TypeProf::LSP::Server.start_socket(@core_options, @lsp_options[:port])
       end
     rescue Exception
       puts $!.detailed_message(highlight: false).gsub(/^/, "---")
@@ -151,7 +156,7 @@ module TypeProf::CLI
       files = []
       @cli_options[:argv].each do |path|
         if File.directory?(path)
-          files.concat(Dir.glob("#{ path }/**/*.{rb,rbs}"))
+          files.concat(Dir.glob("#{ path }/**/*.{rb,rbs}").select {|f| File.file?(f) })
         elsif File.file?(path)
           files << path
         else
@@ -189,7 +194,8 @@ module TypeProf::CLI
         {
           "typeprof_version": "experimental",
           "rbs_dir": "sig/",
-          "analysis_unit_dirs": #{exist_dirs.inspect}
+          "analysis_unit_dirs": #{exist_dirs.inspect},
+          // "exclude": ["**/templates/**/*.rb"],
           // "diagnostic_severity": "warning"
         }
       JSONC

data/lib/typeprof/code_range.rb

@@ -55,12 +55,14 @@ module TypeProf
       raise unless first
     end
 
-    def self.from_node(node, encoding = Encoding::UTF_16LE)
+    def self.from_node(node, file_context)
       node = node.location if node.respond_to?(:location)
-      if node.is_a?(Prism::Location)
-        pos1 = CodePosition.new(node.start_line, node.start_code_units_column(encoding))
-        pos2 = CodePosition.new(node.end_line, node.end_code_units_column(encoding))
-      elsif node.is_a?(RBS::Location)
+      case node
+      when Prism::Location
+        start_col, end_col = file_context.column_offsets_for(node)
+        pos1 = CodePosition.new(node.start_line, start_col)
+        pos2 = CodePosition.new(node.end_line, end_col)
+      when RBS::Location
         pos1 = CodePosition.new(*node.start_loc)
         pos2 = CodePosition.new(*node.end_loc)
       else

data/lib/typeprof/core/ast/base.rb

@@ -9,7 +9,7 @@ module TypeProf::Core
         @ret = nil
 
         @changes = ChangeSet.new(self, nil)
-        @diagnostics = Set[]
+        @diagnostics = Set::EMPTY
       end
 
       attr_reader :lenv
@@ -53,7 +53,7 @@ module TypeProf::Core
 
       def code_range
         if @raw_node
-          TypeProf::CodeRange.from_node(@raw_node)
+          @lenv.code_range_from_node(@raw_node)
         else
           pp self
           raise
@@ -104,6 +104,7 @@ module TypeProf::Core
         @changes.reuse(self)
         (@prev_node || raise).diagnostics.each do |diag|
           diag.reuse(self)
+          @diagnostics = Set.empty if @diagnostics.equal?(Set::EMPTY)
           @diagnostics << diag
         end
         each_subnode do |subnode|
@@ -117,6 +118,19 @@ module TypeProf::Core
         raise "should override"
       end
 
+      # Counterpart of install/install0 for pattern position; reuses the install
+      # machinery so @changes is reconciled the same way during incremental analysis.
+      def install_pattern(genv, subject)
+        @ret = install_pattern0(genv, subject)
+        @changes.reinstall(genv)
+        @ret
+      end
+
+      # By default a pattern behaves as a plain expression, ignoring the matched value.
+      def install_pattern0(genv, subject)
+        install0(genv)
+      end
+
       def uninstall(genv)
         @changes.reinstall(genv)
         each_subnode do |subnode|
@@ -129,11 +143,12 @@ module TypeProf::Core
       end
 
       def add_diagnostic(diag)
+        @diagnostics = Set.empty if @diagnostics.equal?(Set::EMPTY)
         @diagnostics << diag
       end
 
       def remove_diagnostic(diag)
-        @diagnostics.delete(diag)
+        @diagnostics.delete(diag) unless @diagnostics.equal?(Set::EMPTY)
       end
 
       def diff(prev_node)
@@ -209,20 +224,30 @@ module TypeProf::Core
     end
 
     class ProgramNode < Node
-      def initialize(raw_node, lenv)
+      def initialize(raw_node, lenv, ignore_ranges: [])
         super(raw_node, lenv)
 
         @tbl = raw_node.locals
+        @ignore_ranges = ignore_ranges
         raw_body = raw_node.statements
 
         @body = AST.create_node(raw_body, lenv, false)
       end
 
-      attr_reader :tbl, :body
+      attr_reader :tbl, :ignore_ranges, :body
 
       def subnodes = { body: }
       def attrs = { tbl: }
 
+      def each_diagnostic(genv, &blk)
+        return super if @ignore_ranges.empty?
+        super(genv) do |diag|
+          line = diag.code_range&.first&.lineno
+          next if line && @ignore_ranges.any? { |r| r.cover?(line) }
+          blk.call(diag)
+        end
+      end
+
       def install0(genv)
         @tbl.each {|var| @lenv.locals[var] = Source.new(genv.nil_type) }
         @lenv.locals[:"*self"] = lenv.cref.get_self(genv)
@@ -270,7 +295,7 @@ module TypeProf::Core
         @ret = ret
       end
 
-      attr_reader :lenv, :prev_node, :ret
+      attr_reader :lenv, :prev_node, :code_range, :ret
 
       def boxes(_)
         []

data/lib/typeprof/core/ast/call.rb

@@ -1,12 +1,12 @@
 module TypeProf::Core
   class AST
     class CallBaseNode < Node
-      def initialize(raw_node, recv, mid, mid_code_range, raw_args, last_arg, raw_block, lenv)
+      def initialize(raw_node, recv, mid, mid_code_range_loc, raw_args, last_arg, raw_block, lenv, forwarding_arguments: false)
         super(raw_node, lenv)
 
         @recv = recv
         @mid = mid
-        @mid_code_range = mid_code_range
+        @mid_code_range_loc = mid_code_range_loc
 
         # args
         @positional_args = []
@@ -16,9 +16,11 @@ module TypeProf::Core
         @block_pass = nil
         @block_tbl = nil
         @block_f_args = nil
+        @block_opt_positional_defaults = nil
         @block_body = nil
         @safe_navigation = raw_node.respond_to?(:safe_navigation?) && raw_node.safe_navigation?
         @anonymous_block_forwarding = false
+        @forwarding_arguments = forwarding_arguments
 
         if raw_args
           args = []
@@ -29,13 +31,13 @@ module TypeProf::Core
               args << raw_arg.expression
               @splat_flags << true
             when Prism::ForwardingArgumentsNode
-              # TODO: Support forwarding arguments
+              @forwarding_arguments = :rest
             else
               args << raw_arg
               @splat_flags << false
             end
           end
-          @positional_args = args.map {|arg| arg ? AST.create_node(arg, lenv) : DummyNilNode.new(code_range, lenv) }
+          @positional_args = args.map {|arg| arg ? AST.create_node(arg, lenv) : nil }
 
           kw = @positional_args.last
           if kw.is_a?(TypeProf::Core::AST::HashNode) && kw.keywords
@@ -55,10 +57,27 @@ module TypeProf::Core
           else
             @block_pass = nil
             @block_tbl = raw_block.locals
-            # TODO: optional args, etc.
+            @block_multi_targets = {}
             @block_f_args = case raw_block.parameters
                             when Prism::BlockParametersNode
-                              raw_block.parameters.parameters.requireds.map {|n| n.is_a?(Prism::MultiTargetNode) ? nil : n.name }
+                              # `{ || ... }` (empty pipes) and `{ |; x| ... }`
+                              # (block-local-only) yield BlockParametersNode
+                              # whose inner `parameters` is nil.
+                              params = raw_block.parameters.parameters
+                              if params
+                                req = params.requireds.each_with_index.map do |n, i|
+                                  if n.is_a?(Prism::MultiTargetNode)
+                                    @block_multi_targets[i] = n
+                                    nil
+                                  else
+                                    n.name
+                                  end
+                                end
+                                opt = params.optionals.map {|n| n.name }
+                                req + opt
+                              else
+                                []
+                              end
                             when Prism::NumberedParametersNode
                               1.upto(raw_block.parameters.maximum).map { |n| :"_#{n}" }
                             when Prism::ItParametersNode
@@ -69,7 +88,13 @@ module TypeProf::Core
                               raise "not supported yet: #{ raw_block.parameters.class }"
                             end
             ncref = CRef.new(lenv.cref.cpath, :instance, @mid, lenv.cref)
-            nlenv = LocalEnv.new(@lenv.path, ncref, {}, @lenv.return_boxes)
+            nlenv = LocalEnv.new(@lenv.file_context, ncref, {}, @lenv.return_boxes)
+            @block_opt_positional_defaults = []
+            if raw_block.parameters.is_a?(Prism::BlockParametersNode) && raw_block.parameters.parameters
+              raw_block.parameters.parameters.optionals.each do |n|
+                @block_opt_positional_defaults << AST.create_node(n.value, nlenv)
+              end
+            end
             @block_body = raw_block.body ? AST.create_node(raw_block.body, nlenv) : DummyNilNode.new(code_range, lenv)
           end
         end
@@ -77,13 +102,18 @@ module TypeProf::Core
         @yield = raw_node.type == :yield_node
       end
 
-      attr_reader :recv, :mid, :mid_code_range, :yield
+      attr_reader :recv, :mid, :yield
+
+      def mid_code_range
+        @mid_code_range ||= @lenv.code_range_from_node(@mid_code_range_loc) if @mid_code_range_loc
+      end
       attr_reader :positional_args, :splat_flags, :keyword_args
-      attr_reader :block_tbl, :block_f_args, :block_body, :block_pass, :anonymous_block_forwarding
-      attr_reader :safe_navigation
+      attr_reader :block_tbl, :block_f_args, :block_opt_positional_defaults, :block_body, :block_pass, :anonymous_block_forwarding
+      attr_reader :block_multi_targets
+      attr_reader :safe_navigation, :forwarding_arguments
 
-      def subnodes = { recv:, positional_args:, keyword_args:, block_body:, block_pass: }
-      def attrs = { mid:, splat_flags:, block_tbl:, block_f_args:, yield:, safe_navigation:, anonymous_block_forwarding: }
+      def subnodes = { recv:, positional_args:, keyword_args:, block_opt_positional_defaults:, block_body:, block_pass: }
+      def attrs = { mid:, splat_flags:, block_tbl:, block_f_args:, yield:, safe_navigation:, anonymous_block_forwarding:, forwarding_arguments: }
 
       def install0(genv)
         recv = @recv ? @recv.install(genv) : @yield ? @lenv.get_var(:"*given_block") : @lenv.get_var(:"*self")
@@ -93,22 +123,36 @@ module TypeProf::Core
           recv = NilFilter.new(genv, self, recv, false).next_vtx
         end
 
-        positional_args = @positional_args.map do |arg|
-          if arg.is_a?(DummyNilNode)
-            @lenv.get_var(:"*anonymous_rest")
-          else
-            arg.install(genv)
+        if @forwarding_arguments
+          forward_a_args = (@lenv.forward_args || raise).to_actual_arguments(
+            genv,
+            @changes,
+            self,
+            include_leading_positionals: @forwarding_arguments != :rest,
+            activation_required: @forwarding_arguments == :rest,
+          )
+          # An anonymous rest cannot appear here: `bar(*, ...)` is a syntax error
+          leading_args = @positional_args.map {|arg| arg.install(genv) }
+          a_args = forward_a_args.prepend_positionals(leading_args, @splat_flags)
+          a_args = a_args.with_keywords(@keyword_args.install(genv)) if @keyword_args
+        else
+          positional_args = @positional_args.map do |arg|
+            if arg.nil?
+              @lenv.get_var(:"*anonymous_rest")
+            else
+              arg.install(genv)
+            end
           end
+          a_args = ActualArguments.new(positional_args, @splat_flags, @keyword_args ? @keyword_args.install(genv) : nil, nil)
         end
 
-        keyword_args = @keyword_args ? @keyword_args.install(genv) : nil
-
         if @block_body
           block_body = @block_body # kinda type annotationty
           block_tbl = @block_tbl || raise
+          block_body.lenv.forward_args = @lenv.forward_args
           @lenv.locals.each {|var, vtx| block_body.lenv.locals[var] = vtx }
           block_tbl.each {|var| block_body.lenv.locals[var] = Source.new(genv.nil_type) }
-          @block_body.lenv.locals[:"*self"] = @block_body.lenv.cref.get_self(genv)
+          block_body.lenv.locals[:"*self"] = block_body.lenv.cref.get_self(genv)
 
           blk_f_args = []
           if @block_f_args
@@ -117,11 +161,28 @@ module TypeProf::Core
             end
           end
 
+          if @block_opt_positional_defaults && !@block_opt_positional_defaults.empty?
+            req_count = blk_f_args.size - @block_opt_positional_defaults.size
+            @block_opt_positional_defaults.each_with_index do |expr, i|
+              @changes.add_edge(genv, expr.install(genv), blk_f_args[req_count + i])
+            end
+          end
+
+          if @block_multi_targets
+            @block_multi_targets.each do |idx, raw_multi_target|
+              param_vtx = blk_f_args[idx]
+              lefts = raw_multi_target.lefts.map do |n|
+                block_body.lenv.new_var(n.is_a?(Prism::MultiTargetNode) ? nil : n.name, self)
+              end
+              @changes.add_masgn_box(genv, param_vtx, lefts, nil, nil)
+            end
+          end
+
           @lenv.locals.each do |var, vtx|
             block_body.lenv.set_var(var, vtx)
           end
           vars = []
-          @block_body.modified_vars(@lenv.locals.keys - block_tbl, vars)
+          block_body.modified_vars(@lenv.locals.keys - block_tbl, vars)
           vars.uniq!
           vars.each do |var|
             vtx = @lenv.get_var(var)
@@ -130,25 +191,35 @@ module TypeProf::Core
             block_body.lenv.set_var(var, nvtx)
           end
 
-          @block_body.lenv.locals[:"*expected_block_ret"] = Vertex.new(self)
-          @block_body.install(genv)
-          @block_body.lenv.add_next_box(@changes.add_escape_box(genv, @block_body.ret))
+          block_body.lenv.locals[:"*expected_block_ret"] = Vertex.new(self)
+          block_body.install(genv)
+          block_body.lenv.add_next_box(@changes.add_escape_box(genv, block_body.ret))
 
           vars.each do |var|
             @changes.add_edge(genv, block_body.lenv.get_var(var), @lenv.get_var(var))
           end
 
           blk_f_ary_arg = Vertex.new(self)
-          @changes.add_masgn_box(genv, blk_f_ary_arg, blk_f_args, nil, nil) # TODO: support splat "do |a, *b, c|"
-          block = Block.new(self, blk_f_ary_arg, blk_f_args, @block_body.lenv.next_boxes)
+          # TODO: support splat "do |a, *b, c|"
+          blk_f_args.each_with_index do |f_arg, i|
+            elem_vtx = @changes.add_splat_box(genv, blk_f_ary_arg, i).ret
+            @changes.add_edge(genv, elem_vtx, f_arg)
+          end
+          block = Block.new(self, blk_f_ary_arg, blk_f_args, block_body.lenv.next_boxes)
           blk_ty = Source.new(Type::Proc.new(genv, block))
         elsif @block_pass
           blk_ty = @block_pass.install(genv)
         elsif @anonymous_block_forwarding
           blk_ty = @lenv.get_var(:"*anonymous_block")
+        elsif @forwarding_arguments
+          blk_ty = forward_a_args.block
         end
 
-        a_args = ActualArguments.new(positional_args, @splat_flags, keyword_args, blk_ty)
+        if @forwarding_arguments
+          a_args = a_args.with_block(blk_ty, omittable: !@block_body && !@block_pass && !@anonymous_block_forwarding)
+        else
+          a_args = a_args.with_block(blk_ty)
+        end
         box = @changes.add_method_call_box(genv, recv, @mid, a_args, !@recv)
 
         block_body = @block_body
@@ -180,7 +251,7 @@ module TypeProf::Core
       end
 
       def retrieve_at(pos, &blk)
-        yield self if @mid_code_range && @mid_code_range.include?(pos)
+        yield self if mid_code_range&.include?(pos)
         each_subnode do |subnode|
           next unless subnode
           subnode.retrieve_at(pos, &blk)
@@ -197,7 +268,7 @@ module TypeProf::Core
               subnode.modified_vars(tbl, vars)
             end
           else
-            subnode.each {|n| n.modified_vars(tbl, vars) }
+            subnode.each {|n| n&.modified_vars(tbl, vars) }
           end
         end
       end
@@ -207,10 +278,9 @@ module TypeProf::Core
       def initialize(raw_node, lenv)
         recv = raw_node.receiver ? AST.create_node(raw_node.receiver, lenv) : nil
         mid = raw_node.name
-        mid_code_range = TypeProf::CodeRange.from_node(raw_node.message_loc) if raw_node.message_loc
         raw_args = raw_node.arguments
         raw_block = raw_node.block
-        super(raw_node, recv, mid, mid_code_range, raw_args, nil, raw_block, lenv)
+        super(raw_node, recv, mid, raw_node.message_loc, raw_args, nil, raw_block, lenv)
       end
 
       def narrowings
@@ -231,6 +301,20 @@ module TypeProf::Core
             else
               super
             end
+          when :nil?
+            if @recv.is_a?(LocalVariableReadNode)
+              [
+                Narrowing.new({ @recv.var => Narrowing::NilConstraint.new(true) }),
+                Narrowing.new({ @recv.var => Narrowing::NilConstraint.new(false) })
+              ]
+            elsif @recv.is_a?(InstanceVariableReadNode)
+              [
+                Narrowing.new({ @recv.var => Narrowing::NilConstraint.new(true) }),
+                Narrowing.new({ @recv.var => Narrowing::NilConstraint.new(false) })
+              ]
+            else
+              super
+            end
           when :!
             then_narrowing, else_narrowing = @recv.narrowings
             [else_narrowing, then_narrowing]
@@ -251,9 +335,9 @@ module TypeProf::Core
 
     class ForwardingSuperNode < CallBaseNode
       def initialize(raw_node,  lenv)
-        raw_args = nil # TODO: forward args properly
+        raw_args = nil
         raw_block = raw_node.block
-        super(raw_node, nil, :"*super", nil, raw_args, nil, raw_block, lenv)
+        super(raw_node, nil, :"*super", nil, raw_args, nil, raw_block, lenv, forwarding_arguments: :all)
       end
     end
 
@@ -267,9 +351,8 @@ module TypeProf::Core
     class OperatorNode < CallBaseNode
       def initialize(raw_node, recv, lenv)
         mid = raw_node.binary_operator
-        mid_code_range = TypeProf::CodeRange.from_node(raw_node.binary_operator_loc)
         last_arg = AST.create_node(raw_node.value, lenv)
-        super(raw_node, recv, mid, mid_code_range, nil, last_arg, nil, lenv)
+        super(raw_node, recv, mid, raw_node.binary_operator_loc, nil, last_arg, nil, lenv)
       end
     end
 
@@ -300,8 +383,7 @@ module TypeProf::Core
       def initialize(raw_node, lenv)
         recv = AST.create_node(raw_node.receiver, lenv)
         mid = raw_node.read_name
-        mid_code_range = TypeProf::CodeRange.from_node(raw_node.message_loc)
-        super(raw_node, recv, mid, mid_code_range, nil, nil, nil, lenv)
+        super(raw_node, recv, mid, raw_node.message_loc, nil, nil, nil, lenv)
       end
     end
 
@@ -309,9 +391,8 @@ module TypeProf::Core
       def initialize(raw_node, rhs, lenv)
         recv = AST.create_node(raw_node.receiver, lenv)
         mid = raw_node.is_a?(Prism::CallTargetNode) ? raw_node.name : raw_node.write_name
-        mid_code_range = TypeProf::CodeRange.from_node(raw_node.message_loc)
         @rhs = rhs
-        super(raw_node, recv, mid, mid_code_range, nil, rhs, nil, lenv)
+        super(raw_node, recv, mid, raw_node.message_loc, nil, rhs, nil, lenv)
       end
 
       attr_reader :rhs