rigortype 0.1.3 → 0.1.5

data/lib/rigor/inference/method_dispatcher.rb

@@ -12,6 +12,7 @@ require_relative "method_dispatcher/iterator_dispatch"
 require_relative "method_dispatcher/block_folding"
 require_relative "method_dispatcher/file_folding"
 require_relative "method_dispatcher/kernel_dispatch"
+require_relative "method_dispatcher/method_folding"
 
 module Rigor
   module Inference
@@ -61,11 +62,18 @@ module Rigor
       # @param environment [Rigor::Environment, nil] required for
       #   RBS-backed dispatch; when nil only constant folding can fire.
       # @return [Rigor::Type, nil] inferred result type, or `nil` for "no rule".
-      def dispatch(receiver_type:, method_name:, arg_types:, # rubocop:disable Metrics/ParameterLists
+      def dispatch(receiver_type:, method_name:, arg_types:,
                    block_type: nil, environment: nil,
                    call_node: nil, scope: nil)
         return nil if receiver_type.nil?
 
+        bound_method_result = MethodFolding.try_backward(
+          receiver: receiver_type, method_name: method_name, args: arg_types,
+          block_type: block_type, environment: environment,
+          call_node: call_node, scope: scope
+        )
+        return bound_method_result if bound_method_result
+
         precise = dispatch_precise_tiers(receiver_type, method_name, arg_types, block_type)
         return precise if precise
 
@@ -84,7 +92,24 @@ module Rigor
           receiver: receiver_type, method_name: method_name, args: arg_types,
           environment: environment, block_type: block_type
         )
-        return rbs_result if rbs_result
+        if rbs_result
+          record_boundary_cross_if_applicable(receiver_type, method_name, rbs_result, environment)
+          return rbs_result
+        end
+
+        # ADR-16 Tier B / Tier C — synthetic-method tier. Sits
+        # BELOW RBS dispatch (per WD13: user-authored RBS overrides
+        # substrate synthesis) and ABOVE the dependency-source
+        # inference tier so a plugin's declared emit table beats
+        # the generic gem-source fallback for the same class. Slice
+        # 6a-TierB (origin_module dispatch) lands precise return
+        # types for Tier B emissions; Tier C emissions still return
+        # `Dynamic[T]` at this tier (slice 6b is the Tier C
+        # promotion via ADR-13's resolver chain).
+        synthetic_result = try_synthetic_method(
+          receiver_type, method_name, arg_types, block_type, environment
+        )
+        return synthetic_result if synthetic_result
 
         # ADR-10 slice 2b-ii — dependency-source inference tier.
         # Sits BELOW RBS dispatch (RBS / RBS::Inline / generated
@@ -98,6 +123,21 @@ module Rigor
         dep_source_result = try_dependency_source(receiver_type, method_name, environment)
         return dep_source_result if dep_source_result
 
+        # v0.1.3 — discovered-method dispatch tier. When the
+        # receiver class has no RBS BUT scope_indexer recorded
+        # `def method_name` for that class (or singleton), the
+        # call dispatches to `Dynamic[top]` rather than falling
+        # through to the user-class fallback. Sits below RBS /
+        # dependency-source so authoritative signatures still win.
+        # The scope-indexer-built table records every project-side
+        # `def`, `define_method`, and `alias_method`; the
+        # `discovered_method?` consult here closes the
+        # fail-soft-event hot spot on implicit-self calls
+        # (`sibling_private(...)`) inside `lib/rigor/`'s own
+        # internals (analyser private helpers don't have RBS).
+        discovered_result = try_discovered_method(receiver_type, method_name, scope)
+        return discovered_result if discovered_result
+
         # Slice 7 phase 10 — user-class ancestor fallback. When
         # the receiver is `Nominal[T]` or `Singleton[T]` for a
         # class not in the RBS environment (typically a
@@ -112,6 +152,58 @@ module Rigor
         try_user_class_fallback(receiver_type, method_name, arg_types, environment, block_type)
       end
 
