rigortype 0.4.7 → 0.4.8

data/lib/rigor/reflection/declaration_collectors.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require "prism"
+
+# Not required on its own: `rigor/inference/declaration_walk` loads it once the walk exists, and
+# {Reflection.class_declarations_in} loads that entry point on first use. Keeping the walk out of `Reflection`'s own
+# load keeps the engine-free paths engine-free (ADR-104).
+module Rigor
+  module Reflection
+    # The walk's collector behind {.class_declarations_in}; the plugin never sees it.
+    class DeclarationCollector
+      include Inference::DeclarationWalk::Collector
+
+      EMPTY_NESTING = [].freeze
+
+      attr_reader :classes
+
+      def initialize
+        @classes = []
+      end
+
+      def on_declaration(node, context, body_context)
+        if node.is_a?(Prism::ClassNode)
+          name = body_context.prefix.join("::")
+          @classes << ClassDeclaration.new(name: name, nesting: frozen_nesting(context), node: node) unless name.empty?
+        end
+        Inference::DeclarationWalk::DESCEND
+      end
+
+      private
+
+      # The walk's chain, frozen: the root's `[]` is one array shared by every top-level declaration.
+      def frozen_nesting(context)
+        nesting = context.nesting || EMPTY_NESTING
+        nesting.frozen? ? nesting : nesting.dup.freeze
+      end
+    end
+
+    # {DeclarationCollector} that also forwards every call. A subclass, because the walk dispatches only the events a
+    # collector's class overrides, so a classes-only run pays for no call event.
+    class DeclarationCallCollector < DeclarationCollector
+      def initialize(on_call)
+        super()
+        @on_call = on_call
+      end
+
+      def on_call(node, context)
+        owner = context.prefix.join("::")
+        @on_call.call(DeclaredCall.new(node: node, owner: owner.empty? ? nil : owner))
+        Inference::DeclarationWalk::DESCEND
+      end
+    end
+    private_constant :DeclarationCollector, :DeclarationCallCollector
+  end
+end

data/lib/rigor/reflection/declarations.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require "prism"
+
+module Rigor
+  # {Reflection}'s per-file declaration walk for plugins (ADR-128, #2708): {.class_declarations_in} answers which
+  # classes a parsed file declares under their `Module.nesting`-correct names, and hands each call the walk visits
+  # to a plugin together with the class or module its position reaches. It replaces a plugin's own
+  # `DeclarationWalk::Collector`, so the walk's context, its control constants and its collector protocol stay
+  # internal.
+  module Reflection
+    # One `class` header of a file, as {.class_declarations_in} reports it.
+    #
+    # - `name` — the qualified name the header's body is keyed under (`"Admin::User"` for `class User` in
+    #   `module Admin`, and for `class Admin::User`); never empty.
+    # - `nesting` — `Module.nesting` where the header is written, innermost first, not counting the class itself
+    #   (`["Admin"]` for `class User` in `module Admin`; `[]` at the top level). Frozen.
+    # - `node` — the `Prism::ClassNode`, for its `superclass` and `body`.
+    ClassDeclaration = Data.define(:name, :nesting, :node)
+
+    # One call the walk visited, as {.class_declarations_in} yields it.
+    #
+    # - `node` — the `Prism::CallNode`.
+    # - `owner` — the qualified name of the innermost `class` / `module` the call is lexically inside, or nil where
+    #   none is (the top level, or below a bare header in a `class << self` body).
+    DeclaredCall = Data.define(:node, :owner)
+
+    module_function
+
+    # ADR-128, #2708 — the classes a parsed file declares, in the order their headers are written. A class
+    # reopened in the file appears once per header. A `module`, a `class << self` and a class no name reaches
+    # (`Class.new { … }`, a header below `class << self`) are not reported.
+    #
+    # With a block, the walk also yields a {DeclaredCall} for the calls the engine's declaration walk visits, in
+    # source order, outer calls before the calls inside them. Those are the calls in statements and in the bodies of
+    # `class` / `module` / `class << self` / blocks, at any depth. The owner is lexical, not `self`: a call in
+    # `class << self` or in a `Class.new { … }` block reports the class around it.
+    #
+    # The block does not see every call node of the file. The walk does not enter, so the block never sees:
+    #
+    # - a class or module header's own expressions: the superclass (`class Foo < Struct.new(:a)`) and the constant
+    #   path (`class foo::Bar`);
+    # - the factory call a constant write binds (`K = Class.new { … }`), whose receiver, arguments and block body the
+    #   walk does enter;
+    # - the tail of such a write (`K = Class.new { … }.freeze` yields what is inside the block, not `freeze`), and
+    #   the constant-path parent of a write target (`P` in `P::K = …`).
+    #
+    # `root` is a `Prism::Node`, typically `Prism.parse(source).value`.
+    def class_declarations_in(root, &on_call)
+      # Loaded on first use, not with `Reflection`: the walk heads the analysis engine, which the engine-free
+      # paths (a warm `rigor effects`) load `Reflection` without. The walk's entry point loads the collectors.
+      require_relative "../inference/declaration_walk"
+      collector = on_call ? DeclarationCallCollector.new(on_call) : DeclarationCollector.new
+      Inference::DeclarationWalk.run(root, [collector], Inference::DeclarationWalk::Context.root(nesting: []))
+      collector.classes
+    end
+  end
+end

