rigortype 0.4.1 → 0.4.3

data/lib/rigor/inference/method_dispatcher.rb

@@ -11,6 +11,7 @@ require_relative "dynamic_origin"
 require_relative "flow_tracer"
 require_relative "void_tail_summary"
 require_relative "method_dispatcher/call_context"
+require_relative "method_dispatcher/argument_nodes"
 require_relative "method_dispatcher/constant_folding"
 require_relative "method_dispatcher/literal_string_folding"
 require_relative "method_dispatcher/shape_dispatch"
@@ -18,6 +19,7 @@ require_relative "method_dispatcher/data_folding"
 require_relative "method_dispatcher/struct_folding"
 require_relative "method_dispatcher/rbs_dispatch"
 require_relative "method_dispatcher/iterator_dispatch"
+require_relative "method_dispatcher/arithmetic_sequence_elements"
 require_relative "method_dispatcher/reduce_folding"
 require_relative "method_dispatcher/block_folding"
 require_relative "method_dispatcher/array_to_h_folding"
@@ -38,6 +40,7 @@ require_relative "method_dispatcher/kernel_dispatch"
 require_relative "method_dispatcher/universal_object_dispatch"
 require_relative "method_dispatcher/singleton_mixin_dispatch"
 require_relative "method_dispatcher/method_folding"
+require_relative "method_dispatcher/optional_count"
 
 module Rigor
   module Inference
@@ -101,9 +104,19 @@ module Rigor
       # the tier commits the buffer only if it goes on to answer. See {#try_composite_receiver}.
       def resolve(receiver_type:, method_name:, arg_types:, # rubocop:disable Metrics/AbcSize, Metrics/MethodLength, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity, Metrics/ParameterLists
                   block_type: nil, environment: nil,
-                  call_node: nil, scope: nil, plugin_typed_sink: nil)
+                  call_node: nil, scope: nil, plugin_typed_sink: nil, skip_project_patched: false)
         return nil if receiver_type.nil?
 
+        # Issue #1393 — a `nil` count on `min` / `max` / `min_by` / `max_by` is the no-count call.
+        nil_count = OptionalCount.split(receiver_type, method_name, arg_types, block: !block_type.nil?)
+        if nil_count
+          return resolve_nil_count(nil_count.first, receiver_type: receiver_type, method_name: method_name,
+                                                    block_type: block_type, environment: environment,
+                                                    call_node: call_node, scope: scope,
+                                                    plugin_typed_sink: plugin_typed_sink,
+                                                    skip_project_patched: skip_project_patched)
+        end
+
         # Build the call context once and thread it — unchanged — through every tier
         # (`_DispatchTier#try_dispatch`). The dispatcher's own private fallback tiers still read
         # the positional locals below; only the tier modules consume the context object.
@@ -205,7 +218,10 @@ module Rigor
         # the pre-pass populated `ProjectPatchedMethods` with the `(class, method, kind)` triple;
         # this tier surfaces it as `Dynamic[top]` so the patched call resolves cross-file without
         # `call.undefined-method`.
-        patched_result = try_project_patched_method(receiver_type, method_name, environment)
+        patched_result =
+          unless skip_project_patched
+            try_project_patched_method(receiver_type, method_name, arg_types, block_type, environment)
+          end
         if patched_result
           scope&.record_dynamic_origin(call_node, DynamicOrigin::EXTERNAL_GEM_WITHOUT_RBS)
           return patched_result
@@ -284,6 +300,20 @@ module Rigor
         try_composite_receiver(context)
       end
 
+      # The `nil` part of an optional count dispatches as the no-argument call, the rest as written; a count
+      # that is both answers the union of the two, or declines when either declines. See {OptionalCount}.
+      def resolve_nil_count(rest, **common)
+        return resolve(arg_types: [], **common) if rest.nil?
+
+        # The counted leg runs first: a leg's plugin answer records on the scope (or buffers in the sink, #1101),
+        # and a declining counted leg must not leave the no-argument leg's record behind for a call that answers nil.
+        counted = resolve(arg_types: [rest], **common)
+        return nil if counted.nil?
+
+        without = resolve(arg_types: [], **common)
+        without && Type::Combinator.union(without, counted)
+      end
+
       # ADR-100 WD4 — records the transitive `-> void` provenance when the called method is a
       # discovered project `def` whose {VoidTailSummary} chain ends in an author-declared `-> void`
       # leaf on the same owner. Guards cheapest-first: the internal dispatcher callers nil `scope` /
