rigortype 0.4.1 → 0.4.3

data/lib/rigor/inference/scope_indexer.rb

@@ -4,7 +4,10 @@ require "prism"
 
 require_relative "../scope"
 require_relative "../type"
+require_relative "../source/alias_names"
+require_relative "../source/literals"
 require_relative "../source/constant_path"
+require_relative "object_mixins"
 require_relative "../source/node_children"
 require_relative "../source/node_walker"
 require_relative "../source/parameter_envelope"
@@ -19,6 +22,9 @@ require_relative "last_line"
 require_relative "last_status"
 require_relative "error_info"
 require_relative "hash_lookup_mutation"
+require_relative "in_effect_refinements"
+require_relative "refine_census"
+require_relative "refine_self"
 require_relative "index_write_widening"
 require_relative "module_function_state"
 require_relative "multi_target_binder"
@@ -95,13 +101,17 @@ module Rigor
       #   bodies from their CONVERGED bindings so per-line probes
       #   (`rigor annotate`) reflect the post-writeback state, not the
       #   cap-N intermediate constants. Off for the check path.
+      # @param widen_clauses — check-path flag (issue #1231): a rescue or
+      #   `ensure` clause records the variables the `begin` body writes as
+      #   `Dynamic[top]`. Off for every other reader, so parameter inference
+      #   and sig-gen observe the clause's plain entry.
       # @return identity-comparing
       #   table whose default value is `default_scope`.
       # The no-op re-anchoring table (#722 residue 2): shared so the overwhelmingly common
       # nothing-to-re-anchor walk allocates none.
       EMPTY_RENAMES = {}.freeze
 
-      def index(root, default_scope:, converged_loop_recording: false) # rubocop:disable Metrics/AbcSize
+      def index(root, default_scope:, converged_loop_recording: false, widen_clauses: false) # rubocop:disable Metrics/AbcSize
         # Slice A-declarations. Build the declaration overrides first so every scope handed to the StatementEvaluator
         # already carries the table; structural sharing through `Scope#with_local` / `#with_fact` / `#with_self_type`
         # propagates it across every derived scope.
@@ -188,7 +198,8 @@ module Rigor
 
         on_enter = ->(node, scope) { table[node] = scope }
         StatementEvaluator.new(scope: seeded_scope, on_enter: on_enter,
-                               converged_loop_recording: converged_loop_recording).evaluate(root)
+                               converged_loop_recording: converged_loop_recording,
+                               widen_clauses: widen_clauses).evaluate(root)
 
         propagate(root, table, seeded_scope)
         table
@@ -2249,11 +2260,13 @@ module Rigor
       # @return the `program_globals` table and the census, keyed by the discovery index members it fills
       def build_program_global_index(root, default_scope)
         accumulator = {}
+        in_effect = InEffectRefinements.new(root)
         census = { patched_line_readers: Set.new, clears_last_status: false, defines_case_equality: false,
-                   write_census: GlobalWriteCensus::Collector.new }
+                   write_census: GlobalWriteCensus::Collector.new(in_effect) }
         gather_global_writes(root, default_scope, accumulator, census)
         census[:patched_line_readers] = census[:patched_line_readers].freeze
         census[:implicit_self_evidence] = LastLine::SelfEvidence.new(root)
+        census[:in_effect_refinements] = in_effect
         [accumulator.freeze, census]
       end
 
@@ -3245,8 +3258,10 @@ module Rigor
       # `possible_discovered_methods`, `contested_discovered_def_nodes` and
       # `contested_discovered_parameter_envelopes`, from the {Certainty} classification `certainty` (computed here
       # when the caller has none).
-      def build_methods_and_def_nodes(root, source_path = nil, certainty: Certainty.possible_nodes(root))
+      def build_methods_and_def_nodes(root, source_path = nil, certainty: Certainty.possible_nodes(root), census: nil)
         tables = MethodTables.new({}, {}, nil, certainty, true)
+        tables.root = root
+        tables.census = census
         def_nodes = {}
         walk_methods_and_def_nodes(root, [], false, tables, def_nodes, source_path)
         apply_alias_def_nodes(root, def_nodes, tables)
@@ -3263,8 +3278,79 @@ module Rigor
       # ADR-119 WD3 — `certainty` is the file's {Certainty} answer and `certain` whether the contribution being
       # recorded is certain ({#at} sets it before each recorder). `possible`, `contested_envelopes` and
       # `contested_def_nodes` are the siblings the recorders fill, each nil until a possible contribution writes it.
+      #
+      # Issue #1689 — `root` is the walked tree, and `in_effect` its {InEffectRefinements}, built the first time a
+      # `refine`-shaped call asks {#refine_target_of}, so a file without one never builds it.
+      #
+      # ADR-121 WD7 — `census`, when an Array, collects `[start offset, outcome]` for every `refine`-shaped node the
+      # walk accounts for ({ScopeIndexer.refine_census}); `refine_text` memoises the byte offsets of the `refine`
+      # words in the file's text, so a file with none skips every census scan and a `def` with none is not scanned;
+      # `literal_seen` holds the offsets of the refine literals a call's arguments already accounted for;
+      # `source_bytes` memoises the byte offsets of the file's heredoc openers; `loose_constants` memoises
+      # {ScopeIndexer.loose_constant_segments}. The module a `refine`-shaped node is charged to is what the in-effect
+      # walk worked out for it ({#refine_context}).
       MethodTables = Struct.new(:existence, :envelopes, :refinements, :certainty, :certain, :possible,
-                                :contested_envelopes, :contested_def_nodes) do
+                                :contested_envelopes, :contested_def_nodes, :root, :in_effect, :census,
+                                :refine_text, :literal_seen, :source_bytes, :loose_constants, :block_spans) do
+        # {ScopeIndexer.module_refine_target} against this tree's {InEffectRefinements}.
+        def refine_target_of(node)
+          return nil if ScopeIndexer.refine_target(node).nil?
+
+          ScopeIndexer.module_refine_target(node, in_effect_query)
+        end
+
+        # {InEffectRefinements#class_body_refine?} for a `refine` call of this tree.
+        def class_body_refine?(node) = ScopeIndexer.refine_call?(node) && in_effect_query.class_body_refine?(node)
+
+        def in_effect_query = (self.in_effect ||= InEffectRefinements.new(root))
+
+        # Does the walked file's text name `refine` as a word? Every census scan asks first, so a file that only says
+        # `refined` or `refinement` pays nothing for it.
+        def mentions_refine? = !refine_offsets.empty?
+
+        # Does the text in `[start, stop)` name `refine` as a word, or open a heredoc whose body (which follows the
+        # line, and so may end after `stop`) could? A `def` that does neither is not scanned.
+        def refine_in?(start, stop)
+          ScopeIndexer.offset_in?(refine_offsets, start, stop) ||
+            ScopeIndexer.offset_in?(self.source_bytes ||= ScopeIndexer.heredoc_offsets(root), start, stop)
+        end
+
+        # ADR-121 WD7 — the `self` the `refine`-shaped `node` runs on, as the in-effect walk worked it out
+        # ({InEffectRefinements#refine_context}); a module the walk cannot name for a node it did not record.
+        def refine_context(node) = in_effect_query.refine_context(node) || RefineSelf.unknown
+
+        # The byte offsets of each `refine` word in the file's text, ascending.
+        def refine_offsets
+          self.refine_text ||= ScopeIndexer.refine_word_offsets(root)
+        end
+
+        # Records that the walk accounted for the `refine`-shaped `node` with `outcome` (and the module it charged),
+        # when a census is taken.
+        def account(node, outcome, charged = nil)
+          census&.push([node.location.start_offset, outcome, charged])
+        end
+
+        # Marks a refine literal accounted for by its call, so the walk's descent does not account for it again.
+        def see_literal(node) = (self.literal_seen ||= Set.new) << node.location.start_offset
+
+        def literal_seen?(node) = !literal_seen.nil? && literal_seen.include?(node.location.start_offset)
+
+        # A6 — the last segments of the constants this file binds by `||=` or by a literal `const_set`, which the
+        # project-wide `constant_writers` a reader consults leaves out.
+        def loose_constant?(segment)
+          self.loose_constants ||= ScopeIndexer.loose_constant_segments(root)
+          loose_constants.include?(segment)
+        end
+
+        # Issue #1820 — does `node` sit inside a block or lambda of this tree? A block's `self` may be an object even in
+        # a class body or at the top level (`s.instance_eval { … }`, a `define_method` block). The spans are found once
+        # per file, on the first ask.
+        def in_block?(node)
+          self.block_spans ||= ScopeIndexer.block_spans(root)
+          offset = node.location.start_offset
+          block_spans.any? { |start, stop| offset >= start && offset < stop }
+        end
+
         # Sets {#certain} for the contribution `node` and returns the tables.
         def at(node)
           self.certain = !Certainty.possible?(certainty, node)