+      # v0.1.3 — discovered-method dispatch tier. `scope` carries
+      # the `discovered_methods` table built once per program by
+      # `ScopeIndexer` (a `Hash[String, Hash[Symbol, :instance |
+      # :singleton]]`). When the receiver names a discovered
+      # class AND the requested method is recorded for that
+      # class's appropriate kind, return `Type::Combinator.untyped`
+      # — the dispatcher cannot infer a more precise return type
+      # from the bare `def` shape, but the call site stops being a
+      # fail-soft hot spot.
+      #
+      # Returns `nil` when scope / receiver class is unavailable,
+      # when the method is not in the discovered table, OR when
+      # `discovered_def_nodes` carries a re-typable body for the
+      # method (so the downstream
+      # `ExpressionTyper#try_user_method_inference` tier can
+      # re-type the body for a precise return type rather than
+      # collapsing to `Dynamic[top]` here).
+      #
+      # The tier does NOT gate on `rbs_class_known?`. RBS dispatch
+      # already had its turn upstream and returned `nil` (otherwise
+      # we wouldn't be here). When RBS knows the class but the
+      # particular method is missing from the sig — common for
+      # internal helpers and for auto-generated stubs that emit
+      # `class X` without enumerating every method — falling
+      # through to the user-class fallback would mistakenly fire
+      # `call.undefined-method`. Honoring the discovered table
+      # here keeps the sibling-private call resolution working
+      # under partial RBS coverage.
+      def try_discovered_method(receiver_type, method_name, scope)
+        return nil if scope.nil?
+
+        class_name, kind = discovered_method_lookup(receiver_type)
+        return nil if class_name.nil?
+        return nil unless scope.discovered_method?(class_name, method_name, kind)
+        return nil if kind == :instance && scope.user_def_for(class_name, method_name)
+
+        Type::Combinator.untyped
+      end
+
+      # Resolves the `(class_name, kind)` pair scope_indexer keys
+      # its `discovered_methods` table on. `Nominal[X]` looks up
+      # instance methods on X; `Singleton[X]` looks up singleton
+      # methods on X. Other carriers return `[nil, nil]` so the
+      # tier declines.
+      def discovered_method_lookup(receiver_type)
+        case receiver_type
+        when Type::Nominal then [receiver_type.class_name, :instance]
+        when Type::Singleton then [receiver_type.class_name, :singleton]
+        else [nil, nil]
+        end
+      end
+
       # ADR-2 § "Flow Contribution Bundle" / v0.1.1 Track 2
       # slice 7. Walks every loaded plugin's
       # `#flow_contribution_for(call_node:, scope:)` hook,
@@ -147,6 +239,101 @@ module Rigor
       # publish as ground-truth `T`). Returns `nil` when the
       # environment carries no index, the index has no entry, or
       # the receiver has no nominal class to look up.
