rigortype 0.4.7 → 0.4.8

data/lib/rigor/scope.rb

@@ -3,7 +3,8 @@
 require_relative "type"
 require_relative "environment"
 require_relative "scope/discovery_index"
-require_relative "run_scoped_slots"
+require_relative "typing_state"
+require_relative "memo_audit"
 require_relative "scope/resolution_chain"
 require_relative "inference/definer_resolution"
 require_relative "inference/in_effect_refinements"
@@ -17,6 +18,7 @@ require_relative "inference/def_node_resolver"
 # Issue #2608 — read by `MutationWidening` at a remover call, which only an analysis makes; loaded with the engine
 # so the engine-free value layer that requires `MutationWidening` stays as small as it was.
 require_relative "inference/remover_narrowing"
+require_relative "inference/alias_mutation_floor"
 
 module Rigor
   # Immutable analyzer scope: holds local-variable bindings and a reference to the surrounding Environment. State
@@ -157,7 +159,13 @@ module Rigor
     # renames the foreign declaration. `published_constant_alias_names` holds the last segments of exactly
     # those aliases, and matching on the last segment over-answers in the WITHHOLDING direction, which is the
     # safe one.
+    #
+    # Issue #3199 — the answer turns on another file's publication of the last segment, so the question records
+    # the ADR-46 `constant:<segment>` name edge itself, whatever it answers. The guard asks it about spellings no
+    # typing step reads (a `defined?(B::X)` probe, a callee body the one hop scans), and an edge left to the read
+    # would let an `--incremental` run keep a verdict the moved publication no longer earns.
     def published_constant?(name)
+      Analysis::DependencyRecorder.read_last_segment(:constant, name) if Analysis::DependencyRecorder.active?
       names = @discovery.published_constant_names
       return true if published_constant_alias?(name)
       return false if names.empty?
@@ -287,6 +295,32 @@ module Rigor
                      :EMPTY_PUBLISHED_CONSTANT_IVARS, :EMPTY_REPEATED_OR_WRITES,
                      :EMPTY_CONSTANT_NARROWINGS, :EMPTY_GUARD_RECORDS, :EMPTY_BOT_GUARD_CLASSES
 