data/lib/rigor/reflection/project_method.rb

@@ -0,0 +1,177 @@
+# frozen_string_literal: true
+
+module Rigor
+  # {Reflection}'s ancestor facade for plugins (ADR-128 WD1), split out for the reader rather than for the
+  # loader: {.project_method_defined} turns the two `Scope` ancestor walks into one `Trinary` answer. Reopening
+  # the module keeps it behind the facade its callers already read.
+  module Reflection
+    module_function
+
+    PROJECT_METHOD_KINDS = %i[instance singleton].freeze
+    PROJECT_METHOD_SOURCES = %i[def discovered either].freeze
+    private_constant :PROJECT_METHOD_KINDS, :PROJECT_METHOD_SOURCES
+
+    # ADR-128 WD1 — does the project define `method_name` on `class_name` or on an ancestor the project itself
+    # declares? Answers a {Trinary}: `yes` where the walk found a definer, `no` where it found none and its
+    # `ResolutionChain` was not truncated, and `maybe` where the chain was truncated at its budget before it found one
+    # (ADR-41 WD4), so a definer past the cut cannot be ruled out. It replaces a plugin's direct call to the
+    # two `Scope` walks, whose budget answers differ and are not a promise to plugin authors.
+    #
+    # - `kind:` is `:instance` or `:singleton`; each walks its own chain.
+    # - `source:` names the walk outright, with that walk's order and settling:
+    #   - `:def` — the first project `def` (`Scope#user_def_through_ancestors`, or `#singleton_def_through_ancestors`
+    #     for `kind: :singleton`). It does not count `attr_*` or `define_method`.
+    #   - `:discovered` — the discovery table (`Scope#discovered_method_through_ancestors?`), which also counts
+    #     `attr_*` and `define_method`.
+    #   - `:either` — their union as a three-valued OR: `yes` wins, then `maybe`, then `no`.
+    #
+    # A site that tested the `:def` walk's old answer tests `.yes?` (that walk read a cut as absent); a site that
+    # tested the `:discovered` walk's tests `!no?` (that walk read a cut as present).
+    def project_method_defined(class_name, method_name, kind:, source:, scope:)
+      raise ArgumentError, "unknown kind #{kind.inspect}" unless PROJECT_METHOD_KINDS.include?(kind)
+      raise ArgumentError, "unknown source #{source.inspect}" unless PROJECT_METHOD_SOURCES.include?(source)
+
+      case source
+      when :def then project_def_defined(class_name, method_name, kind, scope)
+      when :discovered then project_discovered_defined(class_name, method_name, kind, scope)
+      else project_either_defined(class_name, method_name, kind, scope)
+      end
+    end
+
+    # Does RBS declare `method_name` on `class_name` or on an ancestor the project's own ancestry reaches? A
+    # project class (`class ArticlesController < ActionController::Base`) is rarely in RBS itself; its RBS-known
+    # ancestors are the EXTERNAL entries of its `ResolutionChain`, which the RBS-only reads
+    # ({.instance_method_definition}) cannot reach from the project class's name. This walks the chain and asks RBS
+    # of each entry (every candidate spelling of an external one), on the side the entry sits.
+    #
+    # Answers a {Trinary}: `yes` when an entry's RBS declares the method, `no` when none does and the chain was
+    # not truncated, `maybe` when the chain was cut at its budget (ADR-41 WD4) before one did. `kind:` is
+    # `:instance` or `:singleton`; a `nil` `class_name` answers `no`.
+    def rbs_method_defined(class_name, method_name, kind:, scope:)
+      chain = ancestry_chain(class_name, kind, scope)
+      return Trinary.no if chain.nil?
+
+      found = chain.search(scope) do |entry|
+        chain_entry_names(entry).any? { |name| !rbs_method_on_side(name, method_name, entry.side, scope).nil? }
+      end
+      chain_answer(found, chain)
+    end
+
+    # Does the project ancestry of `class_name` reach any of `ancestor_names` (qualified names, a leading `::`
+    # ignored)? An external ancestor counts by any candidate spelling, so a superclass the project names but
+    # does not declare (`ActionController::Base`, with no RBS loaded) is found. Same `Trinary` and `kind:` as
+    # {.rbs_method_defined}.
+    def ancestry_reaches(class_name, ancestor_names, kind:, scope:)
+      chain = ancestry_chain(class_name, kind, scope)
+      return Trinary.no if chain.nil?
+
+      wanted = ancestor_names.map { |name| name.to_s.delete_prefix("::") }
+      found = chain.search(scope) do |entry|
+        chain_entry_names(entry).any? { |name| wanted.include?(name.to_s.delete_prefix("::")) }
+      end
+      chain_answer(found, chain)
+    end
+
+    def ancestry_chain(class_name, kind, scope)
+      raise ArgumentError, "unknown kind #{kind.inspect}" unless PROJECT_METHOD_KINDS.include?(kind)
+      return nil if class_name.nil?
+
+      Scope::ResolutionChain.for(scope, class_name.to_s, kind, :methods)
+    end
+    private_class_method :ancestry_chain
+
+    def chain_answer(found, chain)
+      return Trinary.yes if found
+
+      chain.truncated? ? Trinary.maybe : Trinary.no
+    end
+    private_class_method :chain_answer
+
+    def chain_entry_names(entry)
+      entry.external? ? entry.candidates : [entry.name]
+    end
+    private_class_method :chain_entry_names
+
+    def rbs_method_on_side(class_name, method_name, side, scope)
+      if side == :singleton
+        singleton_method_definition(class_name, method_name, scope: scope)
+      else
+        instance_method_definition(class_name, method_name, scope: scope)
+      end
+    end
+    private_class_method :rbs_method_on_side
+
+    # `yes` wins, then `maybe`, then `no`. The early return is a short-circuit and carries no answer of its own:
+    # `yes.or(x)` is `yes`, so removing it changes only which walks run, and so which dependencies they read.
+    def project_either_defined(class_name, method_name, kind, scope)
+      by_def = project_def_defined(class_name, method_name, kind, scope)
+      return by_def if by_def.yes?
+
+      by_def.or(project_discovered_defined(class_name, method_name, kind, scope))
+    end
+    private_class_method :project_either_defined
+
+    # The def walk answers `[node, owner]` or `[nil, nil]`, and `[nil, nil]` both when the chain holds no definer
+    # and when it was cut; the chain (memoised, so this is the one the walk read) tells the two apart.
+    def project_def_defined(class_name, method_name, kind, scope)
+      found = if kind == :singleton
+                scope.singleton_def_through_ancestors(class_name, method_name)
+              else
+                scope.user_def_through_ancestors(class_name, method_name)
+              end
+      return Trinary.yes if found.first
+
+      project_chain_truncated?(class_name, kind, scope) ? Trinary.maybe : Trinary.no
+    end
+    private_class_method :project_def_defined
+
+    # The discovery walk answers `true` both for a definer and for a cut chain, so a `true` on a cut chain is
+    # settled by searching the chain's entries for a definer, as the walk does.
+    #
+    # Issue #2968 — where the walk finds none, a class on the chain whose side is open (an open-names mark: a
+    # splatted `Struct.new(*FIELDS)`, `attr_accessor(*NAMES)`, a `define_method` under a computed name) answers
+    # `maybe`: it defines methods under names no table holds. Issue #2994 — so does an instance side whose chain mixes
+    # in a module no table names (`include(*MODS)`, `ResolutionChain#unnamed_mixin?`); the #618 top-level-`def` veto
+    # (`ExpressionTyper#instance_self_answers?`) reads the same mark, so a plugin that stands down here does not hand
+    # the call to a top-level `def`.
+    def project_discovered_defined(class_name, method_name, kind, scope)
+      unless scope.discovered_method_through_ancestors?(class_name, method_name, kind)
+        return open_side?(class_name, kind, scope) ? Trinary.maybe : Trinary.no
+      end
+      # A shortcut, not a decision: on an untruncated chain the search below finds the same definer.
+      return Trinary.yes unless project_chain_truncated?(class_name, kind, scope)
+
+      chain = Scope::ResolutionChain.for(scope, class_name.to_s, kind, :methods)
+      found = chain.search(scope) do |entry|
+        # A guard, not a decision: it mirrors `Scope#discovered_method_through_ancestors?`, whose search skips
+        # an external entry (no project name to look up). `discovered_method?(nil, ...)` is false anyway.
+        next false if entry.external?
+
+        scope.discovered_method?(entry.name, method_name, discovered_entry_kind(entry, kind))
+      end
+      found ? Trinary.yes : Trinary.maybe
+    end
+    private_class_method :project_discovered_defined
+
+    def open_side?(class_name, kind, scope)
+      return true if Scope::DiscoveryIndex.open_names_on_chain?(scope, class_name, kind)
+
+      kind == :instance && Scope::DiscoveryIndex.unnamed_mixin_on_chain?(scope, class_name)
+    end
+    private_class_method :open_side?
+
+    # A singleton-side entry reads the singleton table; a module on the singleton chain answers with its
+    # INSTANCE methods; on the instance chain the caller's kind stands (`Scope#kind_for`).
+    def discovered_entry_kind(entry, kind)
+      return :singleton if entry.side == :singleton
+
+      kind == :singleton ? :instance : kind
+    end
+    private_class_method :discovered_entry_kind
+
+    def project_chain_truncated?(class_name, kind, scope)
+      Scope::ResolutionChain.for(scope, class_name.to_s, kind, :methods).truncated?
+    end
+    private_class_method :project_chain_truncated?
+  end
+end

