typeprof 0.31.1 → 0.32.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 937e0870f11951c34a3c7903f0c6e02b2ba0b557d327999a8ce807e195409088
-  data.tar.gz: ab8eca2e1cbb24729bbc0274bce7ed3ddd59917accd81285069ebc0086fe0208
+  metadata.gz: 93757a88e1532a3e0d9faf5b3eb8690b7a61ced6027e28d49dfce43234557015
+  data.tar.gz: 8e41f82794582ea68445e0972a6cab30982fcac483a50c5032811e3a2fcb9a60
 SHA512:
-  metadata.gz: 40b2629987ea3feed461c74c279cabb25ad462c0e0118d3d451c12387de4cdbab39b1dd1301ee86ceb6f6f5bbb25b4c5425a72749a11eabe2485a35ea463e5a3
-  data.tar.gz: c8704511e6507f9e50df4b626fb9b481e945954688df4d6c26ecd233b530eb4f1e2e038589c2538f209e9f6cec15c26401d854f48d8ea346325507f29246a475
+  metadata.gz: f1020867309edd82548dd3bcfc84d22007324af9c6acd0e6c82bb002678dfef3bb7acc695f6cc19d243d24084871a3a7a0695b1d7f069122ab28a221fca06469
+  data.tar.gz: 17cf614ed4edd5e75c772750fe844db59d65dcf7dc129b22269e4a840dbf4a45c1136f7ed74ac780d37d183f08de24e2ca447cd1804ea39bc39e7876f393ede8

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|
@@ -129,11 +130,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 +211,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 +282,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,7 +1,7 @@
 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, raw_args, last_arg, raw_block, lenv, forwarding_arguments: false)
         super(raw_node, lenv)
 
         @recv = recv
@@ -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 = true
             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,20 @@ 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 }
+                              params = raw_block.parameters.parameters
+                              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
                             when Prism::NumberedParametersNode
                               1.upto(raw_block.parameters.maximum).map { |n| :"_#{n}" }
                             when Prism::ItParametersNode
@@ -69,7 +81,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.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
@@ -79,11 +97,12 @@ module TypeProf::Core
 
       attr_reader :recv, :mid, :mid_code_range, :yield
       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 +112,30 @@ 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)
+          positional_args = forward_a_args.positionals
+          splat_flags = forward_a_args.splat_flags
+          keyword_args = forward_a_args.keywords
+        else
+          positional_args = @positional_args.map do |arg|
+            if arg.nil?
+              @lenv.get_var(:"*anonymous_rest")
+            else
+              arg.install(genv)
+            end
           end
+          splat_flags = @splat_flags
+          keyword_args = @keyword_args ? @keyword_args.install(genv) : 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 +144,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 +174,31 @@ 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)
+        a_args = ActualArguments.new(positional_args, splat_flags, keyword_args, blk_ty)
         box = @changes.add_method_call_box(genv, recv, @mid, a_args, !@recv)
 
         block_body = @block_body
@@ -197,7 +247,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,7 +257,7 @@ 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
+        mid_code_range = lenv.code_range_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)
@@ -231,6 +281,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 +315,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: true)
       end
     end
 
@@ -267,7 +331,7 @@ 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)
+        mid_code_range = lenv.code_range_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)
       end
@@ -300,7 +364,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)
+        mid_code_range = lenv.code_range_from_node(raw_node.message_loc)
         super(raw_node, recv, mid, mid_code_range, nil, nil, nil, lenv)
       end
     end
@@ -309,7 +373,7 @@ 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)
+        mid_code_range = lenv.code_range_from_node(raw_node.message_loc)
         @rhs = rhs
         super(raw_node, recv, mid, mid_code_range, nil, rhs, nil, lenv)
       end

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

@@ -8,7 +8,7 @@ module TypeProf::Core
           @cbase = nil
           @toplevel = false
           @cname = raw_node.name
-          @cname_code_range = TypeProf::CodeRange.from_node(raw_node.location)
+          @cname_code_range = lenv.code_range_from_node(raw_node.location)
         when :constant_path_node, :constant_path_target_node
           if raw_node.parent
             @cbase = AST.create_node(raw_node.parent, lenv)
@@ -18,7 +18,7 @@ module TypeProf::Core
             @toplevel = true
           end
           @cname = raw_node.name
-          @cname_code_range = TypeProf::CodeRange.from_node(raw_node.name_loc)
+          @cname_code_range = lenv.code_range_from_node(raw_node.name_loc)
         else
           raise raw_node.type.to_s
         end
@@ -57,17 +57,17 @@ module TypeProf::Core
           # C = expr
           @cpath = nil
           @static_cpath = lenv.cref.cpath + [raw_node.name]
-          @cname_code_range = TypeProf::CodeRange.from_node(raw_node.respond_to?(:name_loc) ? raw_node.name_loc : raw_node)
+          @cname_code_range = lenv.code_range_from_node(raw_node.respond_to?(:name_loc) ? raw_node.name_loc : raw_node)
         when :constant_path_write_node, :constant_path_operator_write_node, :constant_path_or_write_node, :constant_path_and_write_node
           # expr::C = expr
           @cpath = AST.create_node(raw_node.target, lenv)
           @static_cpath = AST.parse_cpath(raw_node.target, lenv.cref)
-          @cname_code_range = TypeProf::CodeRange.from_node(raw_node.target)
+          @cname_code_range = lenv.code_range_from_node(raw_node.target)
         when :constant_path_target_node
           # expr::C, * = ary
           @cpath = ConstantReadNode.new(raw_node, lenv)
           @static_cpath = AST.parse_cpath(raw_node, lenv.cref)
-          @cname_code_range = TypeProf::CodeRange.from_node(raw_node)
+          @cname_code_range = lenv.code_range_from_node(raw_node)
         else
           raise
         end
@@ -83,9 +83,10 @@ module TypeProf::Core
         @cpath.define(genv) if @cpath
         @rhs.define(genv) if @rhs
         if @static_cpath
-          mod = genv.resolve_const(@static_cpath)
-          mod.add_def(self)
-          mod
+          cdef = genv.resolve_const(@static_cpath)
+          cdef.on_const_added(genv, @static_cpath)
+          cdef.add_def(self)
+          cdef
         else
           nil
         end
@@ -102,7 +103,9 @@ module TypeProf::Core
 
       def undefine0(genv)
         if @static_cpath
-          genv.resolve_const(@static_cpath).remove_def(self)
+          cdef = genv.resolve_const(@static_cpath)
+          cdef.remove_def(self)
+          cdef.on_const_removed(genv, @static_cpath)
         end
         @rhs.undefine(genv) if @rhs
         @cpath.undefine(genv) if @cpath