rigortype 0.4.6 → 0.4.8

data/lib/rigor/sig_gen/writer.rb

@@ -4,6 +4,7 @@ require "fileutils"
 require "rbs"
 
 require_relative "classification"
+require_relative "generic_header_scan"
 require_relative "layout_index"
 require_relative "superclass_spelling"
 require_relative "write_result"
@@ -15,7 +16,8 @@ module Rigor
     #
     # ADR-14 slice 2: the writer parses the target with `RBS::Parser` to find the matching class declaration and
     # inserts new method declarations just before the class's closing `end` keyword. Existing declarations are
-    # NEVER touched unless `--overwrite` is set AND the candidate's classification is `tighter-return`.
+    # NEVER touched unless `--overwrite` is set and the candidate is eligible for replacement (see
+    # {#eligible_for_replacement?}).
     #
     # The slice does NOT re-render the whole file through `RBS::Writer`. That would lose comments / blank-line
     # formatting per upstream design; the byte-range insertion approach taken here preserves untouched
@@ -32,9 +34,33 @@ module Rigor
 
       # Per-`update_existing` accumulator. The merge_class helper mutates `source` / `decls` / `applied` /
       # `skipped` in place as each class is processed so the next class sees the latest byte positions.
-      MergeState = Struct.new(:source, :decls, :applied, :skipped, :left_unreadable, :replaced, keyword_init: true)
+      MergeState = Struct.new(:source, :decls, :applied, :skipped, :left_unreadable, :replaced, :repaired_headers,
+                              :target, keyword_init: true)
       private_constant :MergeState
 
+      # #2576 — a target the writer cannot write (a permission denial, a directory sitting where the
+      # `.rbs` belongs, a parent path that is a regular file) is a bad `--write` invocation, not a
+      # crash: the command
+      # reports it as the same usage error `rigor init --path` gives and exits 64. Carries the target
+      # and the stripped Errno reason so the CLI prints `cannot write PATH: REASON` without
+      # re-parsing the message.
+      class WriteError < StandardError
+        attr_reader :target_path
+
+        def initialize(target_path, error)
+          @target_path = target_path.to_s
+          super("cannot write #{@target_path}: #{error.message.sub(/ @ .*\z/m, '')}")
+        end
+      end
+
+      # The target routing this writer applies; the generator maps candidates through it to ask {#accepts_target?}.
+      attr_reader :path_mapper
+
+      # #2605 — the generic classes whose bare headers the last {#write_all} (or {#write}) left bare, because a
+      # body names one of the parameters: `{ class:, targets:, blocking: [{ target:, names: }] }` each
+      # ({GenericHeaderScan#left_bare}).
+      attr_reader :left_bare
+
       # @param dry_run — assemble and validate every target exactly as a write would, and report it, without
       #   creating or changing a file. `sig-gen --check` (ADR-112 WD4) is this, so it can only ever disagree
       #   with `--write` about the disk, never about the content.
@@ -47,6 +73,15 @@ module Rigor
         @global_namespace_kinds = {}
         # Run-level qualified-class-name => superclass-token view, same lifecycle as `@global_namespace_kinds`.
         @global_superclasses = {}
+        # #2436 — the target being rendered's view of {MethodCandidate#class_type_params}, set per target.
+        @type_params = {}
+        # #2603/#2605 — the run-wide repair decision {#write_all} reads from the sig root before writing: the
+        # classes cleared for repair with their spelling, and the classes held back. {#write} leaves both empty and
+        # decides per file.
+        @scan_repairs = {}
+        @held_back = []
+        @left_bare = []
+        @repair_targets = []
       end
 
       # Process the full candidate list by resolving each candidate's target sig file via the path mapper (which
@@ -56,31 +91,94 @@ module Rigor
       # ADR-14 follow-up: this is the consolidated-layout entry point. The legacy `write(source_path,
       # candidates)` below assumes all candidates share a target and remains for spec convenience.
       #
+      # @param header_spelling — called with a class name, returns the header spelling of a generic class the run
+      #   does not stamp (#2603: a bare header in a file no candidate routes to); the generator's
+      #   {Generator#generic_header_spelling}. Without it only the run's stamp counts.
       # @return one per target sig file.
