rigortype 0.1.5 → 0.1.7

data/lib/rigor/inference/scope_indexer.rb

@@ -177,8 +177,10 @@ module Rigor
         return if def_node.body.nil? || qualified_prefix.empty?
 
         class_name = qualified_prefix.join("::")
+        singleton = def_node.receiver.is_a?(Prism::SelfNode) ||
+                    def_receiver_targets_lexical_self?(def_node.receiver, qualified_prefix)
         self_type =
-          if def_node.receiver.is_a?(Prism::SelfNode)
+          if singleton
             Type::Combinator.singleton_of(class_name)
           else
             Type::Combinator.nominal_of(class_name)
@@ -341,11 +343,26 @@ module Rigor
         unless qualified_prefix.empty?
           body_scope = body_scope.with_self_type(Type::Combinator.singleton_of(qualified_prefix.join("::")))
         end
-        rvalue_type = body_scope.type_of(node.value)
+        rvalue_type = meta_new_constant_type(node, full) || body_scope.type_of(node.value)
         existing = accumulator[full]
         accumulator[full] = existing ? Type::Combinator.union(existing, rvalue_type) : rvalue_type
       end
 
+      # Survey item (e): when the rvalue is a recognised
+      # `Module.new do ... end` / `Class.new do ... end` /
+      # `Struct.new(*sym) do ... end` / `Data.define(*sym) do
+      # ... end` form, type the named constant as
+      # `Singleton[<full>]` so the discovered-method table
+      # registered under `full` becomes reachable through
+      # singleton-side dispatch (`Const.[]=` etc.). Returns nil
+      # for non-meta-new rvalues so the caller falls back to the
+      # default `body_scope.type_of(node.value)` shape.
+      def meta_new_constant_type(node, full)
+        return nil unless meta_new_block_body(node)
+
+        Type::Combinator.singleton_of(full)
+      end
+
       # Slice 7 phase 12 — in-source method discovery pre-pass.
       # Walks every class/module body and records the methods
       # introduced via `Prism::DefNode` (instance + singleton)
@@ -371,9 +388,12 @@ module Rigor
             return
           end
         when Prism::SingletonClassNode
-          if node.expression.is_a?(Prism::SelfNode) && node.body
-            walk_methods(node.body, qualified_prefix, true, accumulator)
-            return
+          if node.body
+            singleton_prefix = singleton_class_prefix(node, qualified_prefix)
+            if singleton_prefix
+              walk_methods(node.body, singleton_prefix, true, accumulator)
+              return
+            end
           end
         when Prism::ConstantWriteNode
           if meta_new_block_body(node)
@@ -395,21 +415,51 @@ module Rigor
           walk_methods(child, qualified_prefix, in_singleton_class, accumulator)
         end
       end
+
+      # Resolves a `class << X` body's qualified prefix.
+      #   - `class << self` keeps `qualified_prefix` (the enclosing class).
+      #   - `class << Foo` inside `class Foo` collapses to the same prefix
+      #     (semantically `class << self`).
+      #   - `class << Foo` not nested in `class Foo` returns `[Foo]`
+      #     so methods defined inside register on Foo's singleton.
+      #   - Any other expression (variable, method call) returns nil
+      #     so the walker falls through and skips the body.
+      def singleton_class_prefix(node, qualified_prefix)
+        case node.expression
+        when Prism::SelfNode
+          qualified_prefix
+        when Prism::ConstantReadNode, Prism::ConstantPathNode
+          rendered = qualified_name_for(node.expression)
+          return nil unless rendered
+
+          if !qualified_prefix.empty? && qualified_prefix.last == rendered
+            qualified_prefix
+          else
+            rendered.split("::")
+          end
+        end
+      end
       # rubocop:enable Metrics/CyclomaticComplexity, Metrics/MethodLength
 
       # v0.1.2 — when a `Const = Data.define(*sym) do ... end`
       # / `Const = Struct.new(*sym) do ... end` constant write
       # carries a block, the block body holds method overrides