@@ -614,7 +644,7 @@ module Rigor
       # `def to_url; "hello"; end` patched onto `String` now resolves `s.to_url` to
       # `Dynamic[Nominal[String]]` instead of the pre-3a `Dynamic[Top]`. Falls back to
       # `Dynamic[Top]` when the heuristic declined (non-literal tail expression).
-      def try_project_patched_method(receiver_type, method_name, environment)
+      def try_project_patched_method(receiver_type, method_name, arg_types, block_type, environment)
         registry = environment&.project_patched_methods
         return nil if registry.nil? || registry.empty?
 
@@ -624,9 +654,25 @@ module Rigor
         kind = receiver_type.is_a?(Type::Singleton) ? :singleton : :instance
         entry = registry.lookup(class_name: class_name, method_name: method_name, kind: kind)
         return nil if entry.nil?
-        return Type::Combinator.untyped if entry.return_type.nil?
+        return Type::Combinator.dynamic(entry.return_type) if entry.return_type
+
+        aliased = project_patched_alias_target(entry, receiver_type, arg_types, block_type, environment)
+        aliased ? Type::Combinator.dynamic(aliased) : Type::Combinator.untyped
+      end
 
-        Type::Combinator.dynamic(entry.return_type)
+      # Issue #1702 — an alias in a `pre_eval:` patch whose old name no earlier patch binding defines
+      # (`alias old_plus +` on Integer, or `alias_method :orig_succ, :succ` ahead of the patch's own `def succ`)
+      # names the method the class had before the patch, so it answers what that method answers for the same
+      # arguments, behind the `Dynamic` every patched method carries. The re-entry skips this tier: a later patch
+      # `def` of the old name is not the body the alias copied, and the skip is also what ends an alias cycle. It
+      # carries no call node or scope, so it answers a type and records nothing at the call site.
+      def project_patched_alias_target(entry, receiver_type, arg_types, block_type, environment)
+        return nil if entry.alias_of.nil?
+
+        resolve(
+          receiver_type: receiver_type, method_name: entry.alias_of, arg_types: arg_types,
+          block_type: block_type, environment: environment, skip_project_patched: true
+        )
       end
 
       # ADR-10 slice 2b-ii. Consults the per-run `Analysis::DependencySourceInference::Index`
@@ -847,7 +893,8 @@ module Rigor
       private_constant :STDLIB_SINGLETON_FOLDERS
 
       PRECISE_TIERS_TAIL = Ractor.make_shareable([
-        MethodFolding, ReduceFolding, ArrayToHFolding, HashTransformKeysFolding, BlockFolding
+        MethodFolding, ReduceFolding, ArrayToHFolding, HashTransformKeysFolding, BlockFolding,
+        ArithmeticSequenceElements
       ].freeze)
       private_constant :PRECISE_TIERS_TAIL
 
@@ -1104,14 +1151,23 @@ module Rigor
       # `instance_of?(self)` later as the rule catalogue grows; for now only `class` is handled.
       def try_meta_introspection(receiver_type, method_name, arg_types = [], context = nil)
         case method_name
-        when :class then meta_class(receiver_type)
+        when :class then meta_class(receiver_type, context&.environment)
         when :new then meta_new(receiver_type, arg_types, context)
         end
       end
 
-      def meta_class(receiver_type)
+      def meta_class(receiver_type, environment = nil)
         case receiver_type
-        when Type::Nominal then Type::Combinator.singleton_of(receiver_type.class_name)
+        when Type::Nominal
+          # An instance of module `M` is an instance of some class that includes `M`, never of `M`
+          # itself: `self.class` in `M`'s instance method is that includer, which no RBS type names.
+          # `Dynamic[Class]` keeps the surface every class shares (`name`, `ancestors`) and answers
+          # nothing for the includer's own singleton methods.
+          if environment&.rbs_module?(receiver_type.class_name)
+            return Type::Combinator.dynamic(Type::Combinator.nominal_of("Class"))
+          end
+
+          Type::Combinator.singleton_of(receiver_type.class_name)
         when Type::Constant then constant_metaclass(receiver_type.value)
         end
       end
@@ -1140,7 +1196,7 @@ module Rigor
         set_lift = set_new_lift(receiver_type.class_name, arg_types)
         return set_lift if set_lift
 
-        hash_lift = hash_new_lift(receiver_type.class_name, arg_types)
+        hash_lift = hash_new_lift(receiver_type.class_name, arg_types, context&.call_node)
         return hash_lift if hash_lift
 
         regexp_lift = regexp_new_lift(receiver_type.class_name, arg_types)