-      def write_all(candidates)
+      def write_all(candidates, header_spelling: nil)
         emittable = candidates.select { |c| EMITTABLE.include?(c.classification) }
-        return [] if emittable.empty?
+        scan_generic_headers(candidates, header_spelling)
 
         @global_namespace_kinds = build_namespace_kinds(candidates)
         @global_superclasses = build_superclasses(candidates)
-        grouped = emittable.group_by do |c|
-          @path_mapper.target_for(c.path, class_name: c.class_name, method_name: c.method_name, kind: c.rbs_kind)
+        grouped = emittable.group_by { |c| target_of(c) }
+        results = grouped.map { |target, group| write_target(target, group) }
+        results + repair_only_results(candidates, grouped.keys.map { |target| target.expand_path.to_s })
+      end
+
+      def target_of(candidate)
+        @path_mapper.target_for(candidate.path, class_name: candidate.class_name,
+                                                method_name: candidate.method_name, kind: candidate.rbs_kind)
+      end
+      private :target_of
+
+      # Issues #2603 and #2605 — reads every file under the signature paths for bare openings of generic classes
+      # before anything is written ({GenericHeaderScan}). A class is repaired in every file or in none: one bare
+      # opening rbs still rejects keeps the class failing, so repairing its other openings would be churn. Only files
+      # under the sig root are rewritten; a bare opening anywhere else holds its class back.
+      def scan_generic_headers(candidates, header_spelling)
+        stamp = merged_type_params(candidates)
+        scan = GenericHeaderScan.scan(sig_root: @path_mapper.sig_root_dir, signature_dirs: @path_mapper.signature_dirs,
+                                      spelling_for: ->(name) { stamp[name] || header_spelling&.call(name) })
+        @scan_repairs = scan.repairs
+        @held_back = scan.left_bare.map { |entry| entry.fetch(:class) }
+        @left_bare = scan.left_bare
+        @repair_targets = scan.repair_targets
+      end
+      private :scan_generic_headers
+
+      # The files with a bare header to repair that no emitted member routes to: each gets the repair and nothing
+      # else (#2580), whether a skipped candidate routes to it or none does (#2603). The row names a candidate's
+      # source when one routes there. A file the writer would not open (not UTF-8, unparseable) is never listed.
+      def repair_only_results(candidates, written)
+        sources = candidates.each_with_object({}) do |candidate, acc|
+          acc[target_of(candidate).expand_path.to_s] ||= candidate.path if candidate.path
+        end
+        @repair_targets.filter_map do |path|
+          target = Pathname(path)
+          next if written.include?(target.expand_path.to_s) || !inside_sig_root?(target)
+
+          result = update_existing(sources[target.expand_path.to_s], target, [], repair_only: true)
+          result if %i[updated skipped_invalid_rbs].include?(result.action)
         end
-        grouped.map { |target, group| write_target(target, group) }
       end
+      private :repair_only_results
 
-      # @param candidates — only
-      #   emittable classifications (new-method /
-      #   tighter-return) are honoured; the caller is
-      #   responsible for filtering.
+      # @param candidates — only emittable classifications are honoured; `write` filters on `EMITTABLE` itself.
       def write(source_path, candidates)
         emittable = candidates.select { |c| EMITTABLE.include?(c.classification) }
         return WriteResult.new(source_path: source_path, target_path: nil, action: :noop) if emittable.empty?
 
+        @scan_repairs = {}
+        @held_back = []
+        @left_bare = []
         target = @path_mapper.target_for(source_path, class_name: emittable.first.class_name)
         write_target(target, emittable, source_path: source_path)
       end
 