-      # whose canonical class is `Const`. Returns the block body
-      # node (a `Prism::StatementsNode`) when the rvalue
-      # matches; nil otherwise. Used by `walk_methods` /
-      # `walk_def_nodes` to push `Const` onto the qualified
-      # prefix before recursing.
+      # whose canonical class is `Const`. Survey item (e) extended
+      # the recognition to `Const = Module.new do ... end` and
+      # `Const = Class.new(?super) do ... end` — the
+      # ADR-16 Tier A "block-as-method" idiom at constant-write
+      # position. Returns the block body node (a
+      # `Prism::StatementsNode`) when the rvalue matches; nil
+      # otherwise. Used by `walk_methods` / `walk_def_nodes` to
+      # push `Const` onto the qualified prefix before recursing.
       def meta_new_block_body(node)
         return nil unless node.is_a?(Prism::ConstantWriteNode)
 
         rvalue = node.value
-        return nil unless data_define_call?(rvalue) || struct_new_call?(rvalue)
+        return nil unless data_define_call?(rvalue) ||
+                          struct_new_call?(rvalue) ||
+                          module_new_call?(rvalue) ||
+                          class_new_call?(rvalue)
 
         rvalue.block&.body
       end
@@ -418,11 +468,50 @@ module Rigor
         return if qualified_prefix.empty?
 
         class_name = qualified_prefix.join("::")
-        kind = def_node.receiver.is_a?(Prism::SelfNode) || in_singleton_class ? :singleton : :instance
+        singleton = def_singleton?(def_node, qualified_prefix, in_singleton_class)
+        kind = singleton ? :singleton : :instance
         accumulator[class_name] ||= {}
         accumulator[class_name][def_node.name] = kind
       end
 
+      # `def Foo.bar` inside `module Foo` (or `def Meta.init` inside
+      # `module Meta`) is semantically equivalent to `def self.bar`:
+      # at the def-site, the runtime value of the constant `Foo` is
+      # the module itself (== `self`). Recognise the form so the
+      # method registers as singleton on the enclosing class.
+      #
+      # The cross-class form `def Bar.baz` inside `module Foo` —
+      # where the receiver names a constant other than the
+      # enclosing class — is not supported at this slice; falls
+      # through to `:instance` (current behaviour) rather than
+      # silently re-routing the registration.
+      def def_singleton?(def_node, qualified_prefix, in_singleton_class)
+        return true if def_node.receiver.is_a?(Prism::SelfNode) || in_singleton_class
+
+        def_receiver_targets_lexical_self?(def_node.receiver, qualified_prefix)
+      end
+
+      # Only `Prism::ConstantReadNode` is observed in real Ruby —
+      # Prism mis-parses `def C::P.method` as `def C.P` (Ruby itself
+      # rejects the form as a SyntaxError). The ConstantPathNode
+      # branch stays defensive in case Prism's grammar widens.
+      def def_receiver_targets_lexical_self?(receiver, qualified_prefix)
+        return false if qualified_prefix.empty?
+
+        case receiver
+        when Prism::ConstantReadNode
+          receiver.name.to_s == qualified_prefix.last
+        when Prism::ConstantPathNode
+          rendered = render_constant_path(receiver)
+          return false unless rendered
+
+          path = rendered.split("::")
+          qualified_prefix.last(path.length) == path
+        else
+          false
+        end
+      end
+
       # v0.0.2 #5 — instance-side def-node recording. Walks
       # class bodies the same way as `build_discovered_methods`
       # but records the actual `Prism::DefNode` for each
@@ -452,9 +541,12 @@ module Rigor
             return
           end
         when Prism::SingletonClassNode
-          if node.expression.is_a?(Prism::SelfNode) && node.body
-            walk_def_nodes(node.body, qualified_prefix, true, accumulator)
-            return
+          if node.body
+            singleton_prefix = singleton_class_prefix(node, qualified_prefix)
+            if singleton_prefix
+              walk_def_nodes(node.body, singleton_prefix, true, accumulator)
+              return
+            end
           end
         when Prism::ConstantWriteNode
           if meta_new_block_body(node)
@@ -481,7 +573,7 @@ module Rigor
       TOP_LEVEL_DEF_KEY = "<toplevel>"
 
       def record_def_node(def_node, qualified_prefix, in_singleton_class, accumulator)
-        return if def_node.receiver.is_a?(Prism::SelfNode) || in_singleton_class
+        return if def_singleton?(def_node, qualified_prefix, in_singleton_class)
 
         class_name = qualified_prefix.empty? ? TOP_LEVEL_DEF_KEY : qualified_prefix.join("::")
         accumulator[class_name] ||= {}
@@ -530,9 +622,12 @@ module Rigor
             return current_visibility
           end
         when Prism::SingletonClassNode