+    # ADR-129 WD1 — the four advisory tables are bound Tables: each is an identity Hash one file's scopes share by
+    # reference (a fresh body scope may start its own; {#with_isolated_side_tables} copies them), so a journal record
+    # names the store beside the node. Every entry read and write goes through the methods below, which log it while a
+    # capture is open; handing a store to a new Scope is not an entry read.
+    DYNAMIC_ORIGINS = TypingState.table(
+      :dynamic_origins,
+      bound: true,
+      reason: "node => DynamicOrigin cause; typing records it and reads it back for receiver provenance"
+    )
+    VOID_ORIGINS = TypingState.table(
+      :void_origins, bound: true, reason: "node => VoidOrigin site; recorded by dispatch, read by the value-use rule"
+    )
+    PLUGIN_TYPED_CALLS = TypingState.table(
+      :plugin_typed_calls, bound: true, reason: "node => true where a plugin's dynamic_return answered the call"
+    )
+    OPTIMISTIC_ORIGINS = TypingState.table(
+      :optimistic_origins,
+      bound: true,
+      reason: "node => OptimisticOrigin cause; typing records it and reads it back to keep a value nil-free"
+    )
+    private_constant :DYNAMIC_ORIGINS, :VOID_ORIGINS, :PLUGIN_TYPED_CALLS, :OPTIMISTIC_ORIGINS
+    TypingState.store_field(self, :@dynamic_origins, DYNAMIC_ORIGINS)
+    TypingState.store_field(self, :@void_origins, VOID_ORIGINS)
+    TypingState.store_field(self, :@plugin_typed_calls, PLUGIN_TYPED_CALLS)
+    TypingState.store_field(self, :@optimistic_origins, OPTIMISTIC_ORIGINS)
+
     class << self
       def empty(environment: Environment.default, source_path: nil)
         new(environment: environment, locals: {}.freeze,
@@ -295,16 +329,33 @@ module Rigor
     end
 
     def record_dynamic_origin(node, cause)
+      TypingState.current.log_bound_write(DYNAMIC_ORIGINS, @dynamic_origins, node, cause)
       @dynamic_origins[node] = cause
       self
     end
 
+    # The {Inference::DynamicOrigin} cause recorded at `node`, or nil (ADR-129: a logged Table read).
+    def dynamic_origin(node)
+      log_advisory_read(DYNAMIC_ORIGINS, @dynamic_origins, node)
+    end
+
+    # The {Inference::VoidOrigin} recorded at `node`, or nil (ADR-129: a logged Table read).
+    def void_origin(node)
+      log_advisory_read(VOID_ORIGINS, @void_origins, node)
+    end
+
+    # The {Inference::OptimisticOrigin} cause recorded at `node`, or nil (ADR-129: a logged Table read).
+    def optimistic_origin(node)
+      log_advisory_read(OPTIMISTIC_ORIGINS, @optimistic_origins, node)
+    end
+
     # ADR-100 WD3 — records that the value introduced at `node` (a call node) is a `top` recovered from an
     # author-declared `-> void` return, keyed by the origin site (`origin`, an {Inference::VoidOrigin}). The
     # value-context check rule `static.value-use.void` consumes this table. Mirrors {#record_dynamic_origin}
     # exactly: identity-keyed advisory metadata, mutated in place on the shared table (threaded by reference
     # through `#join` / `#rebuild`), excluded from `==` / `hash`, so it never forks a flow-dedup or cache key.
     def record_void_origin(node, origin)
+      TypingState.current.log_bound_write(VOID_ORIGINS, @void_origins, node, origin)
       @void_origins[node] = origin
       self
     end
@@ -317,17 +368,22 @@ module Rigor
     # identity-keyed advisory metadata on a table threaded by reference through `#join` / `#rebuild`,
     # excluded from `==` / `hash`, so it never forks a flow-dedup or cache key.
     def record_plugin_typed_call(node)
+      TypingState.current.log_bound_write(PLUGIN_TYPED_CALLS, @plugin_typed_calls, node, true)
       @plugin_typed_calls[node] = true
       self
     end
 
     # Issue #653 — whether a plugin answered the return type for `node` on this run.
     def plugin_typed_call?(node)
-      @plugin_typed_calls.key?(node)
+      !log_advisory_read(PLUGIN_TYPED_CALLS, @plugin_typed_calls, node).nil?
     end
 
-    # Every keyword past the 31st takes CRuby's allocating unspecified-keywords path when omitted with a non-literal
-    # default; see the note at {#rebuild} before adding a field.
+    # Every keyword past the 31st (`opaque_block_self`, `block_self_unknown`) must keep a literal default. A keyword at
+    # that index with a non-literal default makes a call that omits it allocate CRuby's unspecified-keywords record
+    # during argument setup, and on CRuby 4.0 a GC started by that allocation frees the values already moved into the
+    # keyword locals (ruby/ruby Bug #22500, issue #2850): `Scope.new` stored a freed `match_frame`.
+    # `spec/rigor/keyword_gc_safety_spec.rb` holds every method under `lib/` and `plugins/*/lib` to this. See the note
+    # at {#rebuild} before adding a field.
     def initialize( # rubocop:disable Metrics/AbcSize, Metrics/MethodLength -- one keyword and assignment per field
       environment:, locals:,
       fact_store: Analysis::FactStore.empty,
@@ -342,8 +398,6 @@ module Rigor
       published_constant_sourced: EMPTY_PUBLISHED_CONSTANT_SOURCED,
       source_path: nil,
       struct_fold_safe_locals: EMPTY_FOLD_SAFE,
-      opaque_block_self: false,
-      block_self_unknown: false,
       singleton_class_body: false,
       lexical_nesting: nil,
       dynamic_origins: {}.compare_by_identity,
@@ -360,7 +414,10 @@ module Rigor
       constant_narrowings: EMPTY_CONSTANT_NARROWINGS,
       guard_records: EMPTY_GUARD_RECORDS,
       bot_guard_classes: EMPTY_BOT_GUARD_CLASSES,
-      declared_refinements: Inference::InEffectRefinements::EMPTY
+      declared_refinements: Inference::InEffectRefinements::EMPTY,
+      # Literal defaults only from here on; see the note above.
+      opaque_block_self: false,
+      block_self_unknown: false
     )
       @environment = environment
       @locals = locals
@@ -403,10 +460,20 @@ module Rigor
     # nil-freeness is a property of its class. Mirrors {#dynamic_origins} / {#void_origins}: advisory
     # metadata, ignored by `==` / `hash`, and never varying a flow decision on its own.
     def record_optimistic_origin(node, cause)
+      TypingState.current.log_bound_write(OPTIMISTIC_ORIGINS, @optimistic_origins, node, cause)
       @optimistic_origins[node] = cause
       self
     end
 
+    # The entry of the advisory table `store` (the bound Table `slot`'s) at `node`, or nil, logged as a Table read: a
+    # key the store does not hold logs {TypingState::ABSENT}, so a recorded nil and a miss differ.
+    def log_advisory_read(slot, store, node)
+      value = store.fetch(node, TypingState::ABSENT)
+      TypingState.current.log_bound_read(slot, store, node, value)
+      TypingState::ABSENT.equal?(value) ? nil : value
+    end
+    private :log_advisory_read
+
     # Issue #1703 — this scope with private copies of the identity-keyed side tables (dynamic, void and optimistic
     # origins, plugin-typed calls), so a second walk from it — the `key?`-guarded re-walk — records into its own
     # tables and never into the ones the file's analysis reads.
@@ -639,9 +706,36 @@ module Rigor
       rebuild(opaque_block_self: true, block_self_unknown: true)
     end
 
+    # Issue #2861 — the {#block_self_unknown?} value a block whose yielding call provably runs it under the
+    # caller's own `self` ({Inference::SelfPreservingBlock}) is entered with, when the caller's `self` is not
+    # already unmodelled. It reads as unknown everywhere `true` does, so issue #1717's explicit-`self` exemption is
+    # unchanged; what it withholds is the #316 opaque mark, and it tells a block nested beneath it that it does
+    # not sit under an index walk ({#walked_block_self_unknown?}).
+    PRESERVED_BLOCK_SELF = :preserved
+
+    # Issue #2861 — the entry for a block {Inference::SelfPreservingBlock} proves runs under the caller's `self`
+    # (`rows.map { … }`, `5.times { … }`). Ruby gives the block the `self` the call site has, so the block is as
+    # opaque as the scope around it and no more: it keeps whatever #316 mark the caller's scope carries and adds
+    # none, so a cross-file top-level `def` binds there exactly where it binds beside the call
+    # ({#bindable_top_level_def_for}). A caller's unknown-`self` mark of `true` or {PRESERVED_BLOCK_SELF} is kept as
+    # it is (no rebuild); a {REFINEMENT_BLOCK_SELF} one is not, since the block's `self` is not the refinement module
+    # the mark describes.
+    def entering_self_preserving_block
+      return self if @block_self_unknown == true || @block_self_unknown == PRESERVED_BLOCK_SELF
+
+      rebuild(block_self_unknown: PRESERVED_BLOCK_SELF)
+    end
+
     # True when this scope sits inside a block whose `self` is unmodelled ({#entering_opaque_block}).
     def opaque_block_self? = @opaque_block_self
 
+    # Issue #2861 — true where the unknown-`self` mark came from the index walk or a value-position block
+    # ({#with_block_self_unknown}) rather than a block entry: the mark is set, the #316 one is not, and it is not
+    # a {PRESERVED_BLOCK_SELF} entry's. A block nested in such a scope keeps the #316 mark off (issue #1717).
+    def walked_block_self_unknown?
+      !!@block_self_unknown && !@opaque_block_self && @block_self_unknown != PRESERVED_BLOCK_SELF
+    end
+
     # Issue #1717 — true when this scope sits in a block whose `self` the engine does not know, so an explicit
     # `self.m` there is no evidence `m` is missing: the yielding method may `instance_exec` the block on another
     # object. Read ONLY by `call.undefined-method`'s explicit-`self` exemption, and kept apart from
@@ -897,6 +991,56 @@ module Rigor
       @declaration_sourced.include?([:inferred_param, name.to_sym])
     end
 
+    # Issue #2656 — stamp the gradual-narrowing mark on the local `name`: a class guard narrowed it from a `Dynamic`
+    # value, so its `Nominal` reading is the guard's, not a contract the value was checked against. Rides the ADR-58
+    # side-mark machinery under a distinct `:gradual_narrowing` kind, as `:inferred_param` does: the displayed type
+    # stays the narrowed `Nominal` (dispatch, `call.undefined-method` and `call.wrong-arity` read it), and only
+    # `call.argument-type-mismatch` consults the mark ({Analysis::CheckRules::DeclarationSourcedGuard.gradual_narrowed?}).
+    # Like the `:local` mark it is dropped by `with_local` and intersected by `join`. Applied after the binding.
+    def with_gradual_narrowing_mark(name)
+      marks = add_declaration_sourced(:gradual_narrowing, name)
+      return self if marks.equal?(@declaration_sourced)
+
+      marks = (marks.dup << GRADUAL_HINT).freeze unless marks.include?(GRADUAL_HINT)
+      rebuild(declaration_sourced: marks)
+    end
+
+    # Issue #2656 — a ref stamped beside every gradual-narrowing mark, so {#gradual_narrowing_names} can answer "none"
+    # with one hash lookup instead of a walk of the set, which the ADR-67 marks keep non-empty in most bodies. It is a
+    # hint: a drop leaves it, and the walk then finds no mark; a join keeps it only where both arms carry it.
+    GRADUAL_HINT = [:gradual_narrowing_hint].freeze
+    private_constant :GRADUAL_HINT
+
+    # Issue #2656 — this scope without the gradual-narrowing mark of every local `block_node` writes: a block may run
+    # again after its own write (`loop do mode(x); x = "zz".dup; end`), and its entry does not see that back edge, so
+    # a mark from before the block must not reach a read the write may precede. Zero-alloc when no local is marked.
+    def entering_block_without_gradual_marks(block_node)
+      names = gradual_narrowing_names
+      return self if names.empty?
+
+      written = Inference::OperandEffects.written_variables(block_node).map(&:to_sym)
+      dropped = names.reduce(@declaration_sourced) do |marks, name|
+        written.include?(name) ? drop_gradual_narrowing_mark(marks, name) : marks
+      end
+      dropped.equal?(@declaration_sourced) ? self : rebuild(declaration_sourced: dropped)
+    end
+
+    # Issue #2656 — the locals carrying the gradual-narrowing mark, empty when none does.
+    def gradual_narrowing_names
+      return EMPTY_GRADUAL_NAMES unless @declaration_sourced.include?(GRADUAL_HINT)
+
+      @declaration_sourced.filter_map { |ref| ref[1] if ref[0] == :gradual_narrowing }
+    end
+    EMPTY_GRADUAL_NAMES = [].freeze
+    private_constant :EMPTY_GRADUAL_NAMES
+
+    # Issue #2656 — true when the local `name`'s binding is a class guard's narrowing of a `Dynamic` value.
+    def gradual_narrowing?(name)
+      return false if @declaration_sourced.empty?
+
+      @declaration_sourced.include?([:gradual_narrowing, name.to_sym])
+    end
+
     def with_cvar(name, type)
       rebuild(cvars: @cvars.merge(name.to_sym => type).freeze)
     end
@@ -1280,12 +1424,33 @@ module Rigor
     # a file that starts or stops defining it re-analyses the reader (issue #1459's `defines:` edge).
     def project_method_name?(method_name)
       Analysis::DependencyRecorder.read_name(:defines, method_name) if Analysis::DependencyRecorder.active?
-      table = (Thread.current[PROJECT_METHOD_NAMES_KEY] ||= ObjectSpace::WeakKeyMap.new)
-      return true if (table[@discovery] ||= collect_project_method_names).include?(method_name.to_sym)
+      return true if project_method_names.include?(method_name.to_sym)
 
       false
     end
 
+    # The name set {#project_method_name?} reads, held per discovery index. ADR-129 G2: a hit is checked against a
+    # fresh collection under `RIGOR_MEMO_AUDIT=1`, and an audit recomputation bypasses the table.
+    def project_method_names
+      return collect_project_method_names if memo_audit_bypass?
+
+      table = TypingState.current.weak_key_map(PROJECT_METHOD_NAMES)
+      names = table[@discovery]
+      if names.nil?
+        return table[@discovery] = Inference::MemoAudit.key_audit("project method names") do
+          collect_project_method_names
+        end
+      end
+
+      Inference::MemoAudit.check("project method names", names, :discovery) { collect_project_method_names }
+    end
+    private :project_method_names
+
+    # ADR-129 G2 — true while a MemoAudit recomputation runs: the memos wired here are then bypassed, neither read
+    # nor written. One boolean check when the audit is off.
+    def memo_audit_bypass? = Inference::MemoAudit.enabled? && Inference::MemoAudit.suspended?
+    private :memo_audit_bypass?
+
     def collect_project_method_names
       names = Set.new
       [@discovery.discovered_methods, @discovery.discovered_def_nodes, @discovery.discovered_singleton_def_nodes,
@@ -1296,9 +1461,13 @@ module Rigor
     end
     private :collect_project_method_names
 
-    # A run-scoped slot ({RunScopedSlots}): emptied when a run ends, so an edited project is read afresh.
-    PROJECT_METHOD_NAMES_KEY = RunScopedSlots.register(:__rigor_project_method_names)
-    private_constant :PROJECT_METHOD_NAMES_KEY
+    # ADR-129 WD1 — a run-scoped Memo ({TypingState}): emptied when a run ends, so an edited project is read afresh.
+    PROJECT_METHOD_NAMES = TypingState.memo(
+      :project_method_names,
+      run_scoped: true, audit: "project method names",
+      reason: "a WeakKeyMap keyed on the discovery index; the name set reads only its tables"
+    )
+    private_constant :PROJECT_METHOD_NAMES
 
     def record_discovered_method(class_name, method_name)
       record_class_dependency(class_name)
@@ -1352,6 +1521,9 @@ module Rigor
     def user_instance_def_owners(method_name)
       Analysis::DependencyRecorder.read_name(:defines, method_name) if Analysis::DependencyRecorder.active?
       name = method_name.to_sym
+      # `each` with a lazily built array, not `filter_map`: this runs once per call on every discovered class, and
+      # `Hash#filter_map` allocates a `[key, value]` pair per entry (#2895 cost 3.35% of the release gate's
+      # allocations that way).
       owners = nil
       @discovery.discovered_def_nodes.each do |class_name, defs|
         next unless defs.key?(name) && class_name != Inference::ScopeIndexer::TOP_LEVEL_DEF_KEY
@@ -1540,18 +1712,31 @@ module Rigor
     # call's literal name and a def in a block. Held by the table's identity, as {#toplevel_definition_rows} is.
     def deferred_definition_names
       ranges = @discovery.discovered_deferred_ranges
-      slots = (Thread.current[DEFERRED_NAMES_KEY] ||= [])
+      return collect_deferred_definition_names(ranges) if memo_audit_bypass?
+
+      state = TypingState.current
+      slots = (state[DEFERRED_NAMES] ||= [])
       slot = slots.find { |entry| entry[0].equal?(ranges) }
-      return slot[1] if slot
+      if slot
+        return Inference::MemoAudit.check("deferred definition names", slot[1], :ranges) do
+          collect_deferred_definition_names(ranges)
+        end
+      end
 
+      names = Inference::MemoAudit.key_audit("deferred definition names") { collect_deferred_definition_names(ranges) }
+      slots.unshift([ranges, names]).slice!(2..)
+      names
+    end
+    private :deferred_definition_names
+
+    def collect_deferred_definition_names(ranges)
       names = Set.new
       ranges.each_value do |entries|
         entries.each { |(_start, _finish, name, kind, owner)| names << name if name && kind.nil? && owner.nil? }
       end
-      slots.unshift([ranges, names.freeze]).slice!(2..)
-      names
+      names.freeze
     end
-    private :deferred_definition_names
+    private :collect_deferred_definition_names
 
     # Issue #2336 — {#module_function_def?}'s `:both` reading for a def in any file: whether `def_node`, an instance
     # def of `owner`, is a module function by a deferred-range row over it (`module_function def x`, or a bare
@@ -1571,10 +1756,24 @@ module Rigor
     # a singleton row. Held by the table's identity (a file's merged copy and the seed), released with the run.
     def toplevel_definition_rows
       ranges = @discovery.discovered_deferred_ranges
-      slots = (Thread.current[TOPLEVEL_ROWS_KEY] ||= [])
+      return collect_toplevel_definition_rows(ranges) if memo_audit_bypass?
+
+      state = TypingState.current
+      slots = (state[TOPLEVEL_ROWS] ||= [])
       slot = slots.find { |entry| entry[0].equal?(ranges) }
-      return slot[1] if slot
+      if slot
+        return Inference::MemoAudit.check("toplevel definition rows", slot[1], :ranges) do
+          collect_toplevel_definition_rows(ranges)
+        end
+      end
 
+      rows = Inference::MemoAudit.key_audit("toplevel definition rows") { collect_toplevel_definition_rows(ranges) }
+      slots.unshift([ranges, rows]).slice!(2..)
+      rows
+    end
+    private :toplevel_definition_rows
+
+    def collect_toplevel_definition_rows(ranges)
       rows = Hash.new(0)
       ranges.each_value do |entries|
         entries.each do |(_start, _finish, name, kind, owner)|
@@ -1583,30 +1782,55 @@ module Rigor
           rows[name] = kind == :singleton || rows[name] == MAIN_SINGLETON_ROWS ? MAIN_SINGLETON_ROWS : rows[name] + 1
         end
       end
-      slots.unshift([ranges, rows.freeze]).slice!(2..)
-      rows
+      rows.freeze
     end
-    private :toplevel_definition_rows
+    private :collect_toplevel_definition_rows
 
     # The names an `alias` statement or `alias_method` call introduces, from the global write census; held by the
     # census's identity as {#toplevel_definition_rows} is.
     def method_alias_names
       census = @discovery.discovered_global_write_census
-      slots = (Thread.current[METHOD_ALIASES_KEY] ||= [])
+      return collect_method_alias_names(census) if memo_audit_bypass?
+
+      state = TypingState.current
+      slots = (state[METHOD_ALIASES] ||= [])
       slot = slots.find { |entry| entry[0].equal?(census) }
-      return slot[1] if slot
+      if slot
+        return Inference::MemoAudit.check("method alias names", slot[1], :census) { collect_method_alias_names(census) }
+      end
 
-      names = census.each_with_object(Set.new) { |entry, acc| acc << entry[1] if entry[0] == :method_alias }.freeze
+      names = Inference::MemoAudit.key_audit("method alias names") { collect_method_alias_names(census) }
       slots.unshift([census, names]).slice!(2..)
       names
     end
     private :method_alias_names
 
+    def collect_method_alias_names(census)
+      census.each_with_object(Set.new) { |entry, acc| acc << entry[1] if entry[0] == :method_alias }.freeze
+    end
+    private :collect_method_alias_names
+
     MAIN_SINGLETON_ROWS = -1
-    TOPLEVEL_ROWS_KEY = RunScopedSlots.register(:__rigor_toplevel_definition_rows)
-    METHOD_ALIASES_KEY = RunScopedSlots.register(:__rigor_method_alias_names)
-    DEFERRED_NAMES_KEY = RunScopedSlots.register(:__rigor_deferred_definition_names)
-    private_constant :MAIN_SINGLETON_ROWS, :TOPLEVEL_ROWS_KEY, :METHOD_ALIASES_KEY, :DEFERRED_NAMES_KEY
+    # ADR-129 WD1 — three run-scoped Memos, each a two-entry list of `[table, derived]` held by the identity of the
+    # table the derived value reads (the deferred ranges, or the global write census).
+    TOPLEVEL_ROWS = TypingState.memo(
+      :toplevel_definition_rows,
+      run_scoped: true, audit: "toplevel definition rows",
+      reason: "[deferred ranges, rows] entries keyed on the identity of the ranges table, the only input the rows read"
+    )
+    METHOD_ALIASES = TypingState.memo(
+      :method_alias_names,
+      run_scoped: true, audit: "method alias names",
+      reason: "[census, names] entries keyed on the identity of the global write census, the only input the names " \
+              "read"
+    )
+    DEFERRED_NAMES = TypingState.memo(
+      :deferred_definition_names,
+      run_scoped: true, audit: "deferred definition names",
+      reason: "[deferred ranges, names] entries keyed on the identity of the ranges table, the only input the names " \
+              "read"
+    )
+    private_constant :MAIN_SINGLETON_ROWS, :TOPLEVEL_ROWS, :METHOD_ALIASES, :DEFERRED_NAMES
 
     # Issue #316 — the CONFIDENCE-GATED companion of {#top_level_def_for}, and the only accessor the type
     # inference may bind through. {#top_level_def_for} stays unrestricted because it also serves the
@@ -1847,6 +2071,14 @@ module Rigor
       @discovery.discovered_includes[class_name.to_s] || []
     end
 
+    # Issue #2986 — the modules `class_name` prepends, as written, in search order: the prepended part of
+    # {#includes_of}, which lists them ahead of the included ones. An ActiveSupport::Concern's `prepended do … end`
+    # block runs for a prepend edge only, and its `included do … end` block for an include edge only.
+    def prepends_of(class_name)
+      record_class_dependency(class_name) if Analysis::DependencyRecorder.active?
+      @discovery.discovered_prepends[class_name.to_s] || EMPTY_PREPENDS
+    end
+
     # Issue #898 — the module names `extend`ed onto `class_name`'s SINGLETON, as written, gathered up the
     # as-written superclass chain because a singleton class inherits its superclass's singleton class
     # (`class Base; extend Comparable; end; class Widget < Base; end` leaves `Widget.is_a?(Comparable)`
@@ -1913,6 +2145,7 @@ module Rigor
       end
       return found if found
 
+      chain.record_external_absence
       chain.truncated? ? ancestor_walk_gave_up : [nil, nil]
     end
 
@@ -1952,6 +2185,7 @@ module Rigor
       end
       return found if found
 
+      chain.record_external_absence
       chain.truncated? ? ancestor_walk_gave_up : [nil, nil]
     end
 
@@ -2035,6 +2269,8 @@ module Rigor
         discovered_method?(entry.name, method_name, entry.side == :singleton ? :singleton : kind_for(kind))
       end
       return true if found
+
+      record_discovered_miss(chain, method_name) if Analysis::DependencyRecorder.active?
       # Budget exhaustion is uncertainty, not absence: answering "not declared" here would hand a
       # `call.undefined-method` a fired verdict it has no evidence for. Suppress and record the hit.
       return false unless chain.truncated?
@@ -2043,6 +2279,28 @@ module Rigor
       true
     end
 
+    # Issue #2689 — the ADR-46 negative edges of a discovery-walk miss: the answer is "no project entry on the chain
+    # defines it", so a later edit that defines it on any of them, or a new file that reopens one of them (and may
+    # change the chain, `include` a module that defines it), turns it. Each project entry files the `method:` key
+    # `Incremental.appeared_symbols` emits for that definition (`Name.method` for a class object's own side,
+    # `Name#method` for an instance-chain entry and for a module on the singleton chain, which answers with its
+    # instance methods) and the `class:` key a declaring file appearing fires — the edges the def walk files for the
+    # same miss (`#user_def_for` per entry, `ResolutionChain#settle` for the classes). A hit files none: existence is
+    # a union, so no other entry gaining the method can turn a found answer.
+    # An external entry (an ancestor declared with no methods, or not yet) files its `class:` key
+    # ({ResolutionChain#record_external_absence}), as the def walks do on a miss.
+    def record_discovered_miss(chain, method_name)
+      chain.record_external_absence
+      chain.entries.each do |entry|
+        next if entry.external?
+
+        separator = entry.side == :singleton ? "." : "#"
+        Analysis::DependencyRecorder.read_missing(:method, "#{entry.name}#{separator}#{method_name}")
+        Analysis::DependencyRecorder.read_missing(:class, entry.last_segment)
+      end
+    end
+    private :record_discovered_miss
+
     # A module entry on the singleton chain answers with its INSTANCE methods; on the instance chain, the
     # caller's kind stands.
     def kind_for(kind) = kind == :singleton ? :instance : kind
@@ -2367,8 +2625,9 @@ module Rigor
     # against THIS scope's discovery index (so cross-file dispatches in the body resolve). The incremental
     # session re-drives a declaration-stable changed callee at each previously-observed call key to prove its
     # return is unchanged before skipping its symbol dependents.
-    def user_method_return(def_node, receiver, arg_types)
-      Inference::ExpressionTyper.new(scope: self).return_type_for(def_node, receiver, arg_types)
+    def user_method_return(def_node, receiver, arg_types, positionals_unknown: false)
+      typer = Inference::ExpressionTyper.new(scope: self)
+      typer.return_type_for(def_node, receiver, arg_types, positionals_unknown: positionals_unknown)
     end
 
     # Statement-level evaluation: returns the pair `[type, scope']` where `type` is what the node produces and
@@ -2465,9 +2724,10 @@ module Rigor
     # field indexed by each keyword's position among ALL the method's keywords, required and optional
     # (`VM_KW_SPECIFIED_BITS_MAX`, 31); a keyword past that index whose default is not a literal makes every call that
     # omits it allocate the record instead. A 32nd keyword here did that on every scope transition, about 1% of an
-    # analysis's allocations (issue #2555). `#initialize` is already past the index: `bot_guard_classes` and
-    # `declared_refinements` take the allocating path whenever a caller omits them. The next Scope field crosses it in
-    # this method again, so it needs a positional slot or a restructuring, not a 32nd keyword.
+    # analysis's allocations (issue #2555). On CRuby 4.0 that allocation is also unsafe: a GC it starts frees the
+    # values already moved into the keyword locals (ruby/ruby Bug #22500, issue #2850). `#initialize` is past the index
+    # and keeps literal defaults there for that reason. The next Scope field crosses it in this method again, so it
+    # needs a positional slot or a restructuring, not a 32nd keyword.
     def rebuild(
       construction_facts = @construction_facts,
       locals: @locals, fact_store: @fact_store, self_type: @self_type,
@@ -2892,6 +3152,7 @@ module Rigor
     # beside it ({#with_global_copy_marks}).
     def drop_local_declaration_marks(name)
       dropped = drop_declaration_sourced_for(:local, name)
+      dropped = drop_gradual_narrowing_mark(dropped, name)
       return dropped if dropped.equal?(@declaration_sourced)
 
       name = name.to_sym
@@ -2900,6 +3161,18 @@ module Rigor
       dropped.dup.delete_if { |ref| ref[0] == :global_copy && ref[1] == name }.freeze
     end
 
+    # `marks` without the local `name`'s `:gradual_narrowing` mark (issue #2656); `marks` itself when it has none.
+    def drop_gradual_narrowing_mark(marks, name)
+      return marks if marks.empty?
+
+      ref = [:gradual_narrowing, name.to_sym]
+      return marks unless marks.include?(ref)
+
+      dropped = marks.dup
+      dropped.delete(ref)
+      dropped.freeze
+    end
+
     def add_guard_record(key, pre_guard)
       return @guard_records if @guard_records.key?(key)