+      # ADR-16 synthetic-method tier. Slice 2b shipped the floor —
+      # a match short-circuits at the right precedence (above
+      # dep-source / discovered / user-class-fallback; below RBS)
+      # and returns `Dynamic[T]`. Slice 6 (precision promotion):
+      # - Tier B path (slice 6a, `provenance[:origin_module]`
+      #   recorded by the slice-3b scanner): redispatch on
+      #   `Nominal[origin_module]` via `RbsDispatch` so the
+      #   module's authored RBS return type wins. Devise's
+      #   `valid_password?` returns `bool`, not `Dynamic[T]`.
+      # - Tier C path (slice 6b, plain `return_type:` string from
+      #   the manifest's emit table): look up
+      #   `environment.nominal_for_name(return_type)` so
+      #   `attribute :avatar, Types::String` emits a synthetic
+      #   reader returning `Nominal[ActiveStorage::Attached::One]`
+      #   (when the class is in RBS). Unparameterised class names
+      #   only — parameterised forms (`Array[String]`,
+      #   `Hash[K, V]`) and plugin-supplied utility-type names
+      #   (`Pick<T, K>`) require routing through the full ADR-13
+      #   `Plugin::TypeNodeResolver` chain, which slice 6 does
+      #   not yet wire in (the resolver chain is consulted only
+      #   for `%a{rigor:v1:…}` payloads as of ADR-13 slice 3).
+      def try_synthetic_method(receiver_type, method_name, arg_types, block_type, environment)
+        index = environment&.synthetic_method_index
+        return nil if index.nil? || index.empty?
+
+        class_name = synthetic_method_class_name(receiver_type)
+        return nil if class_name.nil?
+
+        matches = case receiver_type
+                  when Type::Singleton then index.lookup_singleton(class_name, method_name)
+                  else index.lookup_instance(class_name, method_name)
+                  end
+        return nil if matches.empty?
+
+        promoted = promote_synthetic_match(matches, method_name, arg_types, block_type, environment)
+        promoted || Type::Combinator.untyped
+      end
+
+      # First non-nil promotion wins. Tier B (origin_module) and
+      # Tier C (return_type nominal lookup) are tried in the
+      # same registration-order pass per WD11 first-wins —
+      # the slice-3b scanner sets `origin_module` for Tier B
+      # entries and leaves it absent for Tier C, so the two
+      # paths self-route per match.
+      def promote_synthetic_match(matches, method_name, arg_types, block_type, environment)
+        return nil if environment.nil?
+
+        matches.each do |synthetic|
+          promoted =
+            promote_via_origin_module(synthetic, method_name, arg_types, block_type, environment) ||
+            promote_via_return_type(synthetic, environment)
+          return promoted if promoted
+        end
+        nil
+      end
+
+      # Slice 6a-TierB. For Tier B emissions (origin_module
+      # recorded in provenance), redispatch the call on the
+      # included module's `Nominal[...]` type via `RbsDispatch`.
+      # Returns nil when the SyntheticMethod is not a Tier B
+      # entry or when the origin_module is not in the RBS env.
+      def promote_via_origin_module(synthetic, method_name, arg_types, block_type, environment)
+        module_name = synthetic.provenance[:origin_module]
+        return nil unless module_name
+
+        module_type = Type::Combinator.nominal_of(module_name)
+        RbsDispatch.try_dispatch(
+          receiver: module_type, method_name: method_name, args: arg_types,
+          environment: environment, block_type: block_type
+        )
+      end
+
+      # Slice 6b-TierC. For Tier C emissions, look up the
+      # manifest-declared `return_type:` string via
+      # `environment.nominal_for_name`. Skips the placeholder
+      # `"untyped"` (Tier B's record-but-do-not-resolve marker
+      # from the slice-3b scanner) and the `"void"` keyword
+      # (RBS-style absent return). Falls back to nil when the
+      # class is not in the env — caller then returns Dynamic[T].
+      TIER_C_PLACEHOLDER_RETURNS = %w[untyped void].freeze
+      private_constant :TIER_C_PLACEHOLDER_RETURNS
+
+      def promote_via_return_type(synthetic, environment)
+        return_type = synthetic.return_type
+        return nil if return_type.nil? || TIER_C_PLACEHOLDER_RETURNS.include?(return_type)
+
+        environment.nominal_for_name(return_type)
+      end
+
+      def synthetic_method_class_name(receiver_type)
+        case receiver_type
+        when Type::Nominal, Type::Singleton then receiver_type.class_name
+        end
+      end
+
       def try_dependency_source(receiver_type, method_name, environment)
         index = environment&.dependency_source_index
         return nil if index.nil? || index.empty?
@@ -177,6 +364,71 @@ module Rigor
         budget_silence_result(class_name, index, environment)
       end
 