data/lib/rigor/reflection.rb

@@ -511,3 +511,5 @@ end
 # private candidate lookups, so the facade has to exist first.
 require_relative "reflection/constant_ancestors"
 require_relative "reflection/constant_path"
+require_relative "reflection/project_method"
+require_relative "reflection/declarations"

data/lib/rigor/rooted_glob.rb

@@ -38,13 +38,30 @@ module Rigor
     # it always did. An absolute one is split into its own directory and a literal basename: `File.join(".", "/abs")`
     # reads `./abs`, so an absolute path joined under `"."` matched nothing.
     #
+    # A `~`-prefixed path is expanded before the split (#2586): the readers apply `File.expand_path`, so `~/x.yml`
+    # reads `$HOME/x.yml` and the watch must be split from that spelling — `[".", "~/x.yml"]` would watch
+    # `./~/x.yml` and never fire. Only the `~` form is expanded; expanding every path would change how relative
+    # entries are watched.
+    #
     # @param path — a file path, taken literally
     # @return `[root, pattern]`: `"."` and the literal path when relative, else the directory and the literal basename
     def split_file(path)
-      path = path.to_s
+      path = expand_home(path.to_s)
       return [".", literal(path)] unless File.absolute_path?(path)
 
       [File.dirname(path), literal(File.basename(path))]
     end