+      # Whether the writer is sure to write `candidate`. A file the writer writes nothing to is left as it is, so a
+      # class shell riding on that file's candidates never reaches disk; the generator asks this before it counts
+      # a shell as declared (#2454). Only a new method is sure: without `--overwrite` the writer skips a tighter
+      # return or an inline overwrite whose method the target already declares. Counting too few only demotes a
+      # subclass, which is the output before #2454.
+      def self.writes?(candidate)
+        candidate.classification == Classification::NEW_METHOD
+      end
+
+      # Whether {#write_target} would write to `target` at all, asked before any candidate is rendered (#2461): a
+      # target inside the sig root that is missing (the create path), or that exists, is valid UTF-8 and parses.
+      # {#update_existing} refuses an unparseable or mis-encoded file and leaves it untouched, so a class shell on it
+      # never reaches disk. A spliced result {RbsValidity} rejects is a writer defect and is not predicted here.
+      def accepts_target?(target)
+        return false unless inside_sig_root?(target)
+        return true unless target.exist?
+
+        source = target.read
+        source.valid_encoding? && !parse_signature(source).nil?
+      rescue SystemCallError
+        false
+      end
+
       # Whether `proposed` has STRICTLY FEWER bare `untyped` tokens than `existing`. A count, not a slot-by-slot
       # comparison: it reads as "at least one more position is concrete", and does not prove that no concrete
       # position became `untyped` elsewhere. Word-boundary matching counts `untyped` only as a type token, not
@@ -103,6 +201,8 @@ module Rigor
         end
 
         target.exist? ? update_existing(source_path, target, candidates) : create_new(source_path, target, candidates)
+      rescue SystemCallError => e
+        raise WriteError.new(target, e)
       end
 
       # Deliberately NARROWER than {Classification::EMITTABLE}: the write path has never produced a
@@ -139,6 +239,8 @@ module Rigor
         end
         WriteResult.new(source_path: source_path, target_path: target,
                         action: :created, applied: candidates)
+      rescue SystemCallError => e
+        raise WriteError.new(target, e)
       end
 
       # ADR-14 gap-#3 follow-up (c): when one candidate's `class_name` is a strict prefix of another's, emit a
@@ -157,10 +259,11 @@ module Rigor
         tree = build_namespace_tree(candidates, shells)
         kinds = merged_namespace_kinds(candidates)
         supers = merged_superclasses(candidates)
+        @type_params = merged_type_params(candidates)
         render_tree_nodes(tree, kinds, supers, 0)
       end
 
-      # Drains `class_shells` from every candidate; the generator's walker populates the same set on every
+      # Unions `class_shells` across every candidate; the generator's walker populates the same set on every
       # candidate produced from a given file (gap-#3 (e)).
       def collect_class_shells(candidates)
         shells = Set.new
@@ -202,6 +305,13 @@ module Rigor
         merged
       end
 
+      # #2436 — every candidate carries the run's map, so folding the target's candidates is the whole view.
+      def merged_type_params(candidates)
+        candidates.each_with_object({}) do |c, acc|
+          acc.merge!(c.class_type_params) if c.respond_to?(:class_type_params)
+        end
+      end
+
       def build_superclasses(candidates)
         candidates.each_with_object({}) do |candidate, acc|
           next unless candidate.respond_to?(:class_superclasses)
@@ -257,7 +367,7 @@ module Rigor
         indent = INDENT * depth
         qualified = (prefix + [node[:name]]).join("::")
         keyword = node_keyword(node, kinds, qualified)
-        header = "#{keyword} #{node[:name]}#{superclass_suffix(keyword, supers, qualified)}"
+        header = "#{keyword} #{node[:name]}#{@type_params[qualified]}#{superclass_suffix(keyword, supers, qualified)}"
         body = render_tree_node_body(node, kinds, supers, depth, prefix)
         "#{indent}#{header}\n#{body}#{indent}end\n"
       end
@@ -293,13 +403,12 @@ module Rigor
         :module
       end
 
-      def update_existing(source_path, target, candidates)
+      def update_existing(source_path, target, candidates, repair_only: false)
         source = target.read
         # Pre-parser encoding guard, mirroring `Environment::RbsLoader.invalid_encoding?`: handed invalid
         # UTF-8, `RBS::Parser` raises a bare `ArgumentError` on rbs 4.1 (not the `ParsingError` that
         # `parse_signature` below rescues) and could hang outright on the older releases the gemspec