@@ -1415,9 +1471,15 @@ module Rigor
       # form (`Hash.new { |h, k| … }`) keep the bare `Nominal[Hash]` answer — the block's value
       # type is not available at this `:new` dispatch site, and conservatively leaving the read
       # as today's behaviour is precision-additive.
-      def hash_new_lift(class_name, arg_types)
+      #
+      # Issue #1812 — a brace-less keyword hash is `Hash#initialize`'s `capacity:` keyword, not the
+      # default (`Hash.new(capacity: 10).default` is `nil`), so it is dropped before counting the
+      # positionals. A braced hash (`Hash.new({ capacity: 10 })`) is a positional and stays the default.
+      def hash_new_lift(class_name, arg_types, call_node = nil)
         return nil unless class_name == "Hash"
-        return nil unless arg_types.size == 1
+
+        arg_types = hash_new_positionals(arg_types, call_node)
+        return nil unless arg_types&.size == 1
 
         default = arg_types.first
         return nil if default.nil?
@@ -1426,6 +1488,23 @@ module Rigor
         Type::Combinator.nominal_of("Hash", type_args: [Type::Combinator.untyped, value])
       end
 
+      # `Hash.new`'s positional argument types: `arg_types` without a trailing brace-less keyword hash. A literal
+      # send (`Hash.send(:new, capacity: 1)`) dispatches with the outer call node, whose arguments are the
+      # selector symbol followed by `arg_types`' own, and is read through that offset. When the node's arguments
+      # correspond otherwise, a sole hash argument may be the keyword hash, so the answer is nil (decline) and the
+      # bare `Hash` stands; any other argument cannot be a keyword hash and is kept.
+      def hash_new_positionals(arg_types, call_node)
+        return arg_types[0...-1] if ArgumentNodes.keyword_hash_last?(call_node, arg_types)
+
+        arguments = call_node.respond_to?(:arguments) ? call_node.arguments&.arguments : nil
+        return arg_types if arguments.nil? || arguments.size == arg_types.size
+        if arguments.size == arg_types.size + 1 && arguments.first.is_a?(Prism::SymbolNode)
+          return arguments.last.is_a?(Prism::KeywordHashNode) ? arg_types[0...-1] : arg_types
+        end
+
+        arg_types.last.is_a?(Type::HashShape) ? nil : arg_types
+      end
+
       # `Range.new(b, e)` / `Range.new(b, e, excl)` — folds to `Constant[Range]` when both
       # endpoints are `Constant[Integer]` or both are `Constant[String]`, and the optional third
       # argument is a `Constant[true/false]`. Nil endpoints (beginless / endless ranges) are not
@@ -1555,13 +1634,16 @@ module Rigor
       # method definition, or selected overload does not provide statically declared block
       # parameter types. Callers MUST treat the empty array as "no information"; the binder
       # falls back to `Dynamic[Top]` for every parameter slot in that case.
+      #
+      # `call_node` lets the overload selector read the call's keyword arguments as keywords (#1727, #1737), as
+      # the return path does; without it they are read positionally.
       def expected_block_param_types(receiver_type:, method_name:, arg_types:, environment: nil,
-                                     scope: nil)
+                                     scope: nil, call_node: nil)
         return [] if receiver_type.nil?
 
         context = CallContext.build(
           receiver: receiver_type, method_name: method_name,
-          args: arg_types, environment: environment, scope: scope
+          args: arg_types, environment: environment, scope: scope, call_node: call_node
         )
         iterator_result = IteratorDispatch.block_param_types(context)
         return iterator_result if iterator_result

data/lib/rigor/inference/module_function_state.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "prism"
+require_relative "../source/literals"
 require_relative "../source/node_children"
 
 module Rigor
@@ -204,7 +205,7 @@ module Rigor
 
       # The Symbol a `:name` or `"name"` literal argument names, or nil.
       def symbol_argument_name(arg)
-        arg.unescaped.to_sym if arg.is_a?(Prism::SymbolNode) || arg.is_a?(Prism::StringNode)
+        Source::Literals.symbol_or_string(arg)
       end
 
       private_class_method :prescan_call, :prescan_eval_call, :symbol_argument_name

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"
@@ -1273,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
 
@@ -1286,7 +1287,7 @@ module Rigor
           when :=== then analyse_case_equality_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)