+      # ADR-10 slice 5c — record a
+      # `dynamic.dependency-source.boundary-cross` event when
+      # RBS dispatch resolves a call AND the receiver class
+      # belongs to a `mode: :full` opt-in gem whose Walker
+      # also catalogued the same `(class_name, method_name)`.
+      # The dispatcher still returns the RBS answer (per
+      # ADR-10's tier order: authoritative-source wins), but
+      # the reporter accumulates the crossing for end-of-run
+      # audit diagnostics.
+      #
+      # Five honest fall-throughs keep the gate narrow:
+      #
+      # - environment / index / reporter missing — slice 5c
+      #   needs all three.
+      # - receiver has no nominal class name (Dynamic-only
+      #   carriers) — nothing to look up.
+      # - receiver class doesn't belong to a `mode: :full` gem
+      #   — the user didn't opt this gem into the distinct
+      #   dispatch path.
+      # - the gem-source catalog has no entry for the method —
+      #   only RBS knows about it; nothing to cross.
+      # - the RBS-side result is itself `Dynamic[Top]` — the
+      #   "agreement" is trivially `untyped ≈ untyped`, no
+      #   meaningful divergence to flag.
+      def record_boundary_cross_if_applicable(receiver_type, method_name, rbs_result, environment)
+        class_name = boundary_cross_class_name(receiver_type, environment, rbs_result)
+        return if class_name.nil?
+
+        index = environment.dependency_source_index
+        return unless index.full_mode?(class_name)
+        return unless index.contribution_for(class_name: class_name, method_name: method_name)
+
+        environment.boundary_cross_reporter.record(
+          class_name: class_name, method_name: method_name,
+          gem_name: index.gem_for(class_name),
+          rbs_display: rbs_display_for(rbs_result)
+        )
+      end
+
+      # Composite preflight for {#record_boundary_cross_if_applicable}.
+      # Returns the receiver class name only when every prerequisite
+      # for emitting the diagnostic is satisfied (environment carries
+      # an index + reporter, receiver is a nominal carrier, RBS-side
+      # result is not the trivial `Dynamic[Top]` envelope). Returns
+      # `nil` to short-circuit otherwise.
+      def boundary_cross_class_name(receiver_type, environment, rbs_result)
+        return nil if environment.nil?
+        return nil if environment.dependency_source_index.nil?
+        return nil if environment.dependency_source_index.empty?
+        return nil if environment.boundary_cross_reporter.nil?
+        return nil if rbs_result_untyped?(rbs_result)
+
+        dep_source_class_name(receiver_type)
+      end
+
+      def rbs_result_untyped?(rbs_result)
+        rbs_result.is_a?(Type::Dynamic) && rbs_result.static_facet.is_a?(Type::Top)
+      end
+
+      def rbs_display_for(rbs_result)
+        return "untyped" if rbs_result.nil?
+
+        rbs_result.respond_to?(:describe) ? rbs_result.describe : rbs_result.inspect
+      end
+
       def budget_silence_result(class_name, index, _environment)
         return nil unless index.budget_overrun_strategy == :dependency_silence
 
@@ -242,6 +494,7 @@ module Rigor
           ShapeDispatch.try_dispatch(receiver: receiver_type, method_name: method_name, args: arg_types) ||
           FileFolding.try_dispatch(receiver: receiver_type, method_name: method_name, args: arg_types) ||
           KernelDispatch.try_dispatch(receiver: receiver_type, method_name: method_name, args: arg_types) ||
+          MethodFolding.try_forward(receiver: receiver_type, method_name: method_name, args: arg_types) ||
           BlockFolding.try_fold(
             receiver: receiver_type, method_name: method_name, args: arg_types, block_type: block_type
           )
@@ -325,9 +578,25 @@ module Rigor
         Type::Combinator.nominal_of(receiver_type.class_name)
       end
 
-      CONSTANT_CONSTRUCTORS = {
-        "Pathname" => ->(arg) { Pathname.new(arg) }
-      }.freeze
+      # ADR-15 Phase 4b.x — `Ractor.make_shareable` on both the
+      # outer Hash and each lambda value. A plain `.freeze` leaves
+      # the Procs unshareable; reading `CONSTANT_CONSTRUCTORS[class]`
+      # from a worker Ractor would raise `Ractor::IsolationError`,
+      # which the `rescue StandardError` in
+      # `constant_constructor_lift` silently swallows — `meta_new`
+      # then falls back to `Nominal[Pathname]` in pool mode while
+      # sequential builds the `Constant<Pathname>` lift. The
+      # divergence surfaces downstream as a spurious
+      # `call.argument-type-mismatch` (sequential's
+      # `argument_type_diagnostic` short-circuits on Constant<Pathname>
+      # because Pathname is not in its CONSTANT_CLASSES table; pool's
+      # Nominal[Pathname] doesn't short-circuit). Surfaced on GitLab
+      # FOSS via `lib/gitlab/mail_room.rb:17`.
+      CONSTANT_CONSTRUCTORS = Ractor.make_shareable({
+                                                      "Pathname" => Ractor.make_shareable(lambda { |arg|
+                                                                                            Pathname.new(arg)
+                                                                                          })
+                                                    })
       private_constant :CONSTANT_CONSTRUCTORS
 
       def constant_constructor_lift(class_name, arg_types)