-        # supports. The refusal is loud — unlike an unparseable file (`:noop`, surfaced by `rigor check`'s
-        # own quarantine warning), a mojibake file would otherwise fail with a stack trace naming neither
+        # supports. The refusal is loud — a mojibake file would otherwise fail with a stack trace naming neither
         # the file nor the fix.
         unless source.valid_encoding?
           return WriteResult.new(source_path: source_path, target_path: target,
@@ -307,16 +416,19 @@ module Rigor
                                  error: "#{target} is not valid UTF-8")
         end
 
-        decls = parse_signature(source)
-        return WriteResult.new(source_path: source_path, target_path: target, action: :noop) if decls.nil?
-
-        state = MergeState.new(source: source, decls: decls, applied: [], skipped: [], left_unreadable: [],
-                               replaced: [])
-        merge_candidates(state, candidates)
+        # An existing file that does not parse is refused like a mis-encoded one, not skipped as `:noop` (#2480):
+        # `--check` must fail on it, because a `--write` that cannot touch the file is not an up-to-date `sig/`.
+        # `rigor check` quarantines such a file whole; this refusal names it at the sig-gen boundary too.
+        decls, parse_detail = parse_target_signature(target, source)
+        if decls.nil?
+          return WriteResult.new(source_path: source_path, target_path: target,
+                                 action: :skipped_unparseable,
+                                 error: "#{target} does not parse as RBS: #{parse_detail}")
+        end
 
-        action = state.applied.empty? ? :noop : :updated
-        unless action == :updated
-          return WriteResult.new(source_path: source_path, target_path: target, action: action,
+        state = merged_state(source, decls, candidates, repair_only, target)
+        unless state_changed?(state)
+          return WriteResult.new(source_path: source_path, target_path: target, action: :noop,
                                  applied: state.applied, skipped: state.skipped,
                                  left_unreadable: state.left_unreadable)
         end
@@ -333,8 +445,11 @@ module Rigor
 
         target.write(state.source) unless @dry_run
         WriteResult.new(source_path: source_path, target_path: target,
-                        action: action, applied: state.applied, skipped: state.skipped,
-                        left_unreadable: state.left_unreadable, replaced: state.replaced)
+                        action: :updated, applied: state.applied, skipped: state.skipped,
+                        left_unreadable: state.left_unreadable, replaced: state.replaced,
+                        repaired_headers: state.repaired_headers)
+      rescue SystemCallError => e
+        raise WriteError.new(target, e)
       end
 
       # Applies every class group, then every requested shell, then normalises the layout the three steps
@@ -343,12 +458,89 @@ module Rigor
         supers = merged_superclasses(candidates)
         kinds = merged_namespace_kinds(candidates)
         shells = collect_class_shells(candidates)
+        @type_params = merged_type_params(candidates)
         groups = candidates.group_by(&:class_name)
         # Ancestors first, so `Foo` is created (or found) before `Foo::Bar` looks for a parent to nest under.
         # A plain sort suffices: a name always sorts before every name it is a strict prefix of.
         groups.keys.sort.each { |name| merge_class(state, name, groups.fetch(name), kinds, supers) }
         merge_class_shells(state, shells, kinds, supers)
         collapse_nested_declarations(state, groups.keys + shells.to_a)