-          if node.expression.is_a?(Prism::SelfNode) && node.body
-            walk_method_visibilities(node.body, qualified_prefix, true, :public, accumulator)
-            return current_visibility
+          if node.body
+            singleton_prefix = singleton_class_prefix(node, qualified_prefix)
+            if singleton_prefix
+              walk_method_visibilities(node.body, singleton_prefix, true, :public, accumulator)
+              return current_visibility
+            end
           end
         when Prism::ConstantWriteNode
           if meta_new_block_body(node)
@@ -703,6 +798,76 @@ module Rigor
         node.unescaped&.to_sym
       end
 
+      # Walks every file in `paths` (each path is parsed once with
+      # `Prism.parse_file`) and returns the unioned project-wide
+      # `discovered_classes` Hash: `{qualified_name => Singleton[…]}`.
+      # Used by `Analysis::Runner` to seed each file's
+      # `default_scope.discovered_classes` so that lexical
+      # constant lookup in one file resolves a `class Foo`
+      # declared in a sibling file. Per-file collisions are
+      # last-write-wins (matches the existing in-file merge
+      # semantics). Parse failures fail-soft to an empty
+      # contribution. The `buffer` argument, when present,
+      # redirects reads for the bound logical path to the
+      # buffer's physical path so editor-mode pre-passes see
+      # the in-flight bytes.
+      #
+      # **Modules are intentionally excluded** from the
+      # project-wide seed: a `module M; module_function; def x; end; end`
+      # body, when surfaced as `singleton(M)` to the dispatcher,
+      # falls through to `Kernel#x` (or any Module ancestor
+      # method) when the project's per-file
+      # `discovered_methods` doesn't know `M.x` — leading to
+      # surprising types like `Kernel.select → Array[String]`.
+      # Until cross-file `discovered_methods` follows the same
+      # project-wide seed, registering modules here would
+      # introduce regressions in modules-with-module_function
+      # idioms that previously resolved to `Dynamic[Top]`.
+      # Class declarations are safe because per-file
+      # `discovered_methods` already tracks `def self.x` /
+      # `def x` instance and singleton methods consistently.
+      #
+      # @param paths  [Array<String>] project file paths.
+      # @param buffer [Rigor::Analysis::BufferBinding, nil]
+      # @return [Hash{String => Rigor::Type::Singleton}]
+      def discovered_classes_for_paths(paths, buffer: nil)
+        accumulator = {}
+        paths.each do |path|
+          physical = buffer ? buffer.resolve(path) : path
+          source = File.read(physical)
+          root = Prism.parse(source, filepath: path).value
+          collect_class_decls(root, [], accumulator)
+        rescue StandardError
+          # Skip files that fail to parse or read; the per-file
+          # analyzer surfaces the parse error separately.
+          next
+        end
+        accumulator.freeze
+      end
+
+      # Class-only variant of `record_declarations` — descends
+      # into nested module bodies (so `module Foo; class Bar`
+      # registers `Foo::Bar`) but never registers the module
+      # itself in `accumulator`.
+      def collect_class_decls(node, qualified_prefix, accumulator)
+        return unless node.is_a?(Prism::Node)
+
+        case node
+        when Prism::ClassNode
+          name = qualified_name_for(node.constant_path)
+          if name
+            full = (qualified_prefix + [name]).join("::")
+            accumulator[full] = Type::Combinator.singleton_of(full)
+            return collect_class_decls(node.body, qualified_prefix + [name], accumulator) if node.body
+          end
+        when Prism::ModuleNode
+          name = qualified_name_for(node.constant_path)
+          return collect_class_decls(node.body, qualified_prefix + [name], accumulator) if name && node.body
+        end
+
+        node.compact_child_nodes.each { |child| collect_class_decls(child, qualified_prefix, accumulator) }
+      end
+
       # Walks the program once for `Prism::ModuleNode` and
       # `Prism::ClassNode`, recording the `Singleton[<qualified>]`
       # type for the outermost `constant_path` node of each
@@ -802,6 +967,31 @@ module Rigor
         positional.all?(Prism::SymbolNode)
       end
 