+
+    # `File.expand_path`'s `~` handling, kept literal on failure: `~nouser/x` (or an unset HOME) names no home
+    # directory and raises `ArgumentError`; the readers fail on the same path, so the unexpanded spelling —
+    # watched under `"."` like any other relative entry — is the consistent answer.
+    def expand_home(path)
+      return path unless path.start_with?("~")
+
+      File.expand_path(path)
+    rescue ArgumentError
+      path
+    end
+    private_class_method :expand_home
   end
 end

data/lib/rigor/run_scoped_slots.rb

@@ -1,10 +1,14 @@
 # frozen_string_literal: true
 
+require "English"
+require_relative "typing_state"
+require_relative "memo_audit"
+
 module Rigor
-  # Issues #2412 and #2399 — the registry of per-thread memo slots whose contents belong to one analysis run. An
-  # owner registers its `Thread.current` key where it names it (`KEY = RunScopedSlots.register(:key)`), and each
-  # entry point that runs an analysis calls {.release} in its `ensure`, so a finished run, or one that raised,
-  # leaves none of its scopes, discovery tables or environment behind on the thread.
+  # Issues #2412 and #2399 — the run-end hook for per-thread state whose contents belong to one analysis run. An
+  # owner declares such a slot in {TypingState} with `run_scoped: true` where it names it, and each entry point that
+  # runs an analysis calls {.release} in its `ensure`, so a finished run, or one that raised, leaves none of its
+  # scopes, discovery tables or environment behind on the thread.
   #
   # A slot that holds its run until the next run overwrites it retains one run per thread. A slot whose value
   # reaches its own key retains every run, as `LoopValueRecord`'s `ObjectSpace::WeakKeyMap` did: the map holds