@@ -3295,7 +3381,121 @@ module Rigor
       end
 
       EMPTY_REFINEMENTS = {}.freeze
-      private_constant :EMPTY_REFINEMENTS
+      REFINEMENT_WILDCARD = Scope::DiscoveryIndex::REFINEMENT_WILDCARD
+      REFINE_WORD = /\brefine\b/
+      HEREDOC_OPENER = /<<[~-]?["'`A-Za-z_]/
+      private_constant :EMPTY_REFINEMENTS, :REFINEMENT_WILDCARD, :REFINE_WORD, :HEREDOC_OPENER
+
+      NO_OFFSETS = [].freeze
+      private_constant :NO_OFFSETS
+
+      # The byte offsets of the `refine` words in `root`'s text (none for no tree), which `MethodTables#refine_in?`
+      # matches node offsets against.
+      def refine_word_offsets(root) = pattern_offsets(root, REFINE_WORD)
+
+      # The byte offsets of the heredoc openers (`<<~ID`, `<<-ID`, `<<ID`, `<<"ID"`) in `root`'s text: a heredoc's body
+      # follows its line, so it may end after the `def` that opens it.
+      def heredoc_offsets(root) = pattern_offsets(root, HEREDOC_OPENER)
+
+      def pattern_offsets(root, pattern)
+        return NO_OFFSETS if root.nil?
+
+        # Byte-wise: a file may hold bytes its encoding does not (binary `__END__` data, a stray comment byte), and a
+        # regexp over such a String raises.
+        binary = root.send(:source).source.b
+        return NO_OFFSETS unless pattern.match?(binary)
+
+        offsets = []
+        position = 0
+        while (match = pattern.match(binary, position))
+          offsets << match.begin(0)
+          position = match.end(0)
+        end
+        offsets.freeze
+      end
+
+      # Is one of the ascending `offsets` in `[start, stop)`?
+      # The `[start, end)` byte span of every block and lambda in `root`.
+      def block_spans(root)
+        spans = []
+        return spans if root.nil?
+
+        Source::NodeWalker.each(root) do |node|
+          next unless node.is_a?(Prism::BlockNode) || node.is_a?(Prism::LambdaNode)
+
+          location = node.location
+          spans << [location.start_offset, location.end_offset]
+        end
+        spans
+      end
+
+      def offset_in?(offsets, start, stop)
+        index = offsets.bsearch_index { |offset| offset >= start }
+        !index.nil? && offsets[index] < stop
+      end
+
+      # A6 — the last segments of the constants `root` binds by `||=` (`K ||= String`, `A::K ||= …`) or by a
+      # `const_set` whose name is a literal (`Object.const_set(:K, String)`), and (issue #1749) by any write in a
+      # `class << …` body: the project-wide constant census files a write there under no name a `refine` argument
+      # spells, but a `def` in that body reads it lexically (`class << self; K = String; def setup = refine(K) {…}`).
+      # Scanned only for a file with a literal-target `refine`.
+      def loose_constant_segments(root)
+        segments = Set.new
+        Source::NodeWalker.each(root) do |node|
+          case node
+          when Prism::ConstantOrWriteNode then segments << node.name.to_s
+          when Prism::ConstantPathOrWriteNode then segments << node.target.name.to_s
+          when Prism::SingletonClassNode then singleton_constant_segments(node.body, segments)
+          when Prism::CallNode
+            name = node.name == :const_set && node.arguments&.arguments&.first
+            segments << name.unescaped if name.is_a?(Prism::SymbolNode) || name.is_a?(Prism::StringNode)
+          end
+        end
+        segments
+      end
+
+      # The last segment of every constant a write, an operator write or a multiple assignment target in `body` binds.
+      def singleton_constant_segments(body, segments)
+        return if body.nil?
+
+        Source::NodeWalker.each(body) do |node|
+          case node
+          when Prism::ConstantWriteNode, Prism::ConstantTargetNode, Prism::ConstantOperatorWriteNode,
+               Prism::ConstantAndWriteNode, Prism::ConstantPathTargetNode
+            segments << node.name.to_s
+          when Prism::ConstantPathWriteNode, Prism::ConstantPathOperatorWriteNode, Prism::ConstantPathAndWriteNode
+            segments << node.target.name.to_s
+          end
+        end
+      end
+
+      # ADR-121 WD7 — the census gate's view of one parsed file (`root`): `[refinement table, [[start offset,
+      # outcome], …]]`, one pair for every `refine`-shaped node the method walk accounted for. The outcomes are
+      # `:recorded` (a literal target and block, its names recorded; also one in a module's own singleton method,
+      # #1749), `:class_unknown` (a block whose target the walk cannot name), `:targets_wildcard` (a `refine` that
+      # runs once a method is called, other than a module's own singleton method's, or in a block that may rebind
+      # `self`, charged to its module or the wildcard), `:literal` (A3's `:refine` / eval-string literal), `:nested` (a
+      # `refine` in a refine body, or in a singleton method of one), `:dsl` (where `self` is a class, #1689) and
+      # `:raises` (no block, a Proc as the block, another receiver, or a computed target where `self` is `main`), and
+      # `:data` (a `:refine` literal where `self` is a plain class or one of its instances).
+      def refine_census(root)
+        census = []
+        refinements = build_methods_and_def_nodes(root, census: census)[3]
+        [refinements, census]
+      end
+
+      # ADR-121 WD7 (issue #1814) — the refinement table one parsed file contributes: the census of
+      # {#build_methods_and_def_nodes}, whose fourth table is the project walk's own (`seed_discovered_methods` and
+      # `walk_def_contributions` take it from the same call), run for a caller that wants nothing else. The gem source
+      # walker reads a gem file this way, so a gem module's rows carry the wildcards a project module's would
+      # (`walker_walk_census_parity_spec.rb`, beside the walker's specs, holds the two to one table). A file whose text
+      # never names `refine` as a word records no row, so it is not walked. `source_path` names an anonymous module's
+      # row (`#<Module:<path>:L:C>`) as the project walk does, so two files' bare `Module.new` blocks never share one.
+      def refinement_table(root, source_path = nil)
+        return EMPTY_REFINEMENTS if refine_word_offsets(root).empty?
+
+        build_methods_and_def_nodes(root, source_path)[3]
+      end
 
       # Issue #1120 — a refinement table, deep-frozen; the shared empty table when nothing was recorded.
       def freeze_refinements(table)
@@ -3319,8 +3519,7 @@ module Rigor
       # implicit- or `self`-receiver `refine` with one constant argument and a literal block. A computed target
       # (`refine(klass) { … }`) names no class this walk can key, so its body walks as it did before.
       def refine_target(node)
-        return nil unless node.name == :refine && node.block.is_a?(Prism::BlockNode)
-        return nil unless node.receiver.nil? || node.receiver.is_a?(Prism::SelfNode)
+        return nil unless refine_call?(node)
 
         arguments = node.arguments&.arguments
         return nil unless arguments&.size == 1
@@ -3329,27 +3528,239 @@ module Rigor
         target if target.is_a?(Prism::ConstantReadNode) || target.is_a?(Prism::ConstantPathNode)
       end
 
+      # An implicit- or `self`-receiver `refine` call with a literal block, whatever its argument.
+      def refine_call?(node)
+        node.name == :refine && node.block.is_a?(Prism::BlockNode) &&
+          (node.receiver.nil? || node.receiver.is_a?(Prism::SelfNode))
+      end
+
+      # Issue #1689 — {#refine_target}, for a call that `in_effect` (its file's {InEffectRefinements}) does not place
+      # where `self` is a class. `Class` undefines `refine`, so `refine X do … end` directly in a `class` body is the
+      # class's own method (a DSL), and its block walks as any other block. Every walk that treats a refine body
+      # specially asks this, so the method tables, the in-effect refinements and the typer agree on which calls are
+      # refine bodies.
+      def module_refine_target(node, in_effect)
+        target = refine_target(node)
+        target unless target.nil? || in_effect.class_body_refine?(node)
+      end
+
       # Issue #1120 — records the instance `def`s of a `refine X do … end` body as refinement methods of X, keyed by
-      # the refining module (`owner_prefix`, the `self` the `refine` call runs on). X is resolved LEXICALLY
+      # the refining module (`refining`, the `self` the `refine` call runs on). X is resolved LEXICALLY
       # (`qualified_prefix`), which is where Ruby resolves the argument even inside a `Module.new { … }` block
       # whose `self` is anonymous; every name it can denote is recorded, as {#constant_receiver_candidates}
       # explains. Nothing in the body reaches the class tables: `refine String do def shout` does not give
       # `String` or the refining module a `shout` outside a `using`.
-      def record_refinement_defs(node, target, qualified_prefix, owner_prefix, tables)
+      #
+      # ADR-121 WD7 (issue #1799) — the names are what {RefineCensus.read_body} reads (`def`, `alias`,
+      # `alias_method`, `define_method`, `attr_*`, `undef`), and a body that may define a name it cannot spell adds a
+      # names-wildcard row per target. `refining` is `""` at the top level (where Ruby raises). The body is not
+      # walked any further, so the census scans it here.
+      #
+      # A6 — a target this file binds by `||=` or a literal `const_set` (`K ||= String; refine(K)`) names whatever value
+      # the write holds, so its names go under the wildcard class, as a computed target's do.
+      def record_refinement_defs(node, target, qualified_prefix, refining, tables)
+        loose = tables.loose_constant?(target.name.to_s)
+        tables.account(node, loose ? :class_unknown : :recorded, census_charge(refining))
         body = node.block.body
         return if body.nil?
 
-        refining = owner_prefix.join("::")
-        targets = constant_receiver_candidates(target, qualified_prefix)
-        each_refinement_def(body) do |def_node|
-          targets.each do |class_name|
-            methods = ((tables.refinements ||= {})[class_name] ||= {})
-            modules = (methods[def_node.name] ||= [])
-            modules << refining unless modules.include?(refining)
+        targets = loose ? [REFINEMENT_WILDCARD] : constant_receiver_candidates(target, qualified_prefix)
+        reading = RefineCensus.read_body(body)
+        refining.each do |owner|
+          tables.refinements = RefineCensus.record_rows(tables.refinements, targets, reading, owner)
+        end
+        census_scan(body, qualified_prefix, tables, refine_body: true) if tables.mentions_refine?
+      end
+
+      # What the census records as charged for `owners`: the one module, or every name.
+      def census_charge(owners) = owners.size == 1 ? owners.first : owners
+
+      # ADR-121 WD7 — a literal-target `refine X do … end` the module-body walk reaches, charged where the in-effect
+      # walk says it runs ({MethodTables#refine_context}): rows for the module it names (the walk's own name for an
+      # anonymous `Module.new` block, `""` at the top level), or a targets-wildcard for that module (the wildcard
+      # where it cannot be named) when it runs only once a method is called or on a module the walk cannot name.
+      def record_literal_target_refine(node, target, qualified_prefix, owner_prefix, tables)
+        context = tables.refine_context(node)
+        here = context.here
+        return record_refinement_defs(node, target, qualified_prefix, [""], tables) if here == RefineSelf::MAIN
+        if context.deferred || here == REFINEMENT_WILDCARD
+          return record_deferred_refine(node, RefineSelf.charged_modules(context), qualified_prefix, tables)
+        end
+
+        record_refinement_defs(node, target, qualified_prefix, census_owners(context, owner_prefix), tables)
+      end
+
+      # The modules a `refine` charged to `context` refines for; an anonymous `Module.new` block's is named by its
+      # position (`owner_prefix`).
+      def census_owners(context, owner_prefix)
+        context.here == RefineSelf::ANONYMOUS ? [owner_prefix.join("::")] : RefineSelf.charged_modules(context)
+      end
+
+      # ADR-121 WD7 — a targets-wildcard for each of `owners`, as a `refine` that runs once a method is called records
+      # (an instance `def`, a `define_method` or `define_singleton_method` block; a module's own singleton method
+      # records rows instead, #1749). The body is not walked any further, so the census scans it here.
+      def record_deferred_refine(node, owners, qualified_prefix, tables)
+        tables.account(node, :targets_wildcard, census_charge(owners))
+        owners.each { |owner| record_targets_wildcard(tables, owner) }
+        body = node.block.body
+        census_scan(body, qualified_prefix, tables, refine_body: true) if body && tables.mentions_refine?
+      end
+
+      # ADR-121 WD7 — a `refine`-shaped call the canonical arm ({#refine_target}) does not take: on another receiver
+      # (`Module#refine` is private, so it raises), where `self` is a class (#1689's DSL), with no literal block (no
+      # block raises, and so does a Proc passed as one), or with a target the walk cannot name (`refine(k)`,
+      # `refine(self)`, `refine(K.dup)`). The last records the body's names under the wildcard class, so they decline
+      # on every receiver, and a names-wildcard row when they are incomplete, which makes the module opaque; one that
+      # runs once a method is called, or on a module the walk cannot name, records a targets-wildcard. At the top
+      # level `self` is `main`, which has no `refine`.
+      def account_other_refine(node, owner_prefix, tables)
+        context = tables.refine_context(node)
+        outcome, charged =
+          if tables.class_body_refine?(node) || context.here == RefineSelf::CLASS then :dsl
+          elsif !RefineCensus.self_call?(node) || !node.block.is_a?(Prism::BlockNode) ||
+                context.here == RefineSelf::MAIN
+            :raises
+          elsif context.deferred || context.here == REFINEMENT_WILDCARD
+            owners = RefineSelf.charged_modules(context)
+            owners.each { |owner| record_targets_wildcard(tables, owner) }
+            [:targets_wildcard, census_charge(owners)]
+          else
+            owners = census_owners(context, owner_prefix)
+            owners.each { |owner| record_unreadable_target(node, owner, tables) }
+            [:class_unknown, census_charge(owners)]
+          end
+        tables.account(node, outcome, charged)
+      end
+
+      def record_unreadable_target(node, owner, tables)
+        tables.refinements = RefineCensus.record_rows(tables.refinements, [REFINEMENT_WILDCARD],
+                                                      RefineCensus.read_body(node.block.body), owner)
+      end
+
+      # `{"*" => {"*" => [owner]}}`: some `refine` of `owner` (every module, for the wildcard) is unreadable.
+      def record_targets_wildcard(tables, owner)
+        tables.refinements = RefineCensus.add_row(tables.refinements || {}, REFINEMENT_WILDCARD, REFINEMENT_WILDCARD,
+                                                  owner)
+      end
+
+      # ADR-121 WD7 — the census over a subtree the method walk does not descend (a `def` body, a refine body), each
+      # node charged where the in-effect walk says it runs. `refine_body` says `self` is the refinement itself, where a
+      # nested `refine` refines for the refinement and only makes the body's names incomplete (§2.2).
+      def census_scan(node, qualified_prefix, tables, refine_body: false)
+        case node
+        when Prism::DefNode, Prism::ClassNode, Prism::ModuleNode, Prism::SingletonClassNode
+          refine_body = false
+        when Prism::CallNode
+          if (target = own_method_refine_target(node, tables))
+            return record_own_method_refine(node, target, qualified_prefix, tables)
+          end
+
+          census_call(node, qualified_prefix, tables, refine_body)
+        when Prism::SymbolNode
+          census_symbol(node, tables)
+        end
+        node.rigor_each_child { |child| census_scan(child, qualified_prefix, tables, refine_body: refine_body) }
+      end
+
+      # ADR-121 WD7 (issue #1749) — the target of a canonical `refine X do … end` ({#refine_target}) in a module's own
+      # singleton method (`def self.x`, a `def` in the module's `class << self`, or a block there that keeps `self`),
+      # else nil. `self` is the module itself there, so the call refines X for it once the method is called. Anything
+      # else in a method body (an instance `def`, a `define_method` or `define_singleton_method` block, a computed
+      # target, a block that may rebind `self`) charges a targets-wildcard in {#census_call}, and a `refine` in a refine
+      # body is nested there, whichever method it sits in: its context ({RefineSelf.refinement_body}) is not an
+      # own method's.
+      def own_method_refine_target(node, tables)
+        return nil if node.name != :refine
+
+        target = tables.refine_target_of(node)
+        target if target && tables.refine_context(node).own_method
+      end
+
+      # Records `node` as the refine of its module, as a `refine` in the module body is recorded, with the refined
+      # class marked as that one is ({#record_refinement}). The call's block is scanned here, so {#census_scan} does
+      # not descend into it.
+      def record_own_method_refine(node, target, qualified_prefix, tables)
+        record_refinement(node, qualified_prefix, tables)
+        owners = RefineSelf.charged_modules(tables.refine_context(node))
+        record_refinement_defs(node, target, qualified_prefix, owners, tables)
+      end
+
+      def census_call(node, qualified_prefix, tables, refine_body)
+        census_literal_arguments(node, qualified_prefix, tables)
+        return unless node.name == :refine
+
+        context = tables.refine_context(node)
+        nested = refine_body || context.here == RefineSelf::REFINEMENT
+        outcome, charged =
+          if tables.class_body_refine?(node) || context.here == RefineSelf::CLASS then :dsl
+          elsif nested && RefineCensus.self_call?(node) then :nested
+          elsif !RefineCensus.self_call?(node) || node.block.nil? || context.here == RefineSelf::MAIN then :raises
+          else
+            owners = RefineSelf.charged_modules(context)
+            owners.each { |owner| record_targets_wildcard(tables, owner) }
+            [:targets_wildcard, census_charge(owners)]
           end
+        tables.account(node, outcome, charged)
+      end
+
+      # A3 — a `:refine` Symbol argument of any call, or a String argument holding `refine` of an eval, `send` or
+      # method-naming call, records a targets-wildcard for the module the call runs `refine` on: the receiver of a
+      # `send` or `*_eval` (each name a constant one can denote), else the module the in-effect walk says `self` is
+      # there. Where `self` is a plain class or one of its instances, a literal charged to `self` is data.
+      def census_literal_arguments(node, qualified_prefix, tables)
+        arguments = node.arguments&.arguments
+        return if arguments.nil?
+
+        strings = RefineCensus.string_literal_call?(node)
+        arguments.each do |argument|
+          next unless RefineCensus.refine_symbol?(argument) || (strings && RefineCensus.refine_string?(argument))
+          next if tables.literal_seen?(argument)
+
+          tables.see_literal(argument)
+          census_literal_argument(node, argument, qualified_prefix, tables)
+        end
+      end
+
+      def census_literal_argument(call, literal, qualified_prefix, tables)
+        target = RefineCensus.literal_target(call)
+        context = tables.refine_context(literal)
+        return tables.account(literal, :data) if target == :self && context.literal == RefineSelf::CLASS
+        return tables.account(literal, :nested) if target == :self && context.literal == RefineSelf::REFINEMENT
+
+        owners = literal_owners(call, target, RefineSelf.charged_modules(context, literal: true), qualified_prefix)
+        owners.each { |owner| record_targets_wildcard(tables, owner) }
+        tables.account(literal, :literal, target == :self ? census_charge(owners) : [:receiver, owners])
+      end
+
+      def literal_owners(call, target, self_modules, qualified_prefix)
+        case target
+        when :self then self_modules
+        when :unknown then [REFINEMENT_WILDCARD]
+        else
+          receiver = call.receiver
+          names = constant_shaped?(receiver) ? constant_receiver_candidates(receiver, qualified_prefix) : []
+          names.empty? ? [REFINEMENT_WILDCARD] : names
         end
       end
 
+      def constant_shaped?(node) = node.is_a?(Prism::ConstantReadNode) || node.is_a?(Prism::ConstantPathNode)
+
+      # A3 — a `:refine` Symbol anywhere else (`alias my_refine refine`, `%i[refine]`, a hash) names `Module#refine`
+      # for code the walk cannot follow, run on the module the in-effect walk says `self` is there; where `self` is a
+      # plain class or one of its instances it is data.
+      def census_symbol(node, tables)
+        return unless RefineCensus.refine_symbol?(node) && !tables.literal_seen?(node)
+
+        tables.see_literal(node)
+        context = tables.refine_context(node)
+        return tables.account(node, :data) if context.literal == RefineSelf::CLASS
+        return tables.account(node, :nested) if context.literal == RefineSelf::REFINEMENT
+
+        owners = RefineSelf.charged_modules(context, literal: true)
+        owners.each { |owner| record_targets_wildcard(tables, owner) }
+        tables.account(node, :literal, census_charge(owners))
+      end
+
       # The instance `def`s a refine body defines on the refined class: nested declarations open their own
       # scope, and a `def self.x` or a `def` inside another `def` defines nothing on it.
       def each_refinement_def(node, &)
@@ -3503,6 +3914,9 @@ module Rigor
             # `self::` header under a REBOUND self (eval/meta-new body) names
             # `owner::Name` instead.
             child_cref = unnameable_decl?(node, self_decl, singleton_cref)
+            if node.is_a?(Prism::ClassNode) && node.superclass && methods_acc.mentions_refine?
+              census_scan(node.superclass, qualified_prefix, methods_acc)
+            end
             record_declaration_facts(node, child_prefix, methods_acc.at(node)) unless child_cref
             body_prefix = child_cref ? [] : child_prefix
             if node.body
@@ -3519,6 +3933,10 @@ module Rigor
           # still decline. The lexical cref below is unnameable in every case.
           singleton_prefix = singleton_body_prefix(node, in_singleton_class, owner_prefix,
                                                    qualified_prefix)
+          tables = methods_acc.at(node)
+          if !node.expression.is_a?(Prism::SelfNode) || tables.in_block?(node)
+            record_singleton_body_prepends(node, qualified_prefix, tables)
+          end
           walk_methods_and_def_nodes(node.expression, qualified_prefix, in_singleton_class,
                                      methods_acc, def_nodes_acc, source_path, def_owner_prefix,
                                      singleton_cref: singleton_cref,
@@ -3536,6 +3954,7 @@ module Rigor
           return
         when Prism::ConstantWriteNode, Prism::ConstantPathWriteNode, Prism::ConstantOrWriteNode,
              Prism::ConstantPathOrWriteNode
+          record_meta_superclass(node, qualified_prefix, def_owner_prefix, methods_acc.at(node))
           if (split = meta_new_block_split(node, qualified_prefix, def_owner_prefix, singleton_cref))
             enclosing, body, body_self = split
             # A meta-new block rebinds only `self` — `Module.nesting` stays lexical — so
@@ -3572,6 +3991,11 @@ module Rigor
           # receiver, a singleton nothing names) or any ownerless prefix under an unnameable
           # cref — is NOT top level; `record_def_node` would file the def under `<toplevel>`
           # where an implicit-self call could find a method Ruby never installed there.
+          location = node.location
+          if methods_acc.mentions_refine? && methods_acc.refine_in?(location.start_offset, location.end_offset)
+            node.rigor_each_child { |child| census_scan(child, qualified_prefix, methods_acc) }
+          end
+          record_foreign_singleton_def(node, qualified_prefix, owner_prefix, methods_acc.at(node))
           unless def_owner_prefix&.empty? || defs_singleton == :unnameable ||
                  (singleton_cref && owner_prefix.empty?)
             singleton_def = in_singleton_class || defs_singleton
@@ -3581,13 +4005,17 @@ module Rigor
           end
           return
         when Prism::AliasMethodNode, Prism::UndefNode
+          census_scan(node, qualified_prefix, methods_acc) if methods_acc.mentions_refine?
           unless def_owner_prefix&.empty? || defs_singleton == :unnameable ||
                  (singleton_cref && owner_prefix.empty?)
             record_alias_or_undef(node, owner_prefix, in_singleton_class || defs_singleton,
                                   methods_acc.at(node))
           end
           return
+        when Prism::SymbolNode
+          census_symbol(node, methods_acc) if methods_acc.mentions_refine?
         when Prism::CallNode
+          census_literal_arguments(node, qualified_prefix, methods_acc) if methods_acc.mentions_refine?
           if receiver_eval_call?(node)
             return walk_eval_methods_and_defs(node, qualified_prefix, in_singleton_class, methods_acc,
                                               def_nodes_acc, source_path, def_owner_prefix,
@@ -3596,11 +4024,16 @@ module Rigor
           end
           anonymous = record_call_node_methods(node, owner_prefix, in_singleton_class, methods_acc.at(node),
                                                source_path)
+          tables = methods_acc.at(node)
+          record_singleton_prepend(node, qualified_prefix, tables,
+                                   self_ok: node.name == :prepend && tables.in_block?(node))
           # Issue #1120 — a refine body's defs go to the refinement table and nowhere else.
-          if (target = refine_target(node))
-            return record_refinement_defs(node, target, qualified_prefix, owner_prefix, methods_acc)
+          if (target = methods_acc.refine_target_of(node))
+            return record_literal_target_refine(node, target, qualified_prefix, owner_prefix, methods_acc)
           end
 
+          account_other_refine(node, owner_prefix, methods_acc) if node.name == :refine
+
           if anonymous
             walk_anonymous_meta_block(node, anonymous, qualified_prefix, in_singleton_class, methods_acc,
                                       def_nodes_acc, source_path, def_owner_prefix,
@@ -3666,8 +4099,24 @@ module Rigor
       end
 
       # The block form of a meta-new constant write: its members, and the module mark `Module.new` earns.
+      # Issue #1820 — `K = Class.new(Parent)`, with or without a block, names a class whose superclass the superclass
+      # table leaves out; it takes {Scope::DiscoveryIndex::ENVELOPE_META_SUPERCLASS_MARK}.
+      def record_meta_superclass(node, qualified_prefix, self_base, tables)
+        rvalue = meta_new_rvalue(node)
+        return unless class_new_call?(rvalue) && !(rvalue.arguments&.arguments || []).empty?
+
+        child_prefix = meta_new_child_prefix(node, qualified_prefix, self_base)
+        return if child_prefix.nil? || child_prefix.empty?
+
+        record_surface_mark(tables, child_prefix.join("::"), Scope::DiscoveryIndex::ENVELOPE_META_SUPERCLASS_MARK)
+      end
+
       def record_meta_new_facts(rvalue, child_prefix, tables)
         record_meta_members(rvalue, child_prefix, tables)
+        # `Module.new(&BODY)`: the body runs on the new module but cannot be read, so its surface is unknown (#1816).
+        if rvalue.block.is_a?(Prism::BlockArgumentNode)
+          record_surface_mark(tables, child_prefix.join("::"), Scope::DiscoveryIndex::ENVELOPE_DYNAMIC_MARK)
+        end
         return unless module_new_call?(rvalue)
 
         record_surface_mark(tables, child_prefix.join("::"), Scope::DiscoveryIndex::ENVELOPE_MODULE_MARK)
@@ -3700,7 +4149,7 @@ module Rigor
       def record_alias_method_call(call_node, qualified_prefix, in_singleton_class, accumulator)
         return if qualified_prefix.empty?
 
-        names = alias_method_call_names(call_node)
+        names = Source::AliasNames.alias_method_call_names(call_node)
         return if names.nil?
 
         kind = in_singleton_class ? :singleton : :instance
@@ -3807,7 +4256,9 @@ module Rigor
       # other two. {#meta_new_block_call} owns both unwrappings; every walk asks it, so no spelling can be
       # recognised by one pass and missed by another.
       def meta_new_block_body(node)
-        meta_new_block_call(node)&.block&.body
+        block = meta_new_block_call(node)&.block
+        # A `&BODY` / `&:sym` block ARGUMENT is not a literal block: its body is unreadable here (#1816).
+        block.body if block.is_a?(Prism::BlockNode)
       end
 
       # The class-creating call a constant write's rvalue ultimately is, or nil when the write is not the idiom.
@@ -4061,16 +4512,57 @@ module Rigor
         return if def_node.body.nil?
 
         Source::NodeWalker.each(def_node.body) do |node|
+          if node.is_a?(Prism::SingletonClassNode)
+            record_singleton_body_prepends(node, qualified_prefix, tables)
+            next
+          end
           next unless node.is_a?(Prism::CallNode)
 
           if node.name == :extend
             record_object_extension(node, qualified_prefix, tables)
           elsif SURFACE_EVAL_CALLS.include?(node.name) || SURFACE_NAMING_CALLS.include?(node.name)
             record_body_rewrite(node, qualified_prefix, tables)
+          else
+            record_singleton_prepend(node, qualified_prefix, tables, self_ok: true)
           end
         end
       end
 
+      # Issue #1820 — `obj.singleton_class.prepend(M)`, or `prepend M` in a `class << obj` body, puts `M` ahead of
+      # `obj`'s class even when the class already includes it (`prepend` re-inserts it; `extend` would not), so
+      # `M`'s refinement answers first for that object. `M` takes {Scope::DiscoveryIndex::ENVELOPE_OBJECT_EXTENDED_MARK},
+      # the mark an `extend` in a method body already leaves: an object of any class may carry its instance methods
+      # ahead of its class's own. A `singleton_class` of `self` (and a `class << self` body, which the caller leaves
+      # out) written directly in a class or module body or at the top level is the class object's or `main`'s, not an
+      # instance's; in a method body or any block (`self_ok`), where `self` may be an object, it counts.
+      # `singleton_body` says the call sits in a `class << obj` body.
+      def record_singleton_prepend(node, qualified_prefix, tables, singleton_body: false, self_ok: false)
+        return unless node.name == :prepend
+
+        receiver = node.receiver
+        singleton = singleton_body && (receiver.nil? || receiver.is_a?(Prism::SelfNode))
+        singleton ||= singleton_class_call?(receiver, self_ok)
+        record_object_extension(node, qualified_prefix, tables) if singleton
+      end
+
+      def singleton_class_call?(receiver, self_ok)
+        return false unless receiver.is_a?(Prism::CallNode) && receiver.name == :singleton_class
+        return false unless receiver.arguments.nil?
+
+        object = receiver.receiver
+        self_ok || !(object.nil? || object.is_a?(Prism::SelfNode))
+      end
+
+      def record_singleton_body_prepends(node, qualified_prefix, tables)
+        return if node.body.nil?
+
+        Source::NodeWalker.each(node.body) do |inner|
+          next unless inner.is_a?(Prism::CallNode)
+
+          record_singleton_prepend(inner, qualified_prefix, tables, singleton_body: true, self_ok: true)
+        end
+      end
+
       def record_body_rewrite(node, qualified_prefix, tables)
         receiver = node.receiver
         if receiver.is_a?(Prism::ConstantReadNode) || receiver.is_a?(Prism::ConstantPathNode)
@@ -4243,6 +4735,50 @@ module Rigor
         acc[:deferred_ranges][path] = build_deferred_ranges(root)
         record_class_sources(acc[:class_sources], path, root, superclasses, includes, file_def_nodes,
                              acc[:compact_headers])
+        record_singleton_class_sources(acc[:singleton_class_sources], path, root)
+      end
+
+      # `{name => Set[path]}` for a bundle's name list (a bundle written before the list existed has none).
+      def bundle_path_sets(names, path) = (names || []).to_h { |name| [name, Set[path]] }
+
+      # Issue #1752 — the constants a `class << Const` body opens in this file, and those whose singleton side a call
+      # there may rewrite ({#singleton_side_call?}). Such a body records facts about
+      # `Const`'s singleton class (a `remove_method`, a `def`) without declaring `Const`, so it stays out of
+      # `class_sources` (whose readers take a name there as one the project declares) and joins only the per-file
+      # class-declaration sets the incremental `class:` edges diff (`Runner#class_declarations`).
+      def record_singleton_class_sources(sources, path, root)
+        collect_singleton_class_targets(root, []) { |name| (sources[name] ||= Set.new) << path }
+      end
+
+      def collect_singleton_class_targets(node, lexical_prefix, &)
+        case node
+        when Prism::ClassNode, Prism::ModuleNode
+          prefix = Source::ConstantPath.declaration_prefix(lexical_prefix, node.constant_path)
+          node.body && prefix && collect_singleton_class_targets(node.body, prefix, &)
+          return
+        when Prism::SingletonClassNode
+          rendered = singleton_receiver_constant_name(node.expression)
+          yield eval_constant_receiver_prefix(node, node.expression, rendered, lexical_prefix).join("::") if rendered
+        when Prism::CallNode
+          yield_singleton_side_constant(node, node.receiver, lexical_prefix, &) if singleton_side_call?(node)
+        end
+        node.rigor_each_child { |child| collect_singleton_class_targets(child, lexical_prefix, &) }
+      end
+
+      # A call on a constant that may rewrite its singleton side (`Const.singleton_class`,
+      # `Const.define_singleton_method`, `Const.extend(M)`, `Const.instance_eval { … }`) records facts about `Const`'s
+      # singleton methods the refinement walk reads from a file that need not declare `Const`, so the file joins the
+      # constant's set too. Written inside `Const`'s own body, the name is in the file's set already; a `def Const.x`
+      # files its own `method:` key.
+      def singleton_side_call?(node)
+        node.name == :singleton_class || surface_rewriting_call?(node)
+      end
+
+      def yield_singleton_side_constant(node, receiver, lexical_prefix)
+        return unless receiver.is_a?(Prism::ConstantReadNode) || receiver.is_a?(Prism::ConstantPathNode)
+
+        rendered = singleton_receiver_constant_name(receiver)
+        yield eval_constant_receiver_prefix(node, receiver, rendered, lexical_prefix).join("::") if rendered
       end
 
       def build_deferred_ranges(root)
@@ -5875,6 +6411,7 @@ module Rigor
       def mixin_tables(root)
         accumulator = MixinAccumulator.new
         accumulator.direct_body(program_statements(root))
+        accumulator.program_body(program_statements(root))
         walk_class_includes(root, [], nil, accumulator)
         {
           includes: freeze_mixin_lists(accumulator, :include),
@@ -6029,7 +6566,7 @@ module Rigor
           walk_class_includes(arg, qualified_prefix, current_class, accumulator,
                               singleton_self: singleton_self, singleton_cref: singleton_cref)
         end
-        if (body = call.block&.body)
+        if (body = meta_new_block_body(node))
           walk_class_includes(body, qualified_prefix, meta_owner, accumulator,
                               singleton_cref: body_cref)
         end
@@ -6083,6 +6620,7 @@ module Rigor
         kind, _arguments, via_send = mixin_call_view(node)
         return if kind.nil?
 
+        current_class ||= toplevel_include_owner(node, qualified_prefix, current_class, accumulator)
         effects = mixin_effects(node, kind, qualified_prefix, current_class, accumulator, in_singleton: false)
                   .select { |_owner, side| side == :include }
         return if effects.empty?
@@ -6263,6 +6801,25 @@ module Rigor
         node.name == :prepend
       end
 
+      # Issue #1697 — a receiverless `include M` written as a statement of the file's own top level is
+      # `main.include`, which is `Object.include`: it mixes M into `Object`. It is recorded under its own
+      # owner key, `ObjectMixins::TOPLEVEL_INCLUDE_KEY`, rather than on `Object`, so it rides every table an include
+      # rides (the declaration signature, `discovered_class_sources`, the seed bundle) while no ancestry
+      # walk that types a call reaches it: what Ruby reaches first for a name such an include supplies
+      # depends on more than the chain shows (a block that rebinds `self`, an `extend` or a singleton `def`
+      # on `main`), so only the diagnostic silences read it (`Inference::ObjectMixins`), and typing is
+      # issue #1715's. Only a direct program statement counts.
+      # The same call inside a top-level block, a method body or a conditional stays unrecorded, as before:
+      # its `self` may not be `main` (a `describe do include M end` or `class_exec` block rebinds it, while
+      # `[1].each do include M end` does not, and the walk cannot tell them apart), and it may not run. `main`
+      # has no `prepend`, and a top-level `extend M` reaches `main`'s singleton alone, so neither is recorded.
+      def toplevel_include_owner(node, qualified_prefix, current_class, accumulator)
+        return nil unless current_class.nil? && qualified_prefix.empty?
+        return nil unless node.receiver.nil? && node.name == :include
+
+        accumulator.program_statement?(node) ? ObjectMixins::TOPLEVEL_INCLUDE_KEY : nil
+      end
+
       # Issue #1123 — the class a `Recv.prepend(M)` call form targets, as the qualified name the prepend
       # table is keyed by, or nil when the receiver names no static class. The receiver is a constant READ
       # at the call site, so it resolves in the `Module.nesting` the call is written in — the same rule (and
@@ -6581,7 +7138,7 @@ module Rigor
                              in_singleton: in_singleton, singleton_self: singleton_self,
                              singleton_cref: singleton_cref)
         end
-        if (body = call.block&.body)
+        if (body = meta_new_block_body(node))
           walk_class_extends(body, qualified_prefix, meta_owner, accumulator,
                              singleton_cref: body_cref)
         end
@@ -6653,6 +7210,7 @@ module Rigor
         return record_module_function(node, current_class, accumulator, in_singleton) if node.name == :module_function
 
         taint_opaque_eval(node, current_class, accumulator)
+        return if singleton_class_rewrite_tainted?(node, qualified_prefix, current_class, accumulator)
 
         kind, _arguments, via_send = mixin_call_view(node)
         return if kind.nil?
@@ -6665,6 +7223,49 @@ module Rigor
         effects.each { |owner, side| accumulator.taint(owner, side) }
       end
 
+      # Issue #1752 — a call that rewrites a singleton class reached through `singleton_class` (`singleton_class.
+      # class_eval { def x }`, `singleton_class.send(:define_method, :x)`, `Const.singleton_class.prepend(M)`,
+      # `Const.singleton_class.send(:include, M)`) puts methods or modules on that singleton class that no edge
+      # records, so its singleton side is unpositioned: the owner is the enclosing class for a bare or `self.`
+      # receiver, else the constant. True when it tainted.
+      def singleton_class_rewrite_tainted?(node, qualified_prefix, current_class, accumulator)
+        receiver = node.receiver
+        return false unless singleton_class_of_receiver?(receiver) && surface_rewriting_call?(node)
+        return false if singleton_class_named_call?(node)
+
+        owner = singleton_class_owner(node, receiver.receiver, qualified_prefix, current_class)
+        return false if owner.nil?
+
+        accumulator.taint(owner, :extend)
+        true
+      end
+
+      # A bare, `self.` or constant receiver's `singleton_class` call.
+      def singleton_class_of_receiver?(receiver)
+        receiver.is_a?(Prism::CallNode) && receiver.name == :singleton_class && receiver.arguments.nil?
+      end
+
+      # An `attr_*` on a singleton class (`singleton_class.attr_accessor :conf`) rewrites only the names it spells, so
+      # it makes those names' singleton envelopes opaque ({#record_singleton_class_names}) and leaves the rest of the
+      # singleton side readable. An `attr_*` with a name it does not spell as a literal (`attr_accessor(*KEYS)`, a
+      # block's variable), and an `alias_method` or `define_method` there, still taint the side: the own-definer read
+      # would otherwise answer the body Ruby replaced (`definer_resolution_witness_spec.rb`).
+      def singleton_class_named_call?(node)
+        arguments = node.arguments&.arguments || []
+        ATTR_MACROS.include?(node.name) && !arguments.empty? &&
+          arguments.all? { |argument| literal_method_name(argument) }
+      end
+
+      def singleton_class_owner(node, object, qualified_prefix, current_class)
+        return current_class if object.nil? || object.is_a?(Prism::SelfNode)
+
+        rendered = Source::ConstantPath.qualified_name_or_nil(object)
+        return nil if rendered.nil?
+        return rendered if Source::ConstantPath.rooted?(object) || qualified_prefix.empty?
+
+        eval_constant_receiver_prefix(node, object, rendered, qualified_prefix).join("::")
+      end
+
       # The bare `module_function` toggle: the module extends itself. A direct statement only.
       def record_module_function(node, current_class, accumulator, in_singleton)
         return unless current_class && node.receiver.nil? && !in_singleton && ModuleFunctionState.extends_self?(node)
@@ -7149,9 +7750,7 @@ module Rigor
       end
 
       def visibility_target_name(arg)
-        return arg.unescaped.to_sym if arg.is_a?(Prism::SymbolNode) || arg.is_a?(Prism::StringNode)
-
-        nil
+        Source::Literals.symbol_or_string(arg)
       end
 
       # Registers the alias name in the `discovered_methods` table so `undefined-method` diagnostics are not emitted for
@@ -7179,10 +7778,24 @@ module Rigor
         class_name = qualified_prefix.join("::")
         undef_node.names.each do |name|
           method_name = literal_method_name(name)
-          record_method_envelope_opaque(tables, class_name, method_name) if method_name
+          next unless method_name
+
+          record_method_envelope_opaque(tables, class_name, method_name)
+          record_removed_name(tables, class_name, method_name)
         end
       end
 
+      REMOVING_CALLS = %i[remove_method undef_method].to_set.freeze
+      private_constant :REMOVING_CALLS
+
+      # Issue #1820 — `undef f`, `remove_method :f` or `undef_method :f` on the class, as its own entry beside the
+      # opaque envelopes: an `attr_*` or `define_method` records an opaque envelope too, so only this says the name
+      # is gone.
+      def record_removed_name(tables, class_name, method_name)
+        record_envelope(tables.envelopes, class_name, [Scope::DiscoveryIndex::ENVELOPE_REMOVED_KIND, method_name],
+                        Source::ParameterEnvelope::OPAQUE)
+      end
+
       # Both kinds, and the envelope table only: the evidence says something rewrites the name, not which
       # side it lives on, and it is not evidence that the name EXISTS, so the existence table is untouched.
       def record_method_envelope_opaque(tables, class_name, method_name)
@@ -7198,7 +7811,7 @@ module Rigor
       # `def_delegator :@x, :f`) would leave a `def`'s envelope standing for a method that no longer has it.
       NAME_NEUTRAL_MACROS = %i[
         private public protected module_function private_class_method public_class_method
-        private_constant public_constant require require_relative autoload
+        private_constant public_constant require require_relative autoload autoload_relative
       ].to_set.freeze
       private_constant :NAME_NEUTRAL_MACROS
 
@@ -7239,6 +7852,42 @@ module Rigor
           constant_receiver_candidates(receiver, qualified_prefix).each do |name|
             record_surface_mark(tables, name, Scope::DiscoveryIndex::ENVELOPE_DYNAMIC_MARK)
           end
+        elsif singleton_class_of_receiver?(receiver) && singleton_class_named_call?(node)
+          record_singleton_class_names(node, receiver.receiver, qualified_prefix, tables)
+        end
+      end
+
+      # Issue #1752 — the names a {#singleton_class_named_call?} rewrites on its singleton class's owner, each
+      # singleton envelope opaque: the evidence the refinement typer reads as a rewritten singleton name.
+      def record_singleton_class_names(node, object, qualified_prefix, tables)
+        current_class = qualified_prefix.empty? ? nil : qualified_prefix.join("::")
+        owner = singleton_class_owner(node, object, qualified_prefix, current_class)
+        return if owner.nil?
+
+        (node.arguments&.arguments || []).each do |argument|
+          method_name = literal_method_name(argument)
+          next unless method_name
+
+          names = [method_name]
+          names << :"#{method_name}=" if %i[attr_writer attr_accessor].include?(node.name)
+          names.each do |name|
+            record_envelope(tables.envelopes, owner, [:singleton, name], Source::ParameterEnvelope::OPAQUE)
+            contest_envelope(tables, owner, [:singleton, name]) unless tables.certain
+          end
+        end
+      end
+
+      # Issue #1752 — `def Const.x` whose receiver is not the lexical `self` (written at the top level or in another
+      # class's body) defines `Const`'s singleton method, which no table files under `Const`: its singleton name's
+      # envelope turns opaque, the evidence the refinement typer reads as a rewritten singleton name.
+      def record_foreign_singleton_def(node, qualified_prefix, owner_prefix, tables)
+        receiver = node.receiver
+        return unless receiver.is_a?(Prism::ConstantReadNode) || receiver.is_a?(Prism::ConstantPathNode)
+        return if def_receiver_targets_lexical_self?(receiver, owner_prefix)
+
+        constant_receiver_candidates(receiver, qualified_prefix).each do |name|
+          record_envelope(tables.envelopes, name, [:singleton, node.name], Source::ParameterEnvelope::OPAQUE)
+          contest_envelope(tables, name, [:singleton, node.name]) unless tables.certain
         end
       end
 
@@ -7249,13 +7898,21 @@ module Rigor
         if dynamic_surface_call?(node)
           record_surface_mark(tables, class_name, Scope::DiscoveryIndex::ENVELOPE_DYNAMIC_MARK)
         elsif node.name == :refine
-          record_refinement(node, qualified_prefix, tables)
+          # Issue #1689 — a `refine` where `self` is a class is the class's own method, and refines nothing.
+          record_refinement(node, qualified_prefix, tables) unless tables.class_body_refine?(node)
         elsif !NAME_NEUTRAL_MACROS.include?(node.name)
-          (node.arguments&.arguments || []).each do |argument|
-            # `memoize def f(a)` wraps the def it is handed exactly as `memoize :f` does.
-            method_name = argument.is_a?(Prism::DefNode) ? argument.name : literal_method_name(argument)
-            record_method_envelope_opaque(tables, class_name, method_name) if method_name
-          end
+          record_named_arguments_opaque(node, class_name, tables)
+        end
+      end
+
+      def record_named_arguments_opaque(node, class_name, tables)
+        (node.arguments&.arguments || []).each do |argument|
+          # `memoize def f(a)` wraps the def it is handed exactly as `memoize :f` does.
+          method_name = argument.is_a?(Prism::DefNode) ? argument.name : literal_method_name(argument)
+          next unless method_name
+
+          record_method_envelope_opaque(tables, class_name, method_name)
+          record_removed_name(tables, class_name, method_name) if REMOVING_CALLS.include?(node.name)
         end
       end
 
@@ -7414,7 +8071,7 @@ module Rigor
         # `alias_method :new, :old` — the CallNode twin of the `alias` keyword (#533; liquid's i18n
         # `t` alias was the corpus case). Unlike AliasMethodNode a call's children can carry further
         # class bodies (`Class.new do … end`), so the walk continues below it either way.
-        names = alias_method_call_names(node)
+        names = Source::AliasNames.alias_method_call_names(node)
         if names && !rec_prefix.empty? && !(singleton_cref && leaf_owner.nil?)
           record_alias_call_entry(accumulator, rec_prefix.join("::"), names, node)
         end
@@ -7475,21 +8132,6 @@ module Rigor
         true
       end
 
-      # `[new_name, old_name]` for an implicit-self `alias_method` call with two literal symbol /
-      # string arguments, or nil. A variable-named alias is runtime data and stays unrecorded.
-      def alias_method_call_names(call_node)
-        return nil unless call_node.name == :alias_method && call_node.receiver.nil?
-
-        args = call_node.arguments&.arguments
-        return nil unless args && args.size == 2
-
-        new_name = literal_method_name(args[0])
-        old_name = literal_method_name(args[1])
-        return nil if new_name.nil? || old_name.nil?
-
-        [new_name, old_name]
-      end
-
       # The class/module arm of {#collect_class_alias_map}: under an unnameable cref a
       # bare/`self::` header opens `#<singleton>::Name` — the map files nothing for it;
       # a rooted or explicit-base header re-anchors at a nameable prefix.
@@ -7532,11 +8174,12 @@ module Rigor
 
       def record_alias_map_entry(alias_node, qualified_prefix, accumulator)
         return if qualified_prefix.empty?
-        return unless alias_node.new_name.is_a?(Prism::SymbolNode) && alias_node.old_name.is_a?(Prism::SymbolNode)
+
+        names = Source::AliasNames.keyword_names(alias_node)
+        return if names.nil?
 
         class_name = qualified_prefix.join("::")
-        new_name = alias_node.new_name.unescaped.to_sym
-        old_name = alias_node.old_name.unescaped.to_sym
+        new_name, old_name = names
         (accumulator[class_name] ||= {})[new_name] = old_name
         accumulator.wrote(class_name, new_name, alias_node) if accumulator.is_a?(AliasMap)
       end
@@ -7636,9 +8279,7 @@ module Rigor
       end
 
       def literal_method_name(node)
-        return nil unless node.is_a?(Prism::SymbolNode) || node.is_a?(Prism::StringNode)
-
-        node.unescaped&.to_sym
+        Source::Literals.symbol_or_string(node)
       end
 
       # Walks every file in `paths` (each path is parsed once with `Prism.parse_file`) and returns the unioned
@@ -8293,6 +8934,9 @@ module Rigor
         merge_header_nestings(acc[:header_nestings], file_index[:header_nestings] || {})
         fold_mixin_lists(acc, file_index)
         file_index[:class_sources].each { |cn, files| (acc[:class_sources][cn] ||= Set.new).merge(files) }
+        (file_index[:singleton_class_sources] || {}).each do |cn, files|
+          (acc[:singleton_class_sources][cn] ||= Set.new).merge(files)
+        end
         # Issue #722 residue 2 — a pre-#722 seed bundle carries no candidates; the SCHEMA bump makes such a
         # blob a cold rebuild, but default so any in-flight fold stays total.
         acc[:compact_headers].merge!(file_index[:compact_headers] || {})
@@ -8381,6 +9025,7 @@ module Rigor
           # data, so the bundle stays Marshal-clean and a warm file joins the envelopes its cold walk records.
           parameter_envelopes: file_index[:parameter_envelopes],
           class_source_names: file_index[:class_sources].keys,
+          singleton_class_source_names: (file_index[:singleton_class_sources] || {}).keys,
           # Issue #722 residue 2 — plain data, so the bundle stays Marshal-clean and a warm incremental file
           # re-anchors its compact headers the way a cold walk of it does.
           compact_headers: file_index[:compact_headers],
@@ -8405,7 +9050,7 @@ module Rigor
       # ADR-85 WD2 — reconstitutes a cached bundle into a single-file index {#fold_file_index} folds: the
       # def-node triples become {DefHandle}s bound to this file's `path`, and the class-source names become a
       # `{name => Set[path]}` table (the shape `accumulate_project_index` produces).
-      def bundle_to_file_index(bundle, path) # rubocop:disable Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity -- one read per bundle slot
+      def bundle_to_file_index(bundle, path) # rubocop:disable Metrics/AbcSize -- one read per bundle slot
         {
           def_nodes: bundle_defs_to_handles(bundle[:def_nodes], path),
           singleton_def_nodes: bundle_defs_to_handles(bundle[:singleton_def_nodes], path),
@@ -8426,7 +9071,8 @@ module Rigor
           method_visibilities: bundle[:method_visibilities],
           methods: bundle[:methods],
           parameter_envelopes: bundle[:parameter_envelopes] || {},
-          class_sources: bundle[:class_source_names].to_h { |name| [name, Set[path]] },
+          class_sources: bundle_path_sets(bundle[:class_source_names], path),
+          singleton_class_sources: bundle_path_sets(bundle[:singleton_class_source_names], path),
           compact_headers: bundle[:compact_headers] || {},
           # Issue #644 — a pre-#644 bundle carries no census; the SCHEMA bump makes such a blob a cold
           # rebuild, but default so any in-flight fold stays total.
@@ -8476,7 +9122,7 @@ module Rigor
           method_visibilities: {},
           methods: {},
           deferred_ranges: {},
-          parameter_envelopes: {}, class_sources: {},
+          parameter_envelopes: {}, class_sources: {}, singleton_class_sources: {},
           # Issue #722 residue 2 — compact-header re-anchor candidates, adjudicated in {#finalize_def_index}.
           compact_headers: {},
           constant_writes: {},
@@ -8766,7 +9412,7 @@ module Rigor
 
       def constant_write_census(root)
         tables = CensusTables.new(writes: {}, seen: Set.new, declared: Set.new, aliases: {},
-                                  write_census: GlobalWriteCensus::Collector.new)
+                                  write_census: GlobalWriteCensus::Collector.new(InEffectRefinements.new(root)))
         walk_constant_write_census(root, [], tables)
         tables
       end
@@ -9699,7 +10345,7 @@ module Rigor
           record_declarations(part, qualified_prefix, identity_table, discovered,
                               EMPTY_RENAMES, self_prefix, singleton_cref: singleton_cref)
         end
-        if (body = rvalue.block&.body)
+        if (body = rvalue.block.is_a?(Prism::BlockNode) && rvalue.block.body)
           record_declarations(body, qualified_prefix, identity_table, discovered,
                               EMPTY_RENAMES, child_prefix, singleton_cref: singleton_cref)
         end
@@ -9934,11 +10580,22 @@ module Rigor
           propagate(node.expression, table, current_scope)
           propagate(node.rescue_expression, table, current_scope.forget_error_info.forget_last_status)
         when Prism::PostExecutionNode then propagate_end_body(node, table, current_scope)
-        else
-          node.rigor_each_child { |child| propagate(child, table, current_scope) }
+        else propagate_children(node, table, current_scope)
         end
       end
 
+      SELF_OPENING_BODIES = [Prism::DefNode, Prism::ClassNode, Prism::ModuleNode, Prism::SingletonClassNode].freeze
+      private_constant :SELF_OPENING_BODIES
+
+      # Issue #1717 — a `def` / `class` / `module` body opens its own `self`, so an enclosing unentered block's
+      # unknown-`self` mark ({Scope#block_self_unknown?}) stops at it, as the evaluator's fresh body scope does.
+      # Every other node hands its children the scope as is.
+      def propagate_children(node, table, current_scope)
+        child_scope =
+          SELF_OPENING_BODIES.include?(node.class) ? current_scope.with_block_self_unknown(false) : current_scope
+        node.rigor_each_child { |child| propagate(child, table, child_scope) }
+      end
+
       # Issue #1361 — the block of `Thread.new`, `Fiber.new`, `define_method` and the other calls
       # {FreshFrameBlocks.fresh_entry?} names does not read the match-global narrowing of the body it is written in.
       # The evaluator enters it as {FreshFrameBlocks.entry} gives ({MatchRebinding.block_entry}), but a block in a
@@ -9985,12 +10642,117 @@ module Rigor
       def unentered_block_entry(node, block, table, current_scope)
         return current_scope unless block.is_a?(Prism::BlockNode) && !table.key?(block)
 
+        narrowing = unentered_block_narrowing(node, current_scope)
         current_scope = Narrowing.safe_navigation_block_scope(node, current_scope)
         # Issue #1429 — nor a guard's narrowing of a global or constant the body may run after code rebinds.
         current_scope = GuardRebinding.block_entry(current_scope, block, node)
-        return FreshFrameBlocks.entry(current_scope, node) if FreshFrameBlocks.fresh_entry?(node, current_scope)
+        entry =
+          if FreshFrameBlocks.fresh_entry?(node, current_scope)
+            FreshFrameBlocks.entry(current_scope, node)
+          else
+            LastLine.block_entry(FreshFrameBlocks.closure_entry(current_scope, block, node), block, node)
+          end
+        anonymous = AnonymousMetaClass.name_for(node, current_scope.source_path)
+        return unentered_meta_class_body_entry(block, entry, anonymous, table) if anonymous
+
+        refined = refined_body_name(node, current_scope)
+        record_class_body_defs(block, entry, table, Type::Combinator.nominal_of(refined), nil) if refined
+
+        # Issue #1717 — the body's `self` is unknown unless narrowed, as on the evaluator's entry; only the
+        # `call.undefined-method` mark is set here, never #316's opaque mark (its bind gate reads the evaluator's).
+        entry = entry.with_block_self_unknown(true) unless narrowing&.self_type
+        return entry unless narrowing
+
+        MacroBlockSelfType.apply(entry, narrowing, keeps_unknown: current_scope.block_self_narrowing_unknown?(node))
+      end
+
+      # Issue #1120 — the class a `refine X do … end` call's block refines, or nil when the call is not that shape
+      # or is a `refine` where `self` is a class (issue #1689: the class's own method, its block an ordinary one).
+      # The evaluator asks the same two questions ({StatementEvaluator#refined_class_context}).
+      def refined_body_name(node, scope)
+        target = refine_target(node)
+        return nil if target.nil? || InEffectRefinements.class_body_refine?(scope, node)
+
+        refined_class_name(target, scope)
+      end
+
+      # Issue #1120 — the name of the class `refine target do … end` refines: the class `target` types as, or the
+      # constant as written when it does not type as a class object (a gem class with no RBS). Shared by
+      # {StatementEvaluator#refined_class_context} and {#refined_body_name}.
+      def refined_class_name(target, scope)
+        refined = scope.type_of(target)
+        name = refined.is_a?(Type::Singleton) ? refined.class_name : Source::ConstantPath.qualified_name(target)
+        name&.delete_prefix("::")
+      end
+
+      # Issue #1696 — the entry of a `Class.new` / `Module.new` / `Struct.new` / `Data.define` block the evaluator
+      # never entered because it sits in a value position: `Object.const_set(:K, Class.new { attr_reader :x })`,
+      # `[Struct.new(:a) { def b = a }]`. Its `self` is the class `name` ({AnonymousMetaClass.name_for}) names, as
+      # {StatementEvaluator#enter_meta_class_body} gives the statement form; left on the enclosing `self`, a
+      # top-level one read every macro in it as `call.unresolved-toplevel`. Its `def`s are recorded as
+      # {#record_class_body_defs} says.
+      def unentered_meta_class_body_entry(block, entry, name, table)
+        entry = entry.with_block_self_type(Type::Combinator.singleton_of(name)).with_singleton_class_body(false)
+        record_class_body_defs(block, entry, table, Type::Combinator.nominal_of(name), entry.self_type)
+        entry
+      end
+
+      # Issue #1696 — records each `def` a value-position class-body block defines ({#each_class_body_def}) with the
+      # `self` its body runs on, since no evaluator pass enters it: `instance_self` for a plain `def`, `class_self`
+      # for a `def self.m` (skipped when nil). A `refine X` block passes only `Nominal[X]`: Ruby runs its defs on an
+      # instance of X, but the block itself on the refinement module, which Rigor does not model, so the block keeps
+      # the unknown `self` an unnarrowed block has. A `def obj.m` is left to the walk.
+      def record_class_body_defs(block, entry, table, instance_self, class_self)
+        each_class_body_def(block.body) do |def_node|
+          next if table.key?(def_node)
+
+          receiver = def_node.receiver
+          def_self =
+            if receiver.nil? then instance_self
+            elsif receiver.is_a?(Prism::SelfNode) then class_self
+            end
+          table[def_node] = entry.with_block_self_type(def_self) if def_self
+        end
+      end
 
-        LastLine.block_entry(FreshFrameBlocks.closure_entry(current_scope, block, node), block, node)
+      # The `def`s a class-body block defines on its class: every one in the body, `private def m` included, short
+      # of a nested block, lambda or `class` / `module` / `class << …` body, each of which opens its own.
+      def each_class_body_def(node, &)
+        return unless node.is_a?(Prism::Node)
+        return yield(node) if node.is_a?(Prism::DefNode)
+        return if CLASS_BODY_DEF_BARRIERS.include?(node.class)
+
+        node.rigor_each_child { |child| each_class_body_def(child, &) }
+      end
+
+      CLASS_BODY_DEF_BARRIERS = [
+        Prism::BlockNode, Prism::LambdaNode, Prism::ClassNode, Prism::ModuleNode, Prism::SingletonClassNode
+      ].freeze
+      private_constant :CLASS_BODY_DEF_BARRIERS
+
+      # The narrowing ({MacroBlockSelfType::Match}) an unentered block's body runs with — its `self` and, for a
+      # `block_as_methods:` entry, the declared refinements (issue #1667) — when the call is one whose block the
+      # engine narrows: an ADR-16 Tier A `block_as_methods:` match ({MacroBlockSelfType}) or `define_method` on the
+      # lexical `self` ({DefineMethodBlockSelf}, issue #963). The evaluator applies the same two narrowings to
+      # the blocks it enters ({StatementEvaluator#build_block_entry_scope}, {StatementEvaluator#enter_call_block})
+      # and the value pass to every block it types ({ExpressionTyper#block_body_self_narrowing}); without this a
+      # block in a value position — `puts(MyApp.get("/x") { redirect "/y" })`, `render json: Alba.serialize(x) {
+      # attributes :id }`, `private define_method(:m) { helper }` — kept the enclosing `self`, and every DSL call
+      # in it read as a call on that. The receiver is typed only when some plugin declares an entry for the
+      # call's name, so a call no entry names costs one table lookup. A miss, or a raise, keeps the entry as
+      # built — the false-positive-safe direction.
+      def unentered_block_narrowing(node, scope)
+        registry = scope.environment&.plugin_registry
+        if registry && !registry.empty? && !registry.contribution_index.block_entries_for(node.name).empty?
+          receiver_type =
+            node.receiver ? scope.type_of(node.receiver) : MacroBlockSelfType.implicit_receiver_type(scope)
+          match = MacroBlockSelfType.match_for(scope: scope, call_node: node, receiver_type: receiver_type)
+          return match if match
+        end
+        defined = DefineMethodBlockSelf.narrow_self_type_for(scope: scope, call_node: node)
+        defined && MacroBlockSelfType::Match.new(self_type: defined, refinements: InEffectRefinements::EMPTY)
+      rescue StandardError
+        nil
       end
 
       # The scope the children of an unentered block or lambda inherit. The evaluator enters a statement-level