+      # Recognises `Module.new` and `Module.new(&block)` /
+      # `Module.new do ... end` at constant-write rvalue
+      # position. The block body is the anonymous module's
+      # `module_eval` body; defs inside it bind methods on the
+      # named constant (`Const = Module.new do ...; def foo; ...; end; end`).
+      # Arguments are NOT inspected because `Module.new` accepts
+      # no positionals — Ruby raises ArgumentError if any are
+      # passed — so a malformed call falls through the walker
+      # without affecting analysis.
+      def module_new_call?(node)
+        meta_call_with_name?(node, :Module, :new)
+      end
+
+      # Recognises `Class.new`, `Class.new(super_class)`, and the
+      # block form `Class.new { ... }`. Like `module_new_call?`,
+      # the block body is walked as the anonymous class's body.
+      # The optional `super_class` positional is accepted but does
+      # NOT route through `ancestor` discovery in this slice — the
+      # synthesised class still answers method lookups via its
+      # own body's defs, mirroring how `Struct.new` / `Data.define`
+      # are handled.
+      def class_new_call?(node)
+        meta_call_with_name?(node, :Class, :new)
+      end
+
       def meta_call_with_name?(node, receiver_name, method_name)
         return false unless node.is_a?(Prism::CallNode)
         return false unless node.name == method_name

data/lib/rigor/inference/statement_evaluator.rb

@@ -497,13 +497,25 @@ module Rigor
       def eval_begin(node)
         primary_type, primary_scope = eval_begin_primary(node)
         rescue_chain = collect_rescue_chain_results(node.rescue_clause, scope)
-
-        if rescue_chain.empty?
+        # Rescue arms whose body unconditionally exits (`return`,
+        # `next`, `break`, `raise`, `throw`, `exit`, `abort`,
+        # `fail`) contribute neither a type fragment NOR a scope
+        # to the post-begin flow — control left the `begin` via
+        # that arm. Mirrors the `eval_if` / `eval_unless` /
+        # `eval_and_or` early-return narrowing. Without this
+        # filter, a `rescue ... return` on a local bound only in
+        # the primary body nil-injects that local across the
+        # join, defeating the rescue arm's whole point of guaranteeing
+        # the primary local is in scope for downstream statements.
+        live_rescues = rescue_chain.reject { |_pair, arm_node| branch_unconditionally_exits?(arm_node.statements) }
+                                   .map(&:first)
+
+        if live_rescues.empty?
           exit_type = primary_type
           exit_scope = primary_scope
         else
-          exit_type = Type::Combinator.union(primary_type, *rescue_chain.map(&:first))
-          exit_scope = reduce_scopes_with_nil_injection([primary_scope, *rescue_chain.map(&:last)])
+          exit_type = Type::Combinator.union(primary_type, *live_rescues.map(&:first))
+          exit_scope = reduce_scopes_with_nil_injection([primary_scope, *live_rescues.map(&:last)])
         end
 
         if node.ensure_clause
@@ -540,7 +552,7 @@ module Rigor
         current = rescue_node
         while current
           rescue_scope = bind_rescue_reference(current, entry_scope)
-          results << eval_branch_or_nil(current.statements, rescue_scope)
+          results << [eval_branch_or_nil(current.statements, rescue_scope), current]
           current = current.subsequent
         end
         results
@@ -696,10 +708,35 @@ module Rigor
       # edge-aware: `a && b` can only produce the falsey fragment of
       # `a` when the RHS is skipped, while `a || b` can only produce
       # the truthy fragment of `a` when the RHS is skipped.
+      #
+      # When the RHS unconditionally exits (`raise` / `return` /
+      # `throw` / `exit` / `abort` / `fail` / `next` / `break`), the
+      # post-OR / post-AND scope is the LHS-skipped edge alone:
+      # `a or raise` only survives when `a` was truthy, so subsequent
+      # statements observe `a` narrowed to its truthy fragment; the
+      # symmetric `a and raise` survives only when `a` was falsey.
+      # Same shape as the `eval_if` / `eval_unless` early-return
+      # narrowing.
       def eval_and_or(node)
         left_type, left_scope = sub_eval(node.left, scope)
         truthy_left, falsey_left = Narrowing.predicate_scopes(node.left, left_scope)
         rhs_entry = node.is_a?(Prism::AndNode) ? truthy_left : falsey_left