@@ -1462,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
@@ -1479,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?

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/project_patched_definedness_guard.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require "prism"
+
+require_relative "../source/node_children"
+
+module Rigor
+  module Inference
+    module ProjectPatchedScanner
+      # Finds the `def`s of a `pre_eval:` file written under a definedness guard naming the same method
+      # (`def foo = 1 unless method_defined?(:foo)`): polyfills that run only when nothing bound the name before.
+      module DefinednessGuard
+        DEFINEDNESS_PREDICATES = %i[
+          method_defined? private_method_defined? public_method_defined? protected_method_defined? respond_to?
+        ].freeze
+        INSTANCE_METHOD_LISTS = %i[
+          instance_methods public_instance_methods private_instance_methods protected_instance_methods
+        ].freeze
+        private_constant :DEFINEDNESS_PREDICATES, :INSTANCE_METHOD_LISTS
+
+        module_function
+
+        # The `def` nodes (by identity) that sit on the "name not yet defined" side of a definedness guard naming the
+        # same method: `def foo = 1 unless method_defined?(:foo)`, or the same inside an `unless` / `if !` block.
+        def defs(root)
+          found = {}.compare_by_identity
+          collect_guarded(root, found)
+          found
+        end
+
+        def collect_guarded(node, found)
+          return unless node.is_a?(Prism::Node)
+
+          if node.is_a?(Prism::IfNode) || node.is_a?(Prism::UnlessNode)
+            name, negated = definedness_guard(node.predicate)
+            mark_guarded_defs(undefined_branch(node, negated), name, found) if name
+          end
+          node.rigor_each_child { |child| collect_guarded(child, found) }
+        end
+        private_class_method :collect_guarded
+
+        # `[method_name, negated]` for a predicate like `method_defined?(:m)` / `!respond_to?(:m)`, else nil.
+        def definedness_guard(predicate)
+          predicate = predicate.body if predicate.is_a?(Prism::ParenthesesNode) && predicate.body
+          predicate = predicate.body.first if predicate.is_a?(Prism::StatementsNode) && predicate.body.size == 1
+          if predicate.is_a?(Prism::CallNode) && predicate.name == :! && predicate.receiver
+            name, negated = definedness_guard(predicate.receiver)
+            return name && [name, !negated]
+          end
+          name = guard_method_name(predicate)
+          name && [name, false]
+        end
+        private_class_method :definedness_guard
+
+        def guard_method_name(call)
+          return unless call.is_a?(Prism::CallNode)
+
+          listed = %i[include? member?].include?(call.name)
+          listed &&= call.receiver.is_a?(Prism::CallNode) && INSTANCE_METHOD_LISTS.include?(call.receiver.name)
+          return unless listed || DEFINEDNESS_PREDICATES.include?(call.name)
+
+          arg = call.arguments&.arguments&.first
+          arg.unescaped.to_sym if arg.is_a?(Prism::SymbolNode) || arg.is_a?(Prism::StringNode)
+        end
+        private_class_method :guard_method_name
+
+        # The branch that runs when the guarded name is NOT defined yet.
+        def undefined_branch(node, negated)
+          branch_when_true = node.is_a?(Prism::IfNode) ? node.statements : node.else_clause
+          branch_when_false = node.is_a?(Prism::IfNode) ? node.subsequent : node.statements
+          # The predicate is true when the name is defined (unless negated).
+          negated ? branch_when_true : branch_when_false
+        end
+        private_class_method :undefined_branch
+
+        def mark_guarded_defs(node, name, found)
+          return unless node.is_a?(Prism::Node)
+
+          found[node] = true if node.is_a?(Prism::DefNode) && node.name == name
+          node.rigor_each_child { |child| mark_guarded_defs(child, name, found) } unless node.is_a?(Prism::DefNode)
+        end
+        private_class_method :mark_guarded_defs
+      end
+    end
+  end
+end

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
@@ -31,14 +36,14 @@ module Rigor
       attr_reader :by_key, :write_census
 
       # @param entries — flat list of declarations observed during the pre-pass.
-      #   First-write-wins on `(class_name, method_name, kind)` duplicates so the
+      #   Last-write-wins on `(class_name, method_name, kind)` duplicates, as at runtime (ADR-17); the
       #   `pre-eval.duplicate-declaration` diagnostic emission stays decoupled from registry behaviour.
       # @param write_census — issue #1367: the `pre_eval:` files' {GlobalWriteCensus}, which the `global.*` write
       #   rules join with the project's, since a patch file is loaded ahead of the code it patches.
       def initialize(entries: [], write_census: GlobalWriteCensus::EMPTY)
         @by_key = entries.each_with_object({}) do |entry, acc|
           key = [entry.class_name, entry.method_name, entry.kind]
-          acc[key] ||= entry
+          acc[key] = entry
         end.freeze
         @write_census = write_census.frozen? ? write_census : write_census.dup.freeze
         freeze