data/lib/rigor/inference/method_parameter_binder.rb

@@ -32,7 +32,6 @@ module Rigor
     # `#singleton_method`.
     #
     # See docs/internal-spec/inference-engine.md for the binding contract.
-    # rubocop:disable Metrics/ClassLength
     class MethodParameterBinder
       # @param environment [Rigor::Environment]
       # @param class_path [String, nil] the qualified name of the class
@@ -175,7 +174,7 @@ module Rigor
       # `non-empty-array[Integer]` describe the parameter binding
       # they actually want, not its element type.
       def apply_param_overrides(types, slots, rbs_method)
-        override_map = RbsExtended.param_type_override_map(rbs_method)
+        override_map = RbsExtended.param_type_override_map(rbs_method, environment: @environment)
         return if override_map.empty?
 
         slots.each do |slot|
@@ -212,20 +211,30 @@ module Rigor
       # (`?by:`) while the Ruby `def` lists it as required (or vice
       # versa); the binding is by-name regardless of which side
       # defines it.
-      KEYWORD_PROVIDER = lambda do |fn, slot|
+      KEYWORD_PROVIDER = Ractor.make_shareable(lambda do |fn, slot|
         fn.required_keywords[slot.name]&.type || fn.optional_keywords[slot.name]&.type
-      end
+      end)
       private_constant :KEYWORD_PROVIDER
 
-      RBS_TYPE_PROVIDERS = {
-        required_positional: ->(fn, slot) { fn.required_positionals[slot.index]&.type },
-        optional_positional: ->(fn, slot) { fn.optional_positionals[slot.index]&.type },
-        rest_positional: ->(fn, _slot) { fn.rest_positionals&.type },
-        trailing_positional: ->(fn, slot) { fn.trailing_positionals[slot.index]&.type },
-        required_keyword: KEYWORD_PROVIDER,
-        optional_keyword: KEYWORD_PROVIDER,
-        rest_keyword: ->(fn, _slot) { fn.rest_keywords&.type }
-      }.freeze
+      RBS_TYPE_PROVIDERS = Ractor.make_shareable({
+                                                   required_positional: Ractor.make_shareable(lambda { |fn, slot|
+                                                     fn.required_positionals[slot.index]&.type
+                                                   }),
+                                                   optional_positional: Ractor.make_shareable(lambda { |fn, slot|
+                                                     fn.optional_positionals[slot.index]&.type
+                                                   }),
+                                                   rest_positional: Ractor.make_shareable(lambda { |fn, _slot|
+                                                     fn.rest_positionals&.type
+                                                   }),
+                                                   trailing_positional: Ractor.make_shareable(lambda { |fn, slot|
+                                                     fn.trailing_positionals[slot.index]&.type
+                                                   }),
+                                                   required_keyword: KEYWORD_PROVIDER,
+                                                   optional_keyword: KEYWORD_PROVIDER,
+                                                   rest_keyword: Ractor.make_shareable(lambda { |fn, _slot|
+                                                     fn.rest_keywords&.type
+                                                   })
+                                                 })
       private_constant :RBS_TYPE_PROVIDERS
 
       def rbs_type_for_slot(function, slot)
@@ -275,6 +284,5 @@ module Rigor
         end
       end
     end
-    # rubocop:enable Metrics/ClassLength
   end
 end

data/lib/rigor/inference/narrowing.rb

@@ -376,7 +376,7 @@ module Rigor
       # the predicate shape is recognised, or `nil` to signal "no
       # narrowing" so the public surface can fall back to the entry
       # scope.
-      def analyse(node, scope) # rubocop:disable Metrics/CyclomaticComplexity
+      def analyse(node, scope)
         case node
         when Prism::ParenthesesNode
           analyse_parentheses(node, scope)
@@ -384,6 +384,14 @@ module Rigor
           analyse_statements(node, scope)
         when Prism::LocalVariableReadNode
           analyse_local_read(node, scope)
+        when Prism::LocalVariableWriteNode
+          analyse_local_write(node, scope)
+        when Prism::InstanceVariableWriteNode
+          analyse_ivar_write(node, scope)
+        when Prism::ClassVariableWriteNode
+          analyse_cvar_write(node, scope)
+        when Prism::GlobalVariableWriteNode
+          analyse_global_write(node, scope)
         when Prism::CallNode
           analyse_call(node, scope)
         when Prism::AndNode