+        if branch_unconditionally_exits?(node.right)
+          # Walk the RHS for side-effects (on_enter callbacks,
+          # diagnostic dispatch on the raise / return expression
+          # itself) but discard its scope: control never reaches
+          # any statement after `a or raise` via that edge.
+          sub_eval(node.right, rhs_entry)
+          surviving_type =
+            if node.is_a?(Prism::AndNode)
+              Narrowing.narrow_falsey(left_type)
+            else
+              Narrowing.narrow_truthy(left_type)
+            end
+          surviving_scope = node.is_a?(Prism::AndNode) ? falsey_left : truthy_left
+          return [surviving_type, surviving_scope]
+        end
+
         right_type, right_scope = sub_eval(node.right, rhs_entry)
         skipped_type =
           if node.is_a?(Prism::AndNode)
@@ -760,6 +797,19 @@ module Rigor
       # name as a Symbol, so the produced type is `Constant[:name]`.
       def eval_def(node)
         body_scope = build_method_entry_scope(node)
+        # Parameter default value expressions (e.g. `self.x` in
+        # `def copy(x: self.x)`) execute when the method is
+        # *invoked*, not when the `def` is read; their `self` is
+        # the instance receiver, not the surrounding class body.
+        # Walk the parameters subtree under `body_scope` so the
+        # scope-index records the instance `self_type` for every
+        # node inside parameter defaults. `propagate` would
+        # otherwise drop them to the outer class-body scope (where
+        # `self_type` is `singleton(C)`), making `self.foo` look
+        # like a singleton-side call. Observed surfacing 915 false
+        # positives in `prism-1.9.0`'s auto-generated `copy`
+        # methods alone.
+        sub_eval(node.parameters, body_scope, class_context: @class_context) if node.parameters
         sub_eval(node.body, body_scope, class_context: @class_context) if node.body
         [Type::Combinator.constant_of(node.name), scope]
       end
@@ -783,6 +833,21 @@ module Rigor
       def eval_call(node)
         call_type = scope.type_of(node, tracer: tracer)
         evaluate_block_if_present(node)
+        # `ruby2_keywords def foo(...)` (and similar wrappers like
+        # `private def`, `public def`, `module_function def`) parse
+        # the def as the call's positional argument; the
+        # ExpressionTyper#type_of_def handler types it as
+        # `Constant[:foo]` without walking the body. Without
+        # explicitly evaluating the argument-position def, the body's
+        # scope-index entries inherit the outer class-body
+        # `self_type = singleton(C)` from `ScopeIndexer.propagate`,
+        # so `self.helper` inside reports `undefined method 'helper'
+        # for singleton(C)`. Walking each argument-position def under
+        # the current evaluator (not a sub_eval — the def's effects
+        # do not bind into the surrounding scope) populates the
+        # scope index with the correct instance / singleton
+        # `self_type` for the def's body.
+        evaluate_def_arguments(node)
         post_scope = record_closure_escape_if_any(node)
         post_scope = apply_rbs_extended_assertions(node, post_scope)
         post_scope = apply_plugin_assertions(node, post_scope)
@@ -790,6 +855,15 @@ module Rigor
         [call_type, post_scope]
       end
 
+      def evaluate_def_arguments(call_node)
+        args = call_node.arguments
+        return unless args.respond_to?(:arguments)
+
+        args.arguments.each do |arg|
+          eval_def(arg) if arg.is_a?(Prism::DefNode)
+        end
+      end
+
       # v0.0.3 — recognises a small catalogue of RSpec
       # matcher patterns as assert-shaped narrows on the
       # local passed to `expect(...)`. The pattern is
@@ -1069,7 +1143,16 @@ module Rigor
       # narrowing logic via `Narrowing.narrow_for_fact` so the
       # predicate / assert / plugin paths all converge on the
       # same hierarchy-aware narrowing rules.
+      #
+      # v0.1.8 Pillar 2 Slice 1 added the `:local` target_kind
+      # branch so plugins recognising bespoke call shapes
+      # (`expect(x).to be_a(T)`) can directly narrow a named
+      # local in the surrounding scope, bypassing the
+      # parameter-name lookup that requires an authoritative RBS
+      # sig on the called method (which RSpec matchers lack).
       def apply_post_return_fact(fact, call_node, current_scope, method_def)
+        return apply_local_post_return_fact(fact, current_scope) if fact.target_kind == :local
+
         target_node = fact_target_node(fact, call_node, method_def)
         return apply_self_post_return_fact(fact, target_node, current_scope) if fact.target_kind == :self
         return current_scope unless target_node.is_a?(Prism::LocalVariableReadNode)