@@ -12,26 +16,22 @@ module Rigor
   # bounds both. Inside a run nothing changes: every memo keeps its key and its hit rate, and a slot read outside
   # a run (a language-server hover on the main thread) refills on its first miss.
   #
-  # Only memo slots belong here. A slot a `with_*` frame installs and restores around a block is already empty
+  # Only Tables, Memos and Resources are run-scoped. A Frame a `with_*` block installs and restores is already empty
   # when the frame returns, and clearing it from inside a frame would break the frame.
   #
-  # The registry is a module-level array filled at require time, so it is for the main Ractor only.
+  # ADR-129 — run-scoped state is a `run_scoped: true` {TypingState} slot, and nothing else registers: this module
+  # keeps no key list of its own.
   module RunScopedSlots
-    @keys = []
-
-    # Adds `key` to the registry and returns it, so the owner's constant keeps its value.
-    def self.register(key)
-      @keys << key unless @keys.include?(key)
-      key
-    end
-
-    # Every registered key, in registration order.
-    def self.keys = @keys.dup.freeze
-
-    # Empties every registered slot on the calling thread.
+    # Empties every run-scoped {TypingState} slot on the calling thread.
+    #
+    # ADR-129 WD5 (#2785) — with the memo audit on, a mismatch no file drained (one raised by typing outside the
+    # per-file loop: return summaries, return re-evaluation, sig-gen) would be released here unreported, so it is
+    # raised after the release, unless an exception is already leaving the run.
     def self.release
-      thread = Thread.current
-      @keys.each { |key| thread[key] = nil }
+      undrained = Inference::MemoAudit.enabled? ? Inference::MemoAudit.drain : nil
+      TypingState.release_run_scoped
+      raise undrained.first if undrained && !undrained.empty? && $ERROR_INFO.nil?
+
       nil
     end
   end

data/lib/rigor/scope/discovery_index.rb

@@ -60,7 +60,7 @@ module Rigor
       :contested_discovered_parameter_envelopes
     )
 
-    class DiscoveryIndex
+    class DiscoveryIndex # rubocop:disable Metrics/ClassLength -- the envelope kinds and marks are one constant each
       # Issue #2330 — identity as a hash key. `Data` hashes and compares structurally, which over these project-sized
       # tables is both costly and wrong for a per-thread memo keyed by "this very index" (an `ObjectSpace::WeakKeyMap`
       # holds the memo while the index lives and drops it with it). `==` stays structural.
@@ -247,6 +247,100 @@ module Rigor
       ENVELOPE_DYNAMIC_MARK = :"<dynamic>"
       ENVELOPE_OBJECT_EXTENDED_MARK = :"<object-extended>"
       ENVELOPE_REFINED_MARK = :"<refined>"