@@ -445,7 +453,6 @@ module Rigor
         # intersects each half with the integer-domain parts of
         # `current_type`. Non-integer parts of a Union receiver
         # (nil, String, …) survive unchanged.
-        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def complement_integer_range(current_type, range)
           halves = integer_range_complement_halves(range)
           parts = current_type.is_a?(Type::Union) ? current_type.members : [current_type]
@@ -466,7 +473,6 @@ module Rigor
 
           Type::Combinator.union(*survivors)
         end
-        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         # Returns the two open halves of an IntegerRange's
         # complement: the left half `int<-∞, a-1>` (when `a` is
@@ -738,6 +744,59 @@ module Rigor
           ]
         end
 
+        # Assignment-in-condition: `if name = expr` and the more
+        # frequent `if cond && (name = expr)` / `if cond && name =
+        # expr` Redmine-style guard. By the time narrowing runs,
+        # `StatementEvaluator#eval_local_write` has already bound
+        # the assigned local in `scope` to the rvalue type. The
+        # write's own truthiness IS the assigned value's
+        # truthiness, so the truthy edge narrows the local by
+        # `narrow_truthy(current)` and the falsey edge by
+        # `narrow_falsey(current)`. Mirrors `analyse_local_read`
+        # because the only meaningful difference between
+        # "predicate is `var`" and "predicate is `var = expr`" is
+        # which scope holds the just-bound value; the narrowing
+        # contract on the surrounding `if` is the same.
+        def analyse_local_write(node, scope)
+          current = scope.local(node.name)
+          return nil if current.nil?
+
+          [
+            scope.with_local(node.name, narrow_truthy(current)),
+            scope.with_local(node.name, narrow_falsey(current))
+          ]
+        end
+
+        def analyse_ivar_write(node, scope)
+          current = scope.ivar(node.name)
+          return nil if current.nil?
+
+          [
+            scope.with_ivar(node.name, narrow_truthy(current)),
+            scope.with_ivar(node.name, narrow_falsey(current))
+          ]
+        end
+
+        def analyse_cvar_write(node, scope)
+          current = scope.cvar(node.name)
+          return nil if current.nil?
+
+          [
+            scope.with_cvar(node.name, narrow_truthy(current)),
+            scope.with_cvar(node.name, narrow_falsey(current))
+          ]
+        end
+
+        def analyse_global_write(node, scope)
+          current = scope.global(node.name)
+          return nil if current.nil?
+
+          [
+            scope.with_global(node.name, narrow_truthy(current)),
+            scope.with_global(node.name, narrow_falsey(current))
+          ]
+        end
+
         # `if /(?<x>...)/ =~ str` — Prism wraps the `=~` call in a
         # `MatchWriteNode` listing the named-capture targets. The
         # parent `eval_match_write` has already bound each target
@@ -918,12 +977,12 @@ module Rigor
         # zero-arg predicates on `Numeric`. We model them as
         # comparisons against the literal 0 so the existing range
         # narrowing handles them uniformly.
-        ZERO_CLASS_PREDICATE_RULES = {
-          positive?: { truthy: [:>, 0],  falsey: [:<=, 0] },
-          negative?: { truthy: [:<, 0],  falsey: [:>=, 0] },
-          zero?: { truthy: [:eq, 0], falsey: [:ne, 0] },
-          nonzero?: { truthy: [:ne, 0], falsey: [:eq, 0] }
-        }.freeze
+        ZERO_CLASS_PREDICATE_RULES = Ractor.make_shareable({
+                                                             positive?: { truthy: [:>, 0], falsey: [:<=, 0] },
+                                                             negative?: { truthy: [:<, 0], falsey: [:>=, 0] },
+                                                             zero?: { truthy: [:eq, 0], falsey: [:ne, 0] },
+                                                             nonzero?: { truthy: [:ne, 0], falsey: [:eq, 0] }
+                                                           })
         private_constant :ZERO_CLASS_PREDICATE_RULES
 
         def analyse_zero_class_predicate(node, scope, predicate:)
@@ -1204,15 +1263,73 @@ module Rigor
           return nil if node.arguments.nil?
           return nil unless node.arguments.arguments.size == 1
 