+        # Last, so the members this run merged count towards {#shadowed_after_merge?}.
+        repair_generic_headers(state, state.target)
+      end
+
+      # Issue #2580 — a declaration this file already holds for a class the loaded RBS declares generic, opened
+      # with no type parameters at all (`class Array`, as sig-gen wrote it before #2436), is a guaranteed
+      # `RBS::GenericParameterMismatchError`: rbs requires every declaration of a class to repeat the first one's
+      # parameters, and the class, plus every class whose ancestry reaches it (`Object` through `Kernel`), then
+      # fails its definition build. Writing more members into that header would keep the file broken, so the
+      # header gets the same spelling a new header would ({Generator#stamp_generic_reopenings}: plain
+      # parameters only). A header that spells parameters of its own is the project's and is left alone, as is
+      # every class neither the run's stamp nor {#write_all}'s scan names.
+      #
+      # A declaration whose body names a type like one of the parameters (`def old: () -> E` for a project class
+      # `E`) is left bare: under `class Array[unchecked out E]` that `E` would bind to the parameter, silently
+      # changing what the member says. The body is matched as text, so a comment or a nested declaration that
+      # spells the name also keeps the header bare, which is the state the file was already in; a method type that
+      # declares the name as its own parameter (`def m: [E] (E) -> E`) does not (#2605).
+      #
+      # Under {#write_all} the class is repaired in every file under the sig root or in none ({GenericHeaderScan},
+      # #2605): a class held back there is not repaired here, and a class the run does not stamp is repaired with the
+      # scan's spelling (#2603). The check below runs again after the merge, so a member this run merged counts
+      # too; the generator anchors a member's type that a parameter would capture (#2436), so it holds back a class
+      # the scan cleared only for a member written without that anchor, and is then reported in {#left_bare}.
+      # `repaired_headers` gets one entry per declaration repaired.
+      def repair_generic_headers(state, target)
+        spellings = @scan_repairs.merge(@type_params).except(*@held_back)
+        spellings.keys.sort.each do |name|
+          spelling = spellings.fetch(name)
+          bare = find_class_decls(state.decls, name).select { |d| d.type_params.empty? && d.location&.[](:name) }
+          next if bare.empty? || shadowed_after_merge?(state.source, bare, name, spelling, target)
+
+          insert_type_params(state, bare, spelling)
+          bare.each { state.repaired_headers << "#{name}#{spelling}" }
+        end
+      end
+
+      # Whether any of `bare` names one of the parameters `spelling` declares ({GenericHeaderScan.shadowing_names});
+      # each such opening is recorded in {#left_bare}.
+      def shadowed_after_merge?(source, bare, name, spelling, target)
+        params = GenericHeaderScan.parameter_names(spelling)
+        return true if params.nil?
+
+        blocking = bare.filter_map do |decl|
+          names = GenericHeaderScan.shadowing_names(source, decl, params)
+          { target: target.to_s, reason: "names_parameter", names: names } unless names.empty?
+        end
+        return false if blocking.empty?
+
+        @left_bare << { class: name, targets: [target.to_s], blocking: blocking }
+        true
+      end
+
+      # Splices `spelling` right after each declaration's name, last one first so earlier offsets stay valid.
+      def insert_type_params(state, decls, spelling)
+        decls.map { |d| d.location[:name].end_pos }.sort.reverse_each do |pos|
+          state.source = state.source[0...pos] + spelling + state.source[pos..]
+        end
+        state.decls = parse_signature(state.source) || state.decls
+      end
+
+      def merged_state(source, decls, candidates, repair_only, target)
+        state = MergeState.new(source: source, decls: decls, applied: [], skipped: [], left_unreadable: [],
+                               replaced: [], repaired_headers: [], target: target)
+        repair_only ? repair_only_candidates(state, candidates) : merge_candidates(state, candidates)
+        state
+      end
+
+      def state_changed?(state)
+        !(state.applied.empty? && state.repaired_headers.empty?)
+      end
+
+      # {#repair_only_results}' merge step: the run's stamp, and the header repair alone.
+      def repair_only_candidates(state, candidates)
+        @type_params = merged_type_params(candidates)
+        repair_generic_headers(state, state.target)
       end
 
       # ADR-14 gap-#3 (e): for every requested class shell that isn't already declared in the target file,
@@ -401,7 +593,9 @@ module Rigor
         parent_name = segments[0...-1].join("::")
         parent = find_class_decl(state.decls, parent_name)
         decl = parent && find_class_decl(state.decls, qualified)
-        return if decl.nil? || overlapping?(parent, decl)
+        # A rooted declaration (`module A; class ::B::C`) keeps the layout the user wrote: cutting it out of its
+        # enclosing module would leave that module empty, so the member merges in place instead.
+        return if decl.nil? || overlapping?(parent, decl) || decl.name.to_s.start_with?("::")
 
         region = decl_region(state.source, decl)
         block = region && relocated_block(state.source, decl, parent, segments.last, region)
@@ -560,6 +754,15 @@ module Rigor
         nil
       end
 