+      # Issue #2793 — a class-body macro defines methods under names its syntax does not spell
+      # (`def_delegators :@x, *NAMES`), so no table can enumerate the class's members: `call.undefined-method`
+      # treats the class, and every project class that inherits or mixes it in, as open, as it does a source
+      # `method_missing`. Not a {.rewritten_surface?} mark: the macro adds names and replaces no method body
+      # Rigor reads.
+      ENVELOPE_OPEN_NAMES_MARK = :"<open-names>"
+      # Issue #2793 — the sided twins of {ENVELOPE_OPEN_NAMES_MARK}: a `define_method` whose name is not a literal
+      # (`%i[a b].each { |m| define_method(m) { } }`) where `self` is the class defines instance methods no table can
+      # name, and one in a `class << self` body singleton methods. `call.undefined-method` reads the instance mark
+      # for an instance receiver and the singleton mark for the class object, each beside the sideless mark.
+      ENVELOPE_OPEN_INSTANCE_NAMES_MARK = :"<open-instance-names>"
+      ENVELOPE_OPEN_SINGLETON_NAMES_MARK = :"<open-singleton-names>"
+      # Issue #2901 — the two halves of a class macro that defines methods under computed names. A
+      # `[ENVELOPE_COMPUTED_DEFINER_KIND, side, name]` entry says the class or module's own method `name`, on `side`
+      # (`:singleton` or `:instance`, #2975), runs a `define_method` on its `self` whose name is not a literal
+      # (`def self.my_attr(*n) = n.each { |x| define_method(x) {} }`, or a module's instance method an `extend` makes a
+      # class macro). A
+      # `[ENVELOPE_BODY_CALL_KIND, name]` entry says the class body calls `name` on `self` (`my_attr :foo`).
+      # `call.undefined-method` reads a class as instance-open when a body call of it resolves, on its singleton
+      # chain, to a computed definer. Neither entry names a member, so neither declares a surface.
+      ENVELOPE_COMPUTED_DEFINER_KIND = :computed_definer
+      ENVELOPE_BODY_CALL_KIND = :body_call
+      # Issue #2975 — `[ENVELOPE_HOOK_EXTEND_KIND, "ClassMethods"]` says the module's `self.included(base)` (or
+      # `self.prepended(base)`) hook runs `base.extend(ClassMethods)`, the constant as written: an includer's
+      # singleton chain then reaches `ClassMethods`, whose computed definers its body calls may resolve to.
+      #
+      # Issue #2986 — an `extend ActiveSupport::Concern` module records `[ENVELOPE_HOOK_EXTEND_KIND, "ClassMethods",
+      # :const_get]`: `Concern#append_features` extends its includer with `const_get(:ClassMethods)`, which searches the
+      # module, its ancestors and `Object`, not the lexical scope. A `[ENVELOPE_HOOK_BODY_CALL_KIND, hook, name]` entry
+      # says its `included do … end` (`hook` `:included`) or `prepended do … end` (`:prepended`) block calls `name` on
+      # `self`, which Ruby runs in the class body of a class that includes (or prepends) the module directly. It is
+      # filed only on the module whose body the walk is in, so it is not one of `Incremental`'s diffed class-mark kinds.
+      #
+      # Issue #1592 — a hook's own entry names the hook as its third element (`[ENVELOPE_HOOK_EXTEND_KIND, "M",
+      # :included]`, `:prepended` for `self.prepended` or a `prepended do … end` block), and an `extend` on `self` in a
+      # concern's `included do … end` / `prepended do … end` block records one too. The includer's singleton resolution
+      # chain inserts each such module for the edge its hook runs on. A `[ENVELOPE_HOOK_EXTEND_OPEN_KIND, hook]` entry
+      # says that hook may extend its includer with a module no entry names, or one it may not extend at all (an
+      # `extend` that is not a direct statement of the hook body, or whose argument is not a constant).
+      ENVELOPE_HOOK_EXTEND_KIND = :hook_extend
+      ENVELOPE_HOOK_EXTEND_OPEN_KIND = :hook_extend_open
+      # Issue #1592 — `[ENVELOPE_HOOK_DEF_KIND, hook, source]`: one definition of the module's `self.included` /
+      # `self.prepended` hook, by its source text. Two entries for one hook mean the hook is defined twice, and which
+      # definition Ruby keeps is load order.
+      ENVELOPE_HOOK_DEF_KIND = :hook_def
+      ENVELOPE_HOOK_BODY_CALL_KIND = :hook_body_call
+      # Issue #2992 — `[ENVELOPE_CONCERN_DEPENDENCY_KIND, "Dep"]`: the module's body runs `include Dep` (or `prepend
+      # Dep`) after its own `extend ActiveSupport::Concern`, so a concern `Dep` is a dependency of the module, which
+      # ActiveSupport includes into the module's final includer instead. Filed only on the module whose body the walk
+      # is in, as the hook-body-call entry is.
+      ENVELOPE_CONCERN_DEPENDENCY_KIND = :concern_dependency
+      # Issue #3005 — the hook a hook-extend, open or hook-body-call entry names when it comes from an `included do …
+      # end` / `prepended do … end` block in a body that does not run `extend ActiveSupport::Concern` itself. The
+      # block is ActiveSupport's only when some body of the module records the concern entry; a reader takes the
+      # gated hook as the plain one then, and as no hook otherwise ({ResolutionChain.effective_hook}).
+      CONCERN_BLOCK_HOOKS = { included: :concern_included, prepended: :concern_prepended }.freeze
+      # Issue #3005 — the last segment of the module a concern block's `def self.x`s are filed on (`Owner::<included>`),
+      # and the spelling its hook-extend entry names.
+      HOOK_BLOCK_SEGMENTS = %w[<included> <prepended>].freeze
+      # Issue #2979 — `[ENVELOPE_SAME_CLASS_KIND, "Struct::Named"]` on `K`'s bucket, and its mirror on
+      # `Struct::Named`'s, say that `K = Struct.new("Named", …)` binds both constants to one class object: the method
+      # chain of either name reads the other's tables at its own position ({.same_class_names}). It names no member.
+      ENVELOPE_SAME_CLASS_KIND = :same_class
+      # Issue #2998 — `[ENVELOPE_SINGLETON_PREPEND_KIND, "P"]` on `K`'s bucket says one of `K`'s `discovered_extends`
+      # entries spelt `"P"` is a prepend to `K`'s singleton class (`class << self; prepend P; end`,
+      # `singleton_class.prepend P`, `singleton_class.send(:prepend, P)` in `K`'s body), which sits ahead of the class
+      # object's own methods where an `extend` sits behind them. The singleton resolution chain reads it.
+      ENVELOPE_SINGLETON_PREPEND_KIND = :singleton_prepend
+      # Issue #3018 — `[ENVELOPE_OBJECT_SINGLETON_KIND, name]` says a definer written on the constant's object from
+      # outside its body defines `name` there: `def K.name`, a literal `K.define_singleton_method(:name)`, or a `def
+      # name` in a `K.singleton_class.class_eval` block. Each also files the opaque `[:singleton, name]` entry, which
+      # name-rewriting class-body macros (`memoize :name`) file too; this entry is the one the class-object path of
+      # `call.undefined-method` reads as evidence the singleton method exists.
+      ENVELOPE_OBJECT_SINGLETON_KIND = :object_singleton
+      MACRO_KINDS = [ENVELOPE_BODY_CALL_KIND, ENVELOPE_COMPUTED_DEFINER_KIND, ENVELOPE_HOOK_EXTEND_KIND,
+                     ENVELOPE_HOOK_EXTEND_OPEN_KIND, ENVELOPE_HOOK_DEF_KIND, ENVELOPE_HOOK_BODY_CALL_KIND,
+                     ENVELOPE_CONCERN_DEPENDENCY_KIND, ENVELOPE_SAME_CLASS_KIND,
+                     ENVELOPE_SINGLETON_PREPEND_KIND].freeze
+      private_constant :MACRO_KINDS
+
+      NO_NAMES = [].freeze
+      private_constant :NO_NAMES
+
+      # Issue #2979 — the other names an envelope bucket says its class object is bound to
+      # ({ENVELOPE_SAME_CLASS_KIND}), in recording order; empty for nearly every bucket, and allocates nothing then.
+      def self.same_class_names(bucket)
+        return NO_NAMES if bucket.nil?
+
+        names = nil
+        bucket.each_key do |key|
+          (names ||= []) << key.last if key.is_a?(Array) && key.first == ENVELOPE_SAME_CLASS_KIND
+        end
+        names || NO_NAMES
+      end
 
       # Issue #1820 — whether an envelope bucket says the project declares, or rewrites, the name's method table: a
       # per-method entry, the {ENVELOPE_MODULE_MARK} a `module` declaration records, or the {ENVELOPE_DYNAMIC_MARK}