@@ -1082,6 +1165,21 @@ module Rigor
         current_scope.with_local(local_name, narrowed)
       end
 
+      # v0.1.8 Pillar 2 Slice 1 — narrows the named local directly
+      # without consulting the call node's argument list. The fact's
+      # `target_name` is the local-variable name as written in
+      # source. Silently no-ops when the local is unbound in the
+      # current scope (the plugin's named local may have already
+      # gone out of scope when the contribution fires).
+      def apply_local_post_return_fact(fact, current_scope)
+        local_name = fact.target_name
+        current_type = current_scope.local(local_name)
+        return current_scope if current_type.nil?
+
+        narrowed = Narrowing.narrow_for_fact(current_type, fact, current_scope.environment)
+        current_scope.with_local(local_name, narrowed)
+      end
+
       # v0.1.1 Track 1 slice 3 — `assert self is T` post-return
       # narrowing for the four supported receiver shapes (mirrors
       # `Narrowing#apply_self_fact`).
@@ -1399,7 +1497,37 @@ module Rigor
       end
 
       def singleton_def?(def_node)
-        def_node.receiver.is_a?(Prism::SelfNode) || current_frame_singleton?
+        return true if def_node.receiver.is_a?(Prism::SelfNode) || current_frame_singleton?
+
+        def_receiver_targets_lexical_self?(def_node.receiver)
+      end
+
+      # `def Foo.bar` inside `module Foo` (or `def Meta.init` inside
+      # `module Meta`) — explicit-receiver def that semantically
+      # equals `def self.bar` because the receiver constant
+      # resolves to `self` at the def-site. Matched against the
+      # current class context's tail to cover both the
+      # `def OpenURI.x` form (single segment) and the
+      # `def OpenURI::Meta.x` form (qualified path). Cross-class
+      # receivers (`def Bar.baz` inside `module Foo` where the
+      # receiver names a different constant) are not promoted to
+      # singleton at this slice.
+      def def_receiver_targets_lexical_self?(receiver)
+        return false if @class_context.empty?
+
+        prefix = @class_context.map(&:name)
+        case receiver
+        when Prism::ConstantReadNode
+          receiver.name.to_s == prefix.last
+        when Prism::ConstantPathNode
+          rendered = render_constant_path(receiver)
+          return false unless rendered
+
+          path = rendered.split("::")
+          prefix.last(path.length) == path
+        else
+          false
+        end
       end
 
       # Slice A-engine. Inside a class body `class Foo; ...; end`,
@@ -1452,12 +1580,45 @@ module Rigor
       end
 
       def singleton_context_for(node)
-        return @class_context unless node.expression.is_a?(Prism::SelfNode)
-        return @class_context if @class_context.empty?
+        case node.expression
+        when Prism::SelfNode
+          return @class_context if @class_context.empty?
+
+          outer = @class_context[0..-2]
+          last = @class_context.last
+          outer + [ClassFrame.new(name: last.name, singleton: true)]
+        when Prism::ConstantReadNode, Prism::ConstantPathNode
+          target = singleton_constant_target(node.expression)
+          return @class_context unless target
+
+          # `class << Foo` inside `class Foo` (the canonical
+          # pattern in Ruby's own time.rb) is semantically
+          # `class << self` — replace the enclosing frame with a
+          # singleton frame for the same name so method
+          # registration and `self_type` lookup land on Foo.
+          # When the target names a different constant (rare
+          # cross-class form), append a fresh singleton frame
+          # tagged with the target FQN; the bodies are scoped to
+          # that target rather than to the lexical enclosing
+          # class.
+          if !@class_context.empty? && @class_context.last.name == target
+            outer = @class_context[0..-2]
+            outer + [ClassFrame.new(name: target, singleton: true)]
+          else
+            [ClassFrame.new(name: target, singleton: true)]
+          end
+        else
+          @class_context
+        end
+      end
 
-        outer = @class_context[0..-2]
-        last = @class_context.last
-        outer + [ClassFrame.new(name: last.name, singleton: true)]
+      def singleton_constant_target(expression)
+        case expression
+        when Prism::ConstantReadNode
+          expression.name.to_s
+        when Prism::ConstantPathNode
+          render_constant_path(expression)
+        end
       end
 
       # The qualified name of the immediately-enclosing class (joining