rigortype 0.4.0 → 0.4.2

data/lib/rigor/inference/narrowing.rb

@@ -10,6 +10,7 @@ require_relative "../rbs_extended"
 require_relative "../analysis/fact_store"
 require_relative "../builtins/regex_refinement"
 require_relative "guard_rebinding"
+require_relative "key_presence_guard"
 require_relative "last_line"
 require_relative "operand_effects"
 require_relative "optimistic_origin"
@@ -440,6 +441,20 @@ module Rigor
         Source::ConstantPath.rooted?(node) ? "::#{name}" : name
       end
 
+      # Issue #1446 — the classes a class guard narrowed the receiver `node` to where the guard left it `bot`
+      # ({Scope#bot_guard_classes_for}), or nil: a node that is not a local, instance-variable, global or constant
+      # read, or one no such guard narrowed.
+      def bot_guard_classes_of(node, scope)
+        case node
+        when Prism::LocalVariableReadNode then scope.bot_guard_classes_for(:local, node.name)
+        when Prism::InstanceVariableReadNode then scope.bot_guard_classes_for(:ivar, node.name)
+        when Prism::GlobalVariableReadNode then scope.bot_guard_classes_for(:global, node.name)
+        when Prism::ConstantReadNode, Prism::ConstantPathNode
+          key = constant_key(node)
+          key && scope.bot_guard_classes_for(:constant, key)
+        end
+      end
+
       # Public predicate analyser. Returns `[truthy_scope, falsey_scope]`, always; when no
       # narrowing rule matches the predicate node both entries are the receiver scope unchanged.
       def predicate_scopes(node, scope)
@@ -504,15 +519,20 @@ module Rigor
         # a different regex. Applied even when the subject is not a narrowable local read.
         body_scope = apply_when_regex_globals(conditions, scope)
 
-        # Issue #1429 — a global or constant subject (`case $stdout when StringIO`) narrows as a local does.
+        # Issue #1429 — a global or constant subject (`case $stdout when StringIO`) narrows as a local does, and so
+        # does an instance variable (#1446).
         slot = receiver_slot(subject, scope, kinds: CASE_SUBJECT_KINDS)
         return [body_scope, scope] if slot.nil?
 
         truthy_type, falsey_type = case_when_types(scope, slot.current, conditions)
-        [narrow_slot(body_scope, slot, truthy_type), narrow_slot(scope, slot, falsey_type)]
+        classes = conditions.map do |condition|
+          lexical_class_name(condition, scope) || case_equality_target_class(condition)
+        end
+        body_scope = record_bot_guard(narrow_guarded_slot(body_scope, slot, truthy_type), slot, truthy_type, classes)
+        [body_scope, narrow_guarded_slot(scope, slot, falsey_type)]
       end
 
-      CASE_SUBJECT_KINDS = %i[local global constant].freeze
+      CASE_SUBJECT_KINDS = %i[local ivar global constant].freeze
       private_constant :CASE_SUBJECT_KINDS
 
       # When the clause has exactly one `RegularExpressionNode` literal condition, narrow the
@@ -979,8 +999,9 @@ module Rigor
         end
 
         GLOBAL_AND_CONSTANT = %i[global constant].freeze
+        CLASS_GUARD_SLOT_KINDS = %i[ivar global constant].freeze
         ALL_SLOT_KINDS = %i[local ivar global constant].freeze
-        private_constant :GLOBAL_AND_CONSTANT, :ALL_SLOT_KINDS
+        private_constant :GLOBAL_AND_CONSTANT, :CLASS_GUARD_SLOT_KINDS, :ALL_SLOT_KINDS
 
         # The {ReceiverSlot} `node` reads, among `kinds`, or nil. A local or instance variable needs a binding. A
         # global the scope does not bind is read as it reads unbound, and a constant reference as it resolves
@@ -1029,6 +1050,25 @@ module Rigor
           end
         end
 