@@ -258,7 +352,60 @@ module Rigor
       private_constant :DECLARING_MARKS
 
       def self.declares_surface?(bucket)
-        !bucket.nil? && bucket.any? { |key, _| !key.is_a?(Symbol) || DECLARING_MARKS.include?(key) }
+        !bucket.nil? && bucket.any? { |key, _| declaring_key?(key) }
+      end
+
+      # Issue #2901 — a per-method entry declares a member; the two macro entries ({ENVELOPE_BODY_CALL_KIND},
+      # {ENVELOPE_COMPUTED_DEFINER_KIND}) do not.
+      def self.declaring_key?(key)
+        return DECLARING_MARKS.include?(key) if key.is_a?(Symbol)
+
+        !(key.is_a?(Array) && MACRO_KINDS.include?(key.first))
+      end
+
+      # Issue #2968 — the open-names marks of one side: {ENVELOPE_OPEN_NAMES_MARK} and the side's own twin.
+      OPEN_NAMES_MARKS = {
+        instance: [ENVELOPE_OPEN_NAMES_MARK, ENVELOPE_OPEN_INSTANCE_NAMES_MARK].freeze,
+        singleton: [ENVELOPE_OPEN_NAMES_MARK, ENVELOPE_OPEN_SINGLETON_NAMES_MARK].freeze
+      }.freeze
+      private_constant :OPEN_NAMES_MARKS
+
+      # Issue #2968 — whether an entry of `class_name`'s `kind` chain carries that side's open-names mark: a splatted
+      # `Struct.new(*FIELDS)`, `attr_accessor(*NAMES)`, a `define_method` under a computed name, so the side defines
+      # methods no table names. A project class with no `def` of its own is an external entry (#2094), so its candidate
+      # names are asked too. Read by `Reflection.project_method_defined` and by the implicit-self top-level-`def` veto
+      # (`ExpressionTyper#instance_self_answers?`), beside `call.undefined-method`'s own reader.
+      def self.open_names_on_chain?(scope, class_name, kind)
+        marks = OPEN_NAMES_MARKS.fetch(kind)
+        chain = ResolutionChain.for(scope, class_name.to_s, kind, :methods)
+        found = chain.search(scope) do |entry|
+          names = entry.external? ? entry.candidates : [entry.name]
+          names.any? do |name|
+            bucket = scope.parameter_envelopes_of(name)
+            marks.any? { |mark| bucket.key?(mark) }
+          end
+        end
+        !found.nil?
+      end
+
+      # Issue #2994 — whether `class_name`'s instance-side chain mixes in a module no table names
+      # (`ResolutionChain#unnamed_mixin?`: `include(*MODS)`, `include helper`, a hook's `base.include`). A project class
+      # with no `def` of its own is an external entry (#2094) whose ancestry the chain does not walk, so each of its
+      # candidate names that the project declares is asked on its own chain. Read beside {.open_names_on_chain?} by
+      # `Reflection.project_method_defined` and by the implicit-self top-level-`def` veto.
+      def self.unnamed_mixin_on_chain?(scope, class_name)
+        chain = ResolutionChain.for(scope, class_name.to_s, :instance, :methods)
+        return true if chain.unnamed_mixin?
+
+        found = chain.search(scope) do |entry|
+          next false unless entry.external?
+
+          entry.candidates.any? do |name|
+            scope.discovered_classes.key?(name) &&
+              ResolutionChain.for(scope, name, :instance, :methods).unnamed_mixin?
+          end
+        end
+        !found.nil?
       end
 
       # Whether an envelope bucket says the project rewrites the class's method table beyond its literal names: a