+      # Parses an EXISTING target, naming it as the buffer so the parse error carries `path:line:col` (a bare
+      # String would be named `a.rbs`). Returns `[decls, nil]`, or `[nil, first_line_of_message]` on a parse error.
+      def parse_target_signature(target, source)
+        _, _, decls = RBS::Parser.parse_signature(RBS::Buffer.new(name: target.to_s, content: source))
+        [decls, nil]
+      rescue RBS::ParsingError => e
+        [nil, e.message.to_s.lines.first.to_s.strip]
+      end
+
       def merge_class(state, class_name, methods, kinds, supers)
         decl = find_class_decl(state.decls, class_name)
         if decl.nil?
@@ -586,11 +789,10 @@ module Rigor
         decls.each do |decl|
           next unless decl.is_a?(RBS::AST::Declarations::Class) || decl.is_a?(RBS::AST::Declarations::Module)
 
-          local = decl.name.to_s.sub(/\A::/, "")
-          full = prefix.empty? ? local : "#{prefix.join('::')}::#{local}"
-          return decl if full == qualified_name
+          path = ::Rigor::Environment::RbsLoader.declared_class_path(decl, prefix)
+          return decl if path.join("::") == qualified_name
 
-          nested = find_class_decl_in(decl.members, prefix + [local], qualified_name)
+          nested = find_class_decl_in(decl.members, path, qualified_name)
           return nested if nested
         end
         nil
@@ -602,10 +804,9 @@ module Rigor
         decls.each do |decl|
           next unless decl.is_a?(RBS::AST::Declarations::Class) || decl.is_a?(RBS::AST::Declarations::Module)
 
-          local = decl.name.to_s.sub(/\A::/, "")
-          full = prefix.empty? ? local : "#{prefix.join('::')}::#{local}"
-          found << decl if full == qualified_name
-          find_class_decls(decl.members, qualified_name, prefix + [local], found)
+          path = ::Rigor::Environment::RbsLoader.declared_class_path(decl, prefix)
+          found << decl if path.join("::") == qualified_name
+          find_class_decls(decl.members, qualified_name, path, found)
         end
         found
       end
@@ -669,7 +870,7 @@ module Rigor
       # name, slices out the old declaration's source range and substitutes the new RBS one-liner. Members that
       # are not `MethodDefinition`s are left alone.
       #
-      # Two candidate classifications are eligible for replacement under `--overwrite`:
+      # Under `--overwrite`, an inline overwrite is always eligible, and so are two other classifications:
       #
       # 1. `TIGHTER_RETURN` — the classifier already proved the new return type is a strict subtype of the
       #    declared one (with lenience guards passed).

data/lib/rigor/sig_gen.rb

@@ -5,6 +5,7 @@ require_relative "sig_gen/classification"
 require_relative "sig_gen/effect_annotation"
 require_relative "sig_gen/inline_declarations"
 require_relative "sig_gen/method_candidate"
+require_relative "sig_gen/platform_guarded_files"
 require_relative "sig_gen/observed_call"
 require_relative "sig_gen/meta_class_shape"
 require_relative "sig_gen/type_elaborator"