-          class_name = static_class_name(node.arguments.arguments.first)
-          return nil if class_name.nil?
+          bare_name = static_class_name(node.arguments.arguments.first)
+          return nil if bare_name.nil?
 
           current = scope.local(node.receiver.name)
           return nil if current.nil?
 
+          # Resolve `bare_name` through the lexical-scope chain
+          # so a name shadowed by the current class / enclosing
+          # module wins over the top-level constant. Mirrors
+          # Ruby's `Module.nesting`-driven constant lookup. The
+          # canonical motivating case: inside
+          # `Rigor::Type::Singleton#==`, `is_a?(Singleton)`
+          # should resolve to `Rigor::Type::Singleton`, not the
+          # top-level stdlib `Singleton` mixin (which would
+          # surface as a spurious `undefined-method` on
+          # subsequent `other.class_name` calls).
+          class_name = resolve_class_name_lexically(bare_name, scope)
           class_predicate_scopes(scope, node.receiver.name, current, class_name, exact: exact)
         end
 
+        # Walks the lexical-nesting chain derived from
+        # `scope.self_type` and returns the first
+        # `<prefix>::<bare_name>` (or bare `<bare_name>` at the
+        # top level) that the environment recognises. Falls back
+        # to `bare_name` itself when nothing in the chain
+        # resolves; the downstream `narrow_class` then yields
+        # the conservative answer for unknown receivers.
+        def resolve_class_name_lexically(bare_name, scope)
+          return bare_name if bare_name.include?("::") # Already qualified.
+
+          chain = lexical_nesting_for(scope)
+          chain.each do |prefix|
+            candidate = "#{prefix}::#{bare_name}"
+            return candidate if class_known_to_scope?(scope, candidate)
+          end
+          bare_name
+        end
+
+        # Combines the environment's RBS-known set with the
+        # scope's in-source `discovered_classes` table so a
+        # lexical-nesting candidate matches a class the project
+        # declares but has no RBS for.
+        def class_known_to_scope?(scope, candidate)
+          return true if scope.environment.class_known?(candidate)
+
+          scope.discovered_classes.key?(candidate)
+        end
+
+        # Approximates `Module.nesting` from the inferable
+        # `self_type`. Today's implementation handles the common
+        # case: when the surrounding method is a regular
+        # instance method (`self_type = Nominal[T]`) or a
+        # class-body / singleton (`self_type = Singleton[T]`),
+        # the chain is `T`'s namespace path — `Foo::Bar::Baz`
+        # → `["Foo::Bar::Baz", "Foo::Bar", "Foo"]`. Returns an
+        # empty array when `self_type` is unknown.
+        def lexical_nesting_for(scope)
+          self_type = scope.self_type
+          base = case self_type
+                 when Type::Nominal, Type::Singleton then self_type.class_name
+                 end
+          return [] if base.nil? || base.empty?
+
+          parts = base.split("::")
+          parts.each_index.map { |i| parts[0..-(i + 1)].join("::") }
+        end
+
         def class_predicate_scopes(scope, name, current, class_name, exact:)
           [
             scope.with_local(
@@ -1337,7 +1454,7 @@ module Rigor
           method_def = resolve_rbs_extended_method(node, scope)
           return nil if method_def.nil?
 
-          contribution = RbsExtended.read_flow_contribution(method_def)
+          contribution = RbsExtended.read_flow_contribution(method_def, environment: scope.environment)
           return nil if contribution.nil?
 
           result = Rigor::FlowContribution::Merger.merge([contribution])

data/lib/rigor/inference/rbs_type_translator.rb

@@ -41,7 +41,6 @@ module Rigor
     #   `Nominal[C]` regardless of which method body we are in.
     # When either argument is omitted, the corresponding token degrades
     # to Dynamic[Top].
-    # rubocop:disable Metrics/ModuleLength
     module RbsTypeTranslator
       # Hash-based dispatch keeps `translate` linear and dodges the
       # bookkeeping costs of a 20-arm `case` (RuboCop AbcSize/CCN/Length
@@ -214,6 +213,5 @@ module Rigor
         end
       end
     end
-    # rubocop:enable Metrics/ModuleLength
   end
 end