+        # Issue #1446 — {#narrow_slot} for a class guard: an instance variable narrows with its pre-guard type
+        # recorded, as a global does, since code that may reach `self` may rebind it. The other guards on an instance
+        # variable keep {#narrow_slot}'s unrecorded binding.
+        def narrow_guarded_slot(scope, slot, type)
+          return narrow_slot(scope, slot, type) unless slot.kind == :ivar
+          return scope if type == slot.current
+
+          scope.with_guarded_ivar(slot.name, type, slot.current)
+        end
+
+        # Issue #1446 — `scope`, the guard's truthy edge, with `class_names` recorded for `slot` when the guard left
+        # it `bot` ({Scope#with_bot_guard_classes}): the value that passes it is one of those classes. Nothing is
+        # recorded when a condition names no class.
+        def record_bot_guard(scope, slot, type, class_names)
+          return scope unless type.is_a?(Type::Bot) && !class_names.empty? && class_names.none?(&:nil?)
+
+          scope.with_bot_guard_classes(slot.kind, slot.name, class_names)
+        end
+
         def narrow_global_slot(scope, slot, type)
           return scope if type == slot.current
 
@@ -1234,7 +1274,7 @@ module Rigor
         end
 
         def simple_dispatch_name?(name)
-          %i[nil? ! is_a? kind_of? instance_of? == != === =~ match? key? has_key? empty? any?
+          %i[nil? ! is_a? kind_of? instance_of? == != === =~ !~ match? key? has_key? include? member? empty? any?
              none? respond_to? nan? finite?].include?(name)
         end
 
@@ -1245,15 +1285,19 @@ module Rigor
           when :instance_of? then analyse_class_predicate(node, scope, exact: true)
           when :==, :!= then analyse_equality_predicate(node, scope, equality: name)
           when :=== then analyse_case_equality_predicate(node, scope)
-          when :=~ then analyse_regex_match_predicate(node, scope)
+          when :=~, :!~ then dispatch_regex_match_predicate(node, scope, name)
           when :match? then analyse_whole_regex_match_predicate(node, scope)
-          when :key?, :has_key? then analyse_key_presence_predicate(node, scope)
+          when :key?, :has_key?, :include?, :member? then analyse_key_presence_predicate(node, scope)
           when :empty?, :any?, :none? then analyse_array_emptiness_predicate(node, scope, name)
           when :respond_to? then analyse_respond_to_predicate(node, scope)
           when :nan?, :finite? then analyse_float_class_predicate(node, scope, name)
           end
         end
 
+        def dispatch_regex_match_predicate(node, scope, name)
+          name == :=~ ? analyse_regex_match_predicate(node, scope) : analyse_regex_not_match_predicate(node, scope)
+        end
+
         # T3 (template-corpora survey) — `recv.respond_to?(sym)` truthy edge narrows `recv`
         # non-nil. `nil.respond_to?(m)` is `false` for every method `m` that `NilClass` does not
         # define, so a truthy `respond_to?` proves the receiver was not `nil` UNLESS the queried
@@ -1419,14 +1463,16 @@ module Rigor
         # `h[:foo]` nil-typed). The falsey edge is left unchanged — "key absent" is the
         # conservative no-op. Only literal `Symbol`/`String` arguments and
         # `LocalVariableReadNode`/`InstanceVariableReadNode` receivers narrow; everything else
-        # (Dynamic, `Nominal[Hash]`, method-chain receivers, dynamic keys) bails to no
-        # narrowing.
+        # (Dynamic, `Nominal[Hash]`, method-chain receivers) bails to no narrowing. A non-literal
+        # key goes to {#analyse_computed_key_presence_predicate} (issue #1703).
         def analyse_key_presence_predicate(node, scope)
           return nil if node.arguments.nil?
           return nil unless node.arguments.arguments.size == 1
 
-          key = static_hash_key(node.arguments.arguments.first)
-          return nil if key.nil?
+          # A literal key promotes a shape's optional key only for `key?` / `has_key?`; `include?` / `member?` reach
+          # the computed-key guard alone, so a String or Array receiver's `include?` keeps its own narrowings.
+          key = static_hash_key(node.arguments.arguments.first) if %i[key? has_key?].include?(node.name)
+          return analyse_computed_key_presence_predicate(node, scope) if key.nil?
 
           case node.receiver
           when Prism::LocalVariableReadNode
@@ -1436,6 +1482,17 @@ module Rigor
           end
         end
 
+        # Issue #1703 — `H.key?(k)` / `has_key?` / `include?` / `member?` with a non-literal key (a local, an ivar,
+        # or a reader chain such as `prop.column_type`) on a closed hash shape held in a local, an ivar or a
+        # constant. The truthy edge records the guard, and a later `H[k]` of the same receiver and structurally the
+        # same key drops the miss `nil` ({KeyPresenceGuard}). The falsey edge is the no-op: an
+        # absent computed key says nothing a shape can record. Nil when the guard does not apply, so a collection's
+        # `include?` still reaches the membership and String predicates.
+        def analyse_computed_key_presence_predicate(node, scope)
+          truthy = KeyPresenceGuard.record(node, scope)
+          truthy && [truthy, scope]
+        end
+
         def key_presence_scopes(name, key, scope, reader:, writer:)
           current = scope.public_send(reader, name)
           return nil if current.nil?
@@ -1532,7 +1589,9 @@ module Rigor
         #
         # Returns nil (no narrowing) when the receiver / argument pair does not resolve to exactly one
         # regex pattern we can count (see {#regex_match_pattern}).
-        def analyse_regex_match_predicate(node, scope)
+        #
+        # `refine: false` leaves out the whole-receiver refinement, which names a String.
+        def analyse_regex_match_predicate(node, scope, refine: true)
           return nil if node.arguments.nil?
           return nil unless node.arguments.arguments.size == 1
 
@@ -1552,10 +1611,96 @@ module Rigor
           # match-global logic above. A successful `str =~ /\A\d+\z/` proves the WHOLE string
           # matched, so the string operand narrows to the imported refinement the anchored pattern
           # names. The falsey edge is untouched: a failed match proves nothing about the shape.
-          truthy = apply_whole_receiver_refinement(truthy, node.receiver, arg, pattern.source, scope)
+          truthy = apply_whole_receiver_refinement(truthy, node.receiver, arg, pattern.source, scope) if refine
           [truthy, falsey]
         end
 
+        # Issue #1379 — `subject !~ pattern` is `Kernel#!~`, which returns `!(subject =~ pattern)`. It runs the same
+        # match in the caller's frame, so its edges are {#analyse_regex_match_predicate}'s swapped: the falsey edge is
+        # the match edge (`$~` a `MatchData`, an unconditional `$N` a `String`, and the whole-receiver refinement), the
+        # truthy edge the no-match edge (`$~` and `$N` nil). The same patterns are recognised and the same ones
+        # declined (a non-regex operand, an ambiguous constant, `//x`).
+        #
+        # Unlike `=~`'s, an edge here is narrowed only when the receiver proves what the frame holds on it
+        # ({#not_match_receiver_edges}). An edge it cannot vouch for keeps the match globals forgotten, since the call
+        # may still have rebound them. The refinement is kept only when the local it would narrow is known to be a
+        # String on the match edge ({#refinable_operand?}).
+        def analyse_regex_not_match_predicate(node, scope)
+          edges = analyse_regex_match_predicate(node, scope, refine: refinable_operand?(node, scope))
+          return nil if edges.nil?
+
+          match, no_match = edges
+          forgotten = scope.forget_match_globals
+          case not_match_receiver_edges(node, scope)
+          when :both then [no_match, match]
+          when :match then [forgotten, match]
+          else [forgotten, forgotten]
+          end
+        end
+
+        # Which edges of `recv !~ pattern` the receiver lets {#analyse_regex_not_match_predicate} narrow. `Kernel#!~`
+        # dispatches `=~` on the receiver:
+        #
+        # - A Regexp receiver (the pattern on the left) runs `Regexp#=~`, which sets `$~` on both outcomes, a `nil`
+        #   argument included: `:both`.
+        # - `String#=~` and `Symbol#=~` do the same: `:both` when every member of the receiver's type is a String or a
+        #   Symbol.
+        # - `NilClass#=~` answers nil and leaves `$~` alone, so a nil receiver reaches the no-match edge with the
+        #   previous match still bound; it never reaches the match edge. A `Dynamic` receiver may be nil at run time
+        #   whatever its static facet says: `:match` when every member is a String, a Symbol, nil, or a `Dynamic`
+        #   that is untyped or whose facet holds only those.
+        # - Any other receiver may define `=~` in Ruby, which binds `$~` in its own frame, not the caller's: nil.
+        #
+        # A safe-navigation `recv&.!~(pattern)` answers nil without matching on a nil receiver, so it declines too.
+        def not_match_receiver_edges(node, scope)
+          return nil if node.receiver.nil? || node.safe_navigation?
+          return :both if regex_operand_pattern(node.receiver, scope).is_a?(RegexMatchPattern)
+
+          kinds = not_match_member_kinds(scope.type_of(node.receiver), scope)
+          return :both if kinds.all? { |kind| %i[string symbol].include?(kind) }
+
+          :match if kinds.all? { |kind| %i[string symbol nil dynamic].include?(kind) }
+        end
+
+        # Whether the local operand {#apply_whole_receiver_refinement} would narrow holds only Strings and nil, which
+        # the match edge excludes. The refinement names a String, so a member that may be a Symbol — a Symbol, or an
+        # untyped `Dynamic` that `Kernel#!~` accepts as the receiver or `Regexp#=~` as the argument — keeps it out:
+        # `return if raw !~ /\A\d+\z/` on an untyped `raw` must not make `raw.to_proc` an undefined method.
+        def refinable_operand?(node, scope)
+          operand = [node.receiver, *node.arguments&.arguments].find { |o| o.is_a?(Prism::LocalVariableReadNode) }
+          type = operand && scope.local(operand.name)
+          return true if type.nil?
+
+          not_match_member_kinds(type, scope).all? { |kind| %i[string nil].include?(kind) }
+        end
+
+        def not_match_member_kinds(type, scope)
+          (type.is_a?(Type::Union) ? type.members : [type]).map { |member| not_match_member_kind(member, scope) }
+        end
+
+        # `:string` or `:symbol` for a member {.narrow_not_class} proves a String or a Symbol (a value or refinement of
+        # either, or a class the environment orders below it; a project subclass it cannot order reads as neither),
+        # `:nil`, `:dynamic` for a `Dynamic` whose facet is untyped or holds only Strings, Symbols and nil, or nil for
+        # anything else.
+        def not_match_member_kind(member, scope)
+          return not_match_dynamic_kind(member, scope) if member.is_a?(Type::Dynamic)
+          return :nil if narrow_nil(member) == member && !member.is_a?(Type::Bot)
+
+          environment = scope.environment
+          { "String" => :string, "Symbol" => :symbol }.each do |class_name, kind|
+            return kind if narrow_not_class(member, class_name, environment: environment, scope: scope).is_a?(Type::Bot)
+          end
+          nil
+        end
+
+        def not_match_dynamic_kind(member, scope)
+          facet = member.static_facet
+          return :dynamic if facet.is_a?(Type::Top)
+
+          facet_kinds = not_match_member_kinds(facet, scope)
+          :dynamic if facet_kinds.all? { |kind| %i[string symbol nil].include?(kind) }
+        end
+
         # `str.match?(/\A\d+\z/)` — `String#match?` is a pure boolean predicate whose truthy edge
         # proves a property of the ENTIRE receiver. When the argument is a fully `\A…\z`-anchored
         # single-char-class pattern recognised by {RegexRefinement.for_whole_pattern}, narrow the
@@ -2239,9 +2384,10 @@ module Rigor
         end
 
         # Issue #1429 — `$stdout.is_a?(StringIO)`, `STDOUT.kind_of?(StringIO)`: a global or constant receiver
-        # narrows as a local does ({#class_predicate_scopes}), with the pre-guard type recorded ({#narrow_slot}).
+        # narrows as a local does ({#class_predicate_scopes}), with the pre-guard type recorded ({#narrow_slot}). So
+        # does an instance variable (#1446, {#narrow_guarded_slot}).
         def analyse_class_predicate_on_slot(receiver, scope, class_name, exact)
-          slot = receiver_slot(receiver, scope, kinds: GLOBAL_AND_CONSTANT)
+          slot = receiver_slot(receiver, scope, kinds: CLASS_GUARD_SLOT_KINDS)
           return nil if slot.nil?
 
           class_slot_scopes(scope, slot, class_name, exact: exact)
@@ -2250,11 +2396,9 @@ module Rigor
         def class_slot_scopes(scope, slot, class_name, exact:)
           environment = scope.environment
           truthy = narrow_class(slot.current, class_name, exact: exact, environment: environment, scope: scope)
-          [
-            narrow_slot(scope, slot, truthy),
-            narrow_slot(scope, slot, narrow_not_class(slot.current, class_name, exact: exact,
-                                                                                environment: environment, scope: scope))
-          ]
+          falsey = narrow_not_class(slot.current, class_name, exact: exact, environment: environment, scope: scope)
+          truthy_scope = record_bot_guard(narrow_guarded_slot(scope, slot, truthy), slot, truthy, [class_name])
+          [truthy_scope, narrow_guarded_slot(scope, slot, falsey)]
         end
 
         # The class name a `is_a?` / `kind_of?` / `instance_of?` argument denotes: the top-level
@@ -2429,12 +2573,12 @@ module Rigor
         end
 
         # Issue #1429 — `StringIO === $stdout`, `StringIO === STDOUT`: the class-constant receiver form on a global or
-        # constant argument. The Range / Regexp receivers stay local-only.
+        # constant argument, and on an instance variable (#1446). The Range / Regexp receivers stay local-only.
         def analyse_case_equality_on_slot(receiver, arg, scope)
           class_name = lexical_class_name(receiver, scope)
           return nil if class_name.nil?
 
-          slot = receiver_slot(arg, scope, kinds: GLOBAL_AND_CONSTANT)
+          slot = receiver_slot(arg, scope, kinds: CLASS_GUARD_SLOT_KINDS)
           return nil if slot.nil?
 
           class_slot_scopes(scope, slot, class_name, exact: false)

data/lib/rigor/inference/object_mixins.rb

@@ -0,0 +1,180 @@
+# frozen_string_literal: true
+
+require_relative "../reflection"
+require_relative "../analysis/dependency_recorder"
+
+module Rigor
+  module Inference
+    # Issue #1697 — the modules the project mixes into `Object`, and what they say about a method name.
+    #
+    # A top-level `include M` is `main.include`, which is `Object.include`, so M's instance methods exist on
+    # every object: bare top-level calls (`main` is an `Object`) and calls on any receiver whose class
+    # descends from `Object`. `ScopeIndexer` records that statement under its own owner key
+    # ({TOPLEVEL_INCLUDE_KEY}), and an `include M` inside `class Object ... end` on `Object`. The RBS
+    # environment knows nothing of either: `Object`'s RBS ancestry is core's, so a direct lookup on an
+    # RBS-known receiver misses every one of M's methods. This module is the one place that asks the
+    # project's `Object` edges instead, for the
+    # `call.unresolved-toplevel` and `call.undefined-method` silences in `Analysis::CheckRules`. Nothing
+    # types a call through these edges yet: what Ruby reaches first, even for a bare top-level call, depends
+    # on more than the chain shows (a block that rebinds `self`, an `extend` or a singleton `def` on `main`),
+    # so typing is issue #1715's.
+    #
+    # The edges are read through `Scope::ResolutionChain`, the two owners' instance chains, whose search
+    # files the ADR-46 class edge of every project entry it passes, the declaring files among them (a file
+    # that wrote a top-level `include` is one), so a consumer re-checks when the include that answered for
+    # it is edited away. A project that never reopens `Object` and writes no top-level `include` returns
+    # before reading anything. The question is a union over the chain, not "which definer does Ruby call":
+    # any entry that may define the name answers, so the chain's `settle` verdict is not asked.
+    module ObjectMixins
+      OWNER = "Object"
+      # The owner key `ScopeIndexer` files a top-level `include` under, beside `Object`'s own key, so that
+      # no ancestry walk that types a call reaches it (see `ScopeIndexer#toplevel_include_owner`).
+      TOPLEVEL_INCLUDE_KEY = "<toplevel-include>"
+
+      module_function
+
+      # How the project's `Object` mixins answer `method_name`, nearest edge first:
+      #
+      # - `[:rbs, module_name, definition]` — an RBS-declared module declares it; `definition` is its
+      #   `RBS::Definition::Method`. `:private_rbs` is the same for a private declaration, which a bare call
+      #   reaches and a call with a receiver does not.
+      # - `[:source, module_name]` — a project module (or `Object` itself) defines it.
+      # - `[:singleton_function, module_name]` — an RBS-declared module declares it only as a singleton method.
+      #   Core declares `Math`'s functions that way (`def self.sqrt`) although they are `module_function`s,
+      #   whose private instance copies a bare call reaches after `include Math`. RBS cannot tell such a
+      #   function from a plain `def self.`, so the answer silences a bare call only.
+      # - `[:opaque, module_name]` — a module neither RBS nor the project declares. Its surface cannot be
+      #   enumerated, so it may define the name.
+      # - `[:truncated, "Object"]` — the chain was cut at its budget with no answer before the cut: a definer
+      #   may sit past it, which is uncertainty, not absence.
+      # - `nil` — no edge, or every edge names a module known not to declare it.
+      #
+      # `skip:` names the kinds a caller cannot use; an entry of one of them is passed over and the search
+      # goes on to the next, so the answer is a union over the chain for those callers rather than the
+      # nearest entry only.
+      def answer(scope, method_name, skip: NO_SKIP)
+        return nil if scope.nil?
+
+        # ADR-46 — the answer depends on whether a top-level `include` exists anywhere, so a consumer checked
+        # while none did must re-check when one appears. The key appears as a declared "class" of the file that
+        # writes it (`discovered_class_sources`), which is what this name-keyed existence edge listens for.
+        if Analysis::DependencyRecorder.active?
+          Analysis::DependencyRecorder.read_last_segment(:class, TOPLEVEL_INCLUDE_KEY)
+        end
+        EDGE_OWNERS.each do |owner|
+          next unless scope.known_user_class?(owner)
+
+          found = answer_on_chain(scope, owner, method_name, skip)
+          return found if found
+        end
+        nil
+      end
+
+      # Where `Object`'s project edges are recorded: a top-level `include` under the indexer's own key, and
+      # `Object` itself for `include M` in `class Object` (and `Object`'s own definitions).
+      EDGE_OWNERS = [TOPLEVEL_INCLUDE_KEY, OWNER].freeze
+      private_constant :EDGE_OWNERS
+
+      def answer_on_chain(scope, owner, method_name, skip)
+        chain = Scope::ResolutionChain.for(scope, owner, :instance, :methods)
+        found = chain.search(scope, side: :instance) do |entry|
+          entry_answer = answer_for_entry(scope, entry, method_name)
+          entry_answer unless entry_answer.nil? || skip.include?(entry_answer.first)
+        end
+        return found if found
+
+        chain.truncated? ? [:truncated, owner] : nil
+      end
+      private_class_method :answer_on_chain
+
+      NO_SKIP = [].freeze
+      # An explicit receiver reaches neither a private method (a `module_function`'s instance copy among
+      # them) nor, on #746's
+      # reading of an ancestor's unknown include (the receiver's own includes only), a module whose surface
+      # is unknown: one top-level `include` of an undeclared module would otherwise silence
+      # `call.undefined-method` on every receiver in the project.
+      EXPLICIT_RECEIVER_SKIP = %i[private_rbs singleton_function opaque].freeze
+      private_constant :NO_SKIP, :EXPLICIT_RECEIVER_SKIP
+
+      # Whether some `Object` mixin may define `method_name`: the question the silences ask. A bare
+      # top-level call (`receiver: :implicit`, `call.unresolved-toplevel`) counts every answer, an unknown
+      # module's included: such an include is the likeliest source of a bare name, and silencing a typo
+      # there is the cheaper error. A call with a receiver (`receiver: :explicit`, `call.undefined-method`)
+      # counts only a declared, public definition.
+      def may_define?(scope, method_name, receiver:)
+        skip = receiver == :explicit ? EXPLICIT_RECEIVER_SKIP : NO_SKIP
+        !answer(scope, method_name, skip: skip).nil?
+      end
+
+      # Whether a receiver of `class_name` reaches `Object`'s mixins at all: `Object` itself, or an RBS
+      # class the environment orders below it. A `BasicObject` subclass does not; a class the environment
+      # cannot order is not claimed.
+      def reaches_object?(scope, class_name)
+        name = class_name.to_s.delete_prefix("::")
+        return true if name == OWNER
+
+        environment = scope&.environment
+        !environment.nil? && environment.class_ordering(name, OWNER) == :subclass
+      end
+
+      # A project entry (`Object` itself, or a project module mixed into it) answers when it defines the name;
+      # an external one when RBS declares the name on one of the names its spelling can denote (as an instance
+      # method, or as a module's singleton function), and is opaque when none of those names is declared at
+      # all.
+      def answer_for_entry(scope, entry, method_name)
+        unless entry.external?
+          return source_defines?(scope, entry.name, method_name) ? [:source, entry.name] : nil
+        end
+
+        entry.candidates.each do |candidate|
+          definition = Rigor::Reflection.instance_method_definition(candidate, method_name, scope: scope)
+          return [private_definition?(definition) ? :private_rbs : :rbs, candidate, definition] if definition
+          return [:singleton_function, candidate] if singleton_function?(scope, candidate, method_name)
+        end
+        return nil if entry.candidates.any? { |candidate| declared?(scope, candidate) }
+
+        [:opaque, entry.raw.to_s]
+      end
+      private_class_method :answer_for_entry
+
+      def private_definition?(definition)
+        definition.respond_to?(:accessibility) && definition.accessibility == :private
+      end
+      private_class_method :private_definition?
+
+      def singleton_function?(scope, name, method_name)
+        environment = scope.environment
+        return false if environment.nil? || !environment.rbs_module?(name)
+
+        definition = Rigor::Reflection.singleton_method_definition(name, method_name, scope: scope)
+        # Declared on the module itself: its singleton class also answers every `Module` method
+        # (`include`, `name`), which no `include` of it brings to the top level.
+        !definition.nil? && definition.defined_in.to_s.delete_prefix("::") == name
+      end
+      private_class_method :singleton_function?
+
+      # Asked of both tables a project method lands in, as `RbsDispatch#source_declares_through_ancestors?`
+      # does: `discovered_methods` withholds a plain `def` written in another file, which is exactly where a
+      # top-level `include` usually finds its module. The chain already expands each module's own ancestry, so
+      # one entry's own tables are asked.
+      def source_defines?(scope, name, method_name)
+        scope.discovered_method?(name, method_name, :instance) || !scope.user_def_for(name, method_name).nil?
+      end
+      private_class_method :source_defines?
+
+      # The same "is this mixin's surface enumerable" reading `Analysis::CheckRules#known_mixin?` gives a
+      # class's own includes (#746): a project class or module, or an RBS declaration Rigor did not
+      # synthesize to keep a broken signature buildable.
+      def declared?(scope, name)
+        return true if scope.discovered_classes.key?(name)
+        return false unless Rigor::Reflection.rbs_class_known?(name, scope: scope)
+
+        loader = scope.environment&.rbs_loader
+        return true if loader.nil? || !loader.respond_to?(:synthesized_type_names)
+
+        !loader.synthesized_type_names.include?(name)
+      end
+      private_class_method :declared?
+    end
+  end
+end

data/lib/rigor/inference/parameter_inference_collector.rb

@@ -245,13 +245,16 @@ module Rigor
         tables[:discovered_classes] = classes unless classes.empty?
         DISCOVERY_FIELD.each do |index_key, field|
           table = def_index.fetch(index_key)
-          tables[field] = table unless table.empty?
+          tables[field] = table unless table.empty? && !Scope::DiscoveryIndex.paired?(field)
         end
-        tables
-      rescue StandardError
+        # ADR-119 WD1 — the pairs travel together: a pair is dropped only when both halves are empty. A sibling whose
+        # member this collector does not seed completes to that member's empty value, which the base scope holds.
+        Scope::DiscoveryIndex.compact_pairs(tables.merge(def_index.fetch(:siblings)))
+      rescue StandardError => e
         # Discovery is best-effort; a malformed corner of the project must not crash the
-        # protection scan. Without discovery the collector simply resolves fewer call sites.
-        {}
+        # protection scan. Without discovery the collector simply resolves fewer call sites. A broken
+        # walk contract is not such a corner, and an empty seed would hide it.
+        e.is_a?(DeclarationWalk::ContractError) ? raise : {}
       end
 
       DISCOVERY_FIELD = {
@@ -260,7 +263,7 @@ module Rigor
         def_sources: :discovered_def_sources,
         superclasses: :discovered_superclasses,
         header_nestings: :discovered_header_nestings,
-        includes: :discovered_includes,
+        includes: :discovered_includes, unpositioned_mixins: :unpositioned_mixins,
         class_sources: :discovered_class_sources,
         method_visibilities: :discovered_method_visibilities,
         methods: :discovered_methods,
@@ -359,9 +362,7 @@ module Rigor
       end
 
       def lookup_def(scope, class_name, method, kind)
-        table = kind == :singleton ? scope.discovered_singleton_def_nodes : scope.discovered_def_nodes
-        per_class = table[class_name]
-        per_class && per_class[method]
+        scope.def_node_slot(class_name, method, kind)
       end
 
       # The leading required-positional parameters — the ones a call's leading positional arguments

data/lib/rigor/inference/project_patched_methods.rb

@@ -7,9 +7,9 @@ module Rigor
     # ADR-17 § "Inference contract" — project-wide patched-method registry populated by the pre-eval
     # pre-pass (slice 2) from the user's `.rigor.yml` `pre_eval:` list.
     #
-    # Each entry records one `def` declaration the pre-pass observed inside a class / module body. The
-    # dispatcher's `try_project_patched_method` tier consults this registry between the plugin tier and
-    # the dependency-source tier so project-side `lib/core_ext/string_extensions.rb` patches are visible
+    # Each entry records one `def`, `alias` or `alias_method` declaration the pre-pass observed inside a class /
+    # module body. The dispatcher's `try_project_patched_method` tier consults this registry between the plugin
+    # tier and the dependency-source tier so project-side `lib/core_ext/string_extensions.rb` patches are visible
     # to cross-file dispatch.
     #
     # The dispatcher answers `Dynamic[T]` (with a heuristic static facet) when `Entry#return_type` is
@@ -22,8 +22,13 @@ module Rigor
       # the {Analysis::DependencySourceInference::ReturnTypeHeuristic}-extracted static facet (a
       # `Rigor::Type::*`) or `nil` when the heuristic declined. The dispatcher wraps a non-nil
       # `return_type` in `Dynamic[T]`; a `nil` `return_type` falls back to `Dynamic[top]`.
-      Entry = Data.define(:class_name, :method_name, :kind, :source_path, :source_line, :return_type) do
-        def initialize(class_name:, method_name:, kind:, source_path:, source_line:, return_type: nil)
+      #
+      # Issue #1702 — an `alias new old` / `alias_method :new, :old` in a patch is recorded too. When a `def` or
+      # alias earlier in the `pre_eval:` files binds `old`, the alias's entry copies that entry's `return_type` (and
+      # its `alias_of`); otherwise `alias_of` names `old`, a method the class had before the patch, and the
+      # dispatcher answers the alias with what that method answers. `alias_of` is nil for a `def`.
+      Entry = Data.define(:class_name, :method_name, :kind, :source_path, :source_line, :return_type, :alias_of) do
+        def initialize(class_name:, method_name:, kind:, source_path:, source_line:, return_type: nil, alias_of: nil)
           super
         end
       end