data/lib/rigor/source/forwardable_delegators.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+require "prism"
+require_relative "literals"
+
+module Rigor
+  module Source
+    # Issue #2793 — the methods a `Forwardable` / `SingleForwardable` delegator macro defines, read off its syntax
+    # alone. Ruby 4.0's `forwardable.rb` is the oracle for each row:
+    #
+    # - `def_instance_delegator(acc, m, ali = m)` defines `ali` on the instance side;
+    # - `def_instance_delegators(acc, *ms)` defines each `m` but `__send__` and `__id__`, instance side (the two are
+    #   recorded anyway: `BasicObject` declares both, so a recorded entry changes no answer);
+    # - `instance_delegate(ms => acc)` defines each key name (a name or an array of them), instance side;
+    # - `def_single_delegator(s)` and `single_delegate` are the same on the singleton side;
+    # - `def_delegator(s)` and `delegate` are the same on the side the `extend` decides.
+    #
+    # `def_delegator(s)` and `delegate` are `Forwardable`'s instance aliases and `SingleForwardable`'s singleton
+    # ones, so their side is {AMBIGUOUS} and the caller settles it from the `extend` it has seen. `def_delegator :@x,
+    # :last, :final` defines `final` and never `last`.
+    #
+    # A name the syntax does not spell (`def_delegators :@x, *NAMES`, `delegate names => :@x`) makes the delegation
+    # {Delegation#open?}: the macro defines methods no reader can enumerate. `delegate` takes Forwardable's
+    # single-hash form only, so ActiveSupport's `delegate :a, to: :b` (positional names before a `to:` key) is
+    # not read here.
+    module ForwardableDelegators
+      AMBIGUOUS = :ambiguous
+
+      # The names a delegator macro defines, on which side, and whether it also defines names its syntax hides.
+      Delegation = Data.define(:side, :names, :open) do
+        def open? = open
+      end
+
+      # `[side, shape]` per macro: `:alias` takes `(accessor, method, alias = method)`, `:list` takes `(accessor,
+      # *methods)`, `:hash` takes `(methods => accessor, …)`.
+      MACROS = Ractor.make_shareable(
+        {
+          def_instance_delegator: %i[instance alias], def_instance_delegators: %i[instance list],
+          instance_delegate: %i[instance hash],
+          def_single_delegator: %i[singleton alias], def_single_delegators: %i[singleton list],
+          single_delegate: %i[singleton hash],
+          def_delegator: [AMBIGUOUS, :alias], def_delegators: [AMBIGUOUS, :list], delegate: [AMBIGUOUS, :hash]
+        }
+      )
+
+      private_constant :MACROS
+
+      module_function
+
+      # The {Delegation} of an implicit-self (or `self.`) delegator macro call, or nil for any other call, and for
+      # one whose arguments are not a shape the macro accepts.
+      def of(call_node)
+        return nil unless call_node.is_a?(Prism::CallNode)
+        return nil unless call_node.receiver.nil? || call_node.receiver.is_a?(Prism::SelfNode)
+
+        side, shape = MACROS[call_node.name]
+        return nil if side.nil?
+
+        arguments = call_node.arguments&.arguments || []
+        return Delegation.new(side: side, names: [].freeze, open: true) if unplaceable_splat?(shape, arguments)
+
+        names, open = case shape
+                      when :alias then alias_names(arguments)
+                      when :list then list_names(arguments)
+                      else hash_names(arguments)
+                      end
+        return nil if names.nil?
+
+        Delegation.new(side: side, names: names.freeze, open: open)
+      end
+
+      # A splat (`def_delegator(*ARGS)`, `def_delegators(*ARGS)`, `delegate(*pairs)`) hides which argument is the
+      # accessor and which a name, so the macro may define any name. A splat after the accessor of the list form is
+      # only a hidden name, and {#list_names} reads the literal names beside it.
+      def unplaceable_splat?(shape, arguments)
+        splats = arguments.each_index.select { |index| arguments[index].is_a?(Prism::SplatNode) }
+        return false if splats.empty?
+
+        shape != :list || splats.include?(0)
+      end
+
+      def alias_names(arguments)
+        return nil unless (2..3).cover?(arguments.size)
+
+        name = Literals.symbol_or_string(arguments.last)
+        name.nil? ? [[], true] : [[name], false]
+      end
+
+      def list_names(arguments)
+        return nil if arguments.empty?
+
+        rest = arguments.drop(1)
+        names = rest.filter_map { |argument| Literals.symbol_or_string(argument) }
+        [names, names.size != rest.size]
+      end
+
+      def hash_names(arguments)
+        return nil unless arguments.size == 1
+
+        hash = arguments.first
+        return nil unless hash.is_a?(Prism::KeywordHashNode) || hash.is_a?(Prism::HashNode)
+
+        names = []
+        open = false
+        hash.elements.each do |element|
+          return [[], true] unless element.is_a?(Prism::AssocNode)
+
+          keys = key_names(element.key)
+          keys.nil? ? (open = true) : names.concat(keys)
+        end
+        [names, open]
+      end
+
+      # The names a hash key spells — a literal name, or an array of them — or nil when any is computed.
+      def key_names(key)
+        elements = key.is_a?(Prism::ArrayNode) ? key.elements : [key]
+        names = elements.map { |element| Literals.symbol_or_string(element) }
+        names.include?(nil) ? nil : names
+      end
+    end
+  end
+end