data/lib/rigor/scope/resolution_chain/relevance.rb

@@ -27,6 +27,8 @@ module Rigor
       # segment of its spelling, so a new file declaring the module re-checks the consumer.
       module Relevance
         WILDCARD = "*"
+        # Issue #2991 — listed beside {WILDCARD} when the side mixes in a module no name spells.
+        UNNAMED = "?"
 
         # The singleton hooks Ruby calls while a module enters (or is asked to enter) another's ancestry. A module
         # that defines one can add methods to the includer, extender or prepender with nothing the tables record
@@ -39,7 +41,18 @@ module Rigor
         def discharged?(scope, chain, mark, name)
           name = name.to_sym
           memo = ResolutionChain.relevance_memo(scope, chain.flavor)
-          verdict, edges = memo[[mark, name]] ||= compute(scope, chain.flavor, mark, name)
+          key = [mark, name]
+          entry = memo[key]
+          verdict, edges =
+            if entry.nil?
+              memo[key] = Inference::MemoAudit.key_audit("resolution chain relevance") do
+                compute(scope, chain.flavor, mark, name)
+              end
+            else
+              Inference::MemoAudit.check("resolution chain relevance", entry, mark, name) do
+                Analysis::DependencyRecorder.withhold { compute(scope, chain.flavor, mark, name) }.first
+              end
+            end
           replay(scope, edges) if Analysis::DependencyRecorder.active?
           verdict
         end