data/lib/rigor/source/node_children.rb

@@ -109,6 +109,19 @@ module Rigor
       def each_child(node, &)
         node.rigor_each_child(&) if node.is_a?(Prism::Node)
       end
+
+      # #2455 — whether `root` nests deeper than `bound` levels, measured without recursion (the question is asked after
+      # the recursive walkers ran out of stack). Stops as soon as one path passes the bound.
+      def self.nested_deeper_than?(root, bound)
+        stack = [[root, 1]]
+        until stack.empty?
+          node, depth = stack.pop
+          return true if depth > bound
+
+          node.rigor_each_child { |child| stack << [child, depth + 1] }
+        end
+        false
+      end
     end
   end
 end

data/lib/rigor/type/acceptance_router.rb

@@ -6,8 +6,8 @@ module Rigor
     #
     # Every carrier's acceptance check is the same fixed forwarding on `self` —
     # `Inference::Acceptance.accepts(self, other, mode: mode)` — so it lived as an identical copy in
-    # fourteen carriers. The one exception is `Type::App`, which forwards on its reduced `bound` type rather
-    # than `self`; it keeps its own `accepts` and does not include this.
+    # every carrier that includes it. The one exception is `Type::App`, which forwards on its reduced `bound`
+    # type rather than `self`; it keeps its own `accepts` and does not include this.
     module AcceptanceRouter
       def accepts(other, mode: :gradual)
         Inference::Acceptance.accepts(self, other, mode: mode)

data/lib/rigor/type/accepts_result.rb

@@ -9,7 +9,7 @@ module Rigor
     # answer alongside the boundary mode the answer was computed under and an ordered list of textual
     # reasons describing which rules fired.
     #
-    # AcceptsResult is the dual of `SubtypeResult` (Slice 5+). Acceptance answers "is `other` passable to
+    # AcceptsResult is the dual of the planned `SubtypeResult`. Acceptance answers "is `other` passable to
     # `self` at a method-parameter or assignment boundary?", consulting the gradual-typing rules in
     # docs/type-specification/value-lattice.md when `mode` is `:gradual`, and the strict subset relation
     # when `mode` is `:strict`. Phase 2c ships full `:gradual` semantics; `:strict` is reserved for later

data/lib/rigor/type/app.rb

@@ -17,13 +17,11 @@ module Rigor
     # (use a plain type alias instead).
     #
     # `bound` is a `Rigor::Type` representing the value Rigor MUST erase to when this `App` cannot be
-    # reduced — registered at `%a{rigor:v1:hkt_register}` time, defaulting to
-    # `Rigor::Type::Dynamic[Rigor::Type::Top]` per ADR-20 D5 / WD2. It also drives the lattice probes
-    # (`top` / `bot` / `dynamic`) and the acceptance fallback while no reduction is wired (Slice 1).
+    # reduced — registered at `%a{rigor:v1:hkt_register}` time, defaulting to the untyped top per ADR-20 D5 /
+    # WD2. It also drives the lattice probes (`top` / `bot` / `dynamic`) and `accepts`.
     #
-    # Slice 1 ships the carrier as **opaque**: every operation delegates to `bound` since no reduction
-    # surface exists yet. Slice 2 introduces the conditional / indexed-access evaluator that reduces `App`
-    # to its registered body before delegating; the carrier shape stays identical.
+    # The carrier is opaque: those operations delegate to `bound`, and {#reduce} is the one path that unfolds
+    # the application to its registered body first (ADR-20 Slice 2a).
     #
     # Display form per ADR-20 OQ5: bare RBS-style `uri[arg1, arg2]`, not the wrapped `App[uri, [arg1,
     # arg2]]` faithful form. Two `App` values are structurally equal iff their `uri`, `args`, AND `bound`