rigortype 0.4.1 → 0.4.2

data/lib/rigor/inference/in_effect_refinements/refine_defs.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Rigor
+  module Inference
+    class InEffectRefinements
+      # Issue #1664 — the `def`s one file's refine bodies define, keyed by refining module, refined class (each name
+      # the `refine` argument's spelling can denote) and method, with the `Module.nesting` each is written in. The
+      # last `def` of a name wins, as Ruby's method table keeps it.
+      class RefineDefs
+        # ADR-121 WD7 — what {#lookup} answers for a name whose last definer has no body (`define_method`, `attr_*`,
+        # `undef`): the search for a body ends there, so the typed arm answers `Dynamic[top]` rather than another
+        # file's `def`.
+        BODILESS = :bodiless
+        # Issue #1749 — what {#lookup} answers for a name whose refinement the walk cannot attribute: one from a
+        # `refine` that runs inside a method (it exists once the method has run, replacing what a refine body wrote for
+        # the name, or adding nothing if it never runs, and `using` sees it only if it runs first), or from an eval on
+        # a constant that several names denote (it runs on one of them, which another file decides, and replaces or is
+        # replaced by a `def` of the name in a refine body of the module, whichever runs first). A `def` of the name
+        # in a module-body refine, in this file or another, cannot say which one answers, so the name is never typed
+        # from any body: the lookup ends there across every file that declares the module, and unlike {BODILESS} a
+        # later record does not replace it.
+        UNDECIDED = :undecided
+
+        attr_reader :nestings
+
+        def initialize
+          @nodes = {}
+          @nestings = {}.compare_by_identity
+        end
+
+        # `owners` are the refining modules (several where an eval on a constant may run on any of its names), each
+        # filed under every class of `targets`. `name` is the method `def_node` answers for: its own name, or an
+        # alias's (ADR-121 WD7). A nil `def_node` is a later definer with no body (`define_method`, `attr_*`, `undef`),
+        # which replaces the earlier `def`. A name whose refinement the walk cannot attribute keeps no body and is
+        # {UNDECIDED}: several owners (Ruby runs the body on one of them only), or `created`, true for a `refine` that
+        # runs inside a method.
+        def record(owners, targets, name, def_node, nesting, created: false)
+          undecided = created || owners.size > 1
+          def_node = nil if undecided
+          owners.each do |owner|
+            by_class = (@nodes[owner] ||= {})
+            targets.each do |class_name|
+              by_name = (by_class[class_name] ||= {})
+              by_name[name] = undecided ? UNDECIDED : (def_node || BODILESS) unless by_name[name] == UNDECIDED
+            end
+          end
+          @nestings[def_node] = nesting if def_node
+        end
+
+        def lookup(module_name, class_name, method_name) = @nodes.dig(module_name, class_name, method_name)
+      end
+    end
+  end
+end

data/lib/rigor/inference/in_effect_refinements/scope_reads.rb

@@ -0,0 +1,282 @@
+# frozen_string_literal: true
+
+module Rigor
+  module Inference
+    class InEffectRefinements
+      # Issue #1673 — the answers that need the project as well as the file: a `using`'s include expansion, the
+      # refining modules of a name, and the typer's entry ({Scope#in_effect_refinements}). Each records the
+      # dependencies its answer reads (ADR-46), so a warm run answers as a cold one.
+      module ScopeReads
+        # The in-effect refinements at `node` as {Scope#in_effect_refinements} answers them: the file's list from
+        # the query `Inference::ScopeIndexer` stamps on the discovery index, each `using` expanded through
+        # {.activated_modules}, then `declared`. A scope no index stamped answers `declared` alone.
+        def for_node(scope, node, declared = EMPTY)
+          query = scope.discovery.in_effect_refinements
+          return EMPTY if declared.empty? && (query.nil? || query.empty?)
+          return query.for_node(node, declared) { |name| activated_modules(scope, name) } if query
+
+          declared.uniq.freeze
+        end
+
+        # ADR-121 WD7 — the in-effect list at `offset` of `query`'s file with no block source, each `using` expanded
+        # through {.activated_modules}: what the check rules read through `Analysis::CheckRules::LexicalMethodSites`,
+        # and what {.for_node} answers the typer for the same node with no declared module, so the two agree.
+        def lexical_list(scope, query, offset)
+          query.at(offset) { |name| activated_modules(scope, name) }
+        end
+
+        # Issue #1664 — the `def` a refine body gives `method_name` on `class_name` for the refining module
+        # `module_name`, or nil where none can be read: this file's own refine body first, else one in a file that
+        # declares the module (`Scope#discovered_class_sources`), parsed once a run. A gem refinement, a module a
+        # `Module.new` write names in another file, or an anonymous module answer nil, which the typed arm reads as
+        # an unreadable body (`Dynamic[top]`). Issue #1749 — so does a name {RefineDefs::UNDECIDED} in this file or in
+        # any file that declares the module (a `refine` that runs inside a method, or an eval on a constant that
+        # several names denote): which refinement answers depends on an order and a module the walk cannot decide, and
+        # it can replace a module-body `def` of the name wherever it is written, so no body of the name is read. The
+        # consumer's `refinement:<name>` edge covers an edit to that body (`Incremental.changed_refinement_names`).
+        def refinement_def(scope, module_name, class_name, method_name)
+          refinement_def_with_query(scope, module_name, class_name, method_name).first
+        end
+
+        # {.refinement_def} as `[def_node, query]`, where `query` is the other file's {InEffectRefinements} the body was
+        # found in, or nil for this file's own body (or none): the typed arm re-types a foreign body under that file's
+        # in-effect refinements.
+        def refinement_def_with_query(scope, module_name, class_name, method_name)
+          chosen = nil
+          each_declaring_query(scope, module_name) do |query, foreign|
+            found = query&.refinement_def(module_name, class_name, method_name)
+            return NO_DEF if found == RefineDefs::UNDECIDED
+            next if found.nil? || chosen
+            return NO_DEF if found == RefineDefs::BODILESS
+
+            chosen = [found, (query if foreign)]
+          end
+          chosen || NO_DEF
+        end
+
+        # This file's query, then one per file that declares `module_name`.
+        def each_declaring_query(scope, module_name)
+          yield scope.discovery.in_effect_refinements, false
+          (scope.discovered_class_sources[module_name] || EMPTY).each do |path|
+            yield DefNodeResolver.refinement_query(path), true
+          end
+        end
+
+        NO_DEF = [nil, nil].freeze
+        private_constant :NO_DEF
+
+        # Issue #1689 — {InEffectRefinements#class_body_refine?} on the query stamped for `scope`'s file; false where no
+        # index stamped one, which keeps the call's refine-body reading.
+        def class_body_refine?(scope, call_node)
+          query = scope.discovery.in_effect_refinements
+          !query.nil? && query.class_body_refine?(call_node)
+        end
+
+        # Issue #1671 — the modules whose refinements `using name` puts in effect, in activation order: the project
+        # modules on `name`'s instance-side `Scope::ResolutionChain` (what a module includes and prepends,
+        # transitively) in reverse ancestor order, each at its first position, so the module's own refinements
+        # follow its includes and a module it prepends follows it and wins. CRuby's `using_module_recursive` walks
+        # `RCLASS_SUPER` to its end before each link, and a prepended module sits above the module's origin. `name`
+        # itself goes last when the chain does not list it. Nil, read as "any module may be in effect", when the
+        # chain may hold a module it does not list: it was cut at its limit, or a module on it records a mixin the
+        # tables cannot name.
+        #
+        # ADR-121 WD7 — {UNDECLARED} when nothing declares `name` ({.declared_module?}), which drops it from a
+        # `using`'s candidates (A1). A chain entry the project does not declare is dropped when it is a core or
+        # stdlib module (the core and standard-library signatures the rbs gem ships declare no refinements); any
+        # other enters by its spelling, which {.opaque_module?} then rejects, so a module included from a gem or from
+        # a file outside the analysed paths may refine anything.
+        #
+        # ADR-46 — the answer reads include edges declared in other files, so it depends on every file that
+        # declares a module on the chain, and on the existence of each one's name: a new file reopening `name`, or
+        # declaring an included module the project did not declare before, re-checks the consumer through
+        # `class:<name>`.
+        def activated_modules(scope, name)
+          unless declared_module?(scope, name)
+            Analysis::DependencyRecorder.read_last_segment(:class, name) if Analysis::DependencyRecorder.active?
+            return UNDECLARED
+          end
+
+          chain = Scope::ResolutionChain.for(scope, name, :instance, :constants)
+          record_chain(scope, name, chain) if Analysis::DependencyRecorder.active?
+          return nil if chain.truncated? || chain.wildcard_mixin?
+
+          modules = chain.entries.reverse_each.filter_map { |entry| activated_entry(scope, entry) }.uniq
+          modules.include?(name) ? modules : modules << name
+        end
+
+        # ADR-121 WD7 (A4) — can Rigor not read every refinement of `name`, a module in an in-effect list? True when
+        # the project does not declare it (a gem's module, a module required from outside the analysed paths, or
+        # one only an `Object.const_set` makes), unless it is a core or stdlib module, which refines nothing; and
+        # true when a targets-wildcard row (`{"*" => {"*" => [...]}}`) lists it or the wildcard, which some unreadable
+        # `refine` wrote. Every reader that declines on an opaque module asks this, and nothing else. Gem modules
+        # stay opaque even when the gem source walker read them.
+        #
+        # ADR-46 — the answer moves when a file declares or stops declaring the module (`class:<last segment>`) or
+        # when a targets-wildcard row appears or vanishes (`refinement:*`).
+        def opaque_module?(scope, name)
+          if Analysis::DependencyRecorder.active?
+            Analysis::DependencyRecorder.read_last_segment(:class, name)
+            Analysis::DependencyRecorder.read_name(:refinement, WILDCARD)
+          end
+          unread = scope.discovered_refinements.dig(WILDCARD, WILDCARD)
+          return true if unread && (unread.include?(name) || unread.include?(WILDCARD))
+          return false if project_module?(scope, name)
+
+          !core_or_stdlib_module?(scope, name)
+        end
+
+        # Does `list` (an in-effect list, the unknown marker skipped) hold an {.opaque_module?}?
+        def opaque_in?(scope, list)
+          list.any? { |name| name != UNKNOWN && opaque_module?(scope, name) }
+        end
+
+        # ADR-121 WD7 (A1) — does the project, RBS or an opted-in gem declare `name`? A `using`'s lexical candidates
+        # that nothing declares are not the module Ruby's lookup finds, so they leave the list.
+        def declared_module?(scope, name)
+          return true if project_module?(scope, name)
+          return true if scope.environment&.class_known?(name)
+
+          gem_module?(scope, name)
+        end
+
+        # Issue #1120 — every module that refines `method_name` into `class_name` or one of its ancestors (a
+        # refinement of `Object` reaches a `String` receiver), or nil when none does. The table is empty on a
+        # project that refines nothing, which answers without a lookup.
+        #
+        # ADR-121 WD7 — a row the walk could not read counts too: a names-wildcard row of the class (the body may
+        # define any name), and a row whose class the walk could not name ({.class_wildcard_key?}), which reaches
+        # every receiver.
+        #
+        # ADR-46 — the answer is a function of every refinement of this name in the project, so the consumer
+        # depends on the name whichever way it answers; a refine body edited in another file must re-check it
+        # (`IncrementalSession#refinement_affected`). It also depends on the wildcard rows (`refinement:*`).
+        def refining_modules(scope, class_name, method_name)
+          record_refinement_names(method_name)
+          refinements = scope.discovered_refinements
+          return nil if refinements.empty?
+
+          modules = nil
+          refinements.each do |refined, methods|
+            names = methods[method_name]
+            unread = methods[WILDCARD]
+            next if names.nil? && unread.nil?
+            next unless refined_receiver_class?(scope, class_name, refined) || class_wildcard_key?(scope, refined)
+
+            modules = (modules || []).concat(names || EMPTY, unread || EMPTY)
+          end
+          modules
+        end
+
+        # ADR-121 WD7 — {.refining_modules} for a receiver the class rows do not reach (a class object): only the rows
+        # whose class the walk could not name ({.class_wildcard_key?}), for the name or as a names-wildcard.
+        def class_unknown_refining_modules(scope, method_name)
+          record_refinement_names(method_name)
+          modules = nil
+          scope.discovered_refinements.each do |refined, methods|
+            names = methods[method_name]
+            unread = methods[WILDCARD]
+            next if (names.nil? && unread.nil?) || !class_wildcard_key?(scope, refined)
+
+            modules = (modules || []).concat(names || EMPTY, unread || EMPTY)
+          end
+          modules
+        end
+
+        # ADR-121 WD7 (A5) — the name edges a consumer of the refinement table records: the method's, and the
+        # wildcard's, so a wildcard row appearing or vanishing in another file re-checks it.
+        def record_refinement_names(method_name)
+          return unless Analysis::DependencyRecorder.active?
+
+          Analysis::DependencyRecorder.read_name(:refinement, method_name)
+          Analysis::DependencyRecorder.read_name(:refinement, WILDCARD)
+        end
+
+        # ADR-121 WD7 — is the refined-class key `refined` a class the walk could not name: the wildcard, or (A6) a
+        # name no class declaration or RBS knows, of which some segment is a constant a write binds: a project
+        # constant write (`K = String; refine(K)`), by the last segment the project's census keys writes on, or one an
+        # opted-in gem's files make (`DependencySourceInference::Index#bound_constant?`, issue #1814), by the name the
+        # write binds, asked for each prefix of the key (`Shared::Target` for `module Shared; Target = String; end` in
+        # a gem; `Pag::Enc` for the gem's own `module Pag; Enc = ::Encoding; refine(Enc::Converter)`), so a gem
+        # constant that merely shares a core class's name (`Names::String`) moves no sibling key (`Ext::String`).
+        # Every segment counts, not only the last, so a prefix alias (`Enc = ::Encoding; refine(Enc::Converter)`,
+        # #1815) reads the same way. A key that is a core or declared class never moves, whatever a file writes under
+        # its name. A constant nothing binds (a gem's class with no RBS) keeps a normal row, which matches no receiver.
+        # Each segment is a `constant:` dependency, so a file that starts or stops binding any of them re-checks the
+        # consumer.
+        def class_wildcard_key?(scope, refined)
+          return true if refined == WILDCARD
+          return false if scope.discovered_classes.key?(refined) || scope.environment&.class_known?(refined)
+
+          segments = refined.split("::").reject(&:empty?)
+          if Analysis::DependencyRecorder.active?
+            Analysis::DependencyRecorder.read_last_segment(:class, refined)
+            segments.each { |segment| Analysis::DependencyRecorder.read_last_segment(:constant, segment) }
+          end
+          segments.any? { |segment| !scope.bound_constant_names(segment).empty? } || gem_bound_key?(scope, segments)
+        end
+
+        # The gem half of {.class_wildcard_key?}: does an opted-in gem bind some prefix of the key (issue #1814)? A
+        # leading `Object::` spells the top level (`Object::Shared::Target` is `Shared::Target`), so it is dropped.
+        def gem_bound_key?(scope, segments)
+          index = scope.environment&.dependency_source_index
+          return false if index.nil? || !index.binds_constants?
+
+          segments = segments.drop_while { |segment| segment == "Object" }
+          segments.each_index.any? { |i| index.bound_constant?(segments[0..i].join("::")) }
+        end
+
+        private
+
+        WILDCARD = Scope::DiscoveryIndex::REFINEMENT_WILDCARD
+        private_constant :WILDCARD
+
+        def activated_entry(scope, entry)
+          return entry.name unless entry.external?
+
+          candidates = entry.candidates
+          return nil if candidates.any? { |candidate| core_or_stdlib_module?(scope, candidate) }
+
+          candidates.first || entry.raw
+        end
+
+        def project_module?(scope, name)
+          scope.discovered_classes.key?(name) || !(scope.discovered_class_sources[name] || EMPTY).empty?
+        end
+
+        def core_or_stdlib_module?(scope, name)
+          scope.environment&.rbs_loader&.core_or_stdlib_class?(name) || false
+        end
+
+        # A module an opted-in gem's source declares: one its catalogue files a method under, or one its refinement
+        # rows name as a refining module.
+        def gem_module?(scope, name)
+          return true if scope.environment&.dependency_source_index&.gem_for(name)
+
+          scope.discovered_refinements.each_value.any? do |methods|
+            methods.each_value.any? { |modules| modules.include?(name) }
+          end
+        end
+
+        def refined_receiver_class?(scope, class_name, refined)
+          return true if class_name == refined
+
+          environment = scope.environment
+          !environment.nil? && environment.class_ordering(class_name, refined) == :subclass
+        end
+
+        def record_chain(scope, name, chain)
+          chain.record(scope)
+          Analysis::DependencyRecorder.read_last_segment(:class, name)
+          chain.entries.each do |entry|
+            if entry.external?
+              entry.candidates.each { |candidate| Analysis::DependencyRecorder.read_last_segment(:class, candidate) }
+            else
+              Analysis::DependencyRecorder.read_missing(:class, entry.last_segment)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rigor/inference/in_effect_refinements/walk.rb

@@ -0,0 +1,276 @@
+# frozen_string_literal: true
+
+require_relative "../../source/constant_path"
+
+module Rigor
+  module Inference
+    class InEffectRefinements
+      # The one walk of a file that records its activations, its refine-body `def`s and the `def`s a refine body
+      # defines on its refined class ({InEffectRefinements} describes what each source contributes).
+      module Walk
+        private
+
+        # `Module.nesting` inside `node`'s body while the block runs, for the refine-body defs recorded there.
+        def within_nesting(node)
+          outer = @nesting
+          @nesting = Source::ConstantPath.pushed_nesting(outer, node.constant_path) || outer
+          yield
+        ensure
+          @nesting = outer
+        end
+
+        # A file whose text names neither `using` nor `refine` (`refined` among it) holds none of the activations the
+        # walk records, so the scan of the source string spares it the tree walk.
+        def mentions_refinements?
+          text = @root.send(:source).source
+          text.include?("using") || text.include?("refine")
+        end
+
+        # `body` is the `[start, end]` of the body a `using` here stays in effect to the end of; `context` is the
+        # `RefineSelf::Context` of the `self` a `refine` here runs on, worked out by `RefineCensus`'s functions for
+        # every body, method and block this walk enters. The census reads it back for each `refine`-shaped node
+        # ({InEffectRefinements#refine_context}), so the two walks charge the same module.
+        def walk(node, prefix, body, in_def, context)
+          return if walked_body?(node, prefix, body, in_def, context)
+
+          case node
+          when Prism::SymbolNode
+            record_refine_context(node, context) if RefineCensus.refine_symbol?(node)
+          when Prism::ConstantWriteNode, Prism::ConstantPathWriteNode, Prism::ConstantOrWriteNode,
+               Prism::ConstantPathOrWriteNode
+            return if walked_meta_new_write?(node, prefix, body, in_def, context)
+          when Prism::LambdaNode, Prism::BlockNode
+            # A call's block walks under {#walk_block_call}; a `super` / `yield`-side block or a lambda may run
+            # under any `self`.
+            return walk_children(node, prefix, body, in_def, RefineSelf.unknown)
+          when Prism::CallNode
+            record_call(node, prefix, body, in_def, context)
+            return walk_block_call(node, prefix, body, in_def, context) if node.block.is_a?(Prism::BlockNode)
+          end
+
+          walk_children(node, prefix, body, in_def, context)
+        end
+
+        # A `class` / `module` / `class << …` body or a `def` body, each with a `self` of its own.
+        def walked_body?(node, prefix, body, in_def, context)
+          case node
+          when Prism::ClassNode, Prism::ModuleNode
+            # A superclass expression runs where the `class` keyword is, a parameter's default in the method's body.
+            walk(node.superclass, prefix, body, in_def, context) if node.is_a?(Prism::ClassNode) && node.superclass
+            inner = Source::ConstantPath.declaration_prefix(prefix, node.constant_path) || prefix
+            within_nesting(node) do
+              walk_children(node.body, inner, span_of(node), false, declaration_context(node, inner))
+            end
+          when Prism::SingletonClassNode
+            walk(node.expression, prefix, body, in_def, context)
+            walk_children(node.body, prefix, span_of(node), false,
+                          RefineSelf.singleton_class_body(context, node.expression.is_a?(Prism::SelfNode)))
+          when Prism::DefNode
+            method_context = RefineSelf.def_body(context, node.receiver)
+            walk_children(node.parameters, prefix, body, true, method_context)
+            walk_children(node.body, prefix, body, true, method_context)
+          else
+            return false
+          end
+          true
+        end
+
+        def declaration_context(node, inner)
+          return RefineSelf.module_body(inner.empty? ? nil : inner.join("::")) if node.is_a?(Prism::ModuleNode)
+
+          superclass = node.superclass
+          module_superclass = (superclass.is_a?(Prism::ConstantReadNode) ||
+                               (superclass.is_a?(Prism::ConstantPathNode) && superclass.parent.nil?)) &&
+                              superclass.name == :Module
+          RefineSelf.class_body(module_superclass)
+        end
+
+        # A block-carrying call: its receiver and arguments walk where the call is, its block under
+        # `RefineSelf.block` (a `define_method` block is a method body, where `using` raises).
+        def walk_block_call(node, prefix, body, in_def, context)
+          walk(node.receiver, prefix, body, in_def, context) if node.receiver
+          walk_children(node.arguments, prefix, body, in_def, context)
+          eval_names = RefineSelf.eval_receiver_names(node, prefix, context)
+          block_context = RefineSelf.block(context, node, eval_names) do |receiver|
+            literal_bound?(receiver, prefix, node.block)
+          end
+          walk_children(node.block, prefix, body, in_def || RefineSelf.method_block?(node), block_context)
+        end
+
+        # Does every binding of the constant, local or instance variable `receiver` in this file give it a literal
+        # (`RefineSelf.literal_bindings`, worked out once per file)? Asked only for a `block` whose text names `refine`
+        # or opens a heredoc: no other block can hold a `refine`-shaped node, so its context is never read, and the
+        # unnamed module it then runs on is the declining answer anyway.
+        def literal_bound?(receiver, prefix, block)
+          return false unless refine_text_in?(block)
+
+          key = RefineSelf.binding_key(receiver, prefix)
+          !key.nil? && (@literal_bindings ||= RefineSelf.literal_bindings(@root)).include?(key)
+        end
+
+        # The census's cost gate (`MethodTables#refine_in?`) over `node`'s text: a `refine` word or a heredoc opener.
+        def refine_text_in?(node)
+          location = node.location
+          (@refine_offsets ||= [ScopeIndexer.refine_word_offsets(@root), ScopeIndexer.heredoc_offsets(@root)])
+            .any? { |offsets| ScopeIndexer.offset_in?(offsets, location.start_offset, location.end_offset) }
+        end
+
+        # ADR-121 WD7 — what the census reads back for a `refine`-shaped node.
+        def record_refine_context(node, context)
+          @refine_contexts[node.location.start_offset] = context
+        end
+
+        def walk_children(node, prefix, body, in_def, context)
+          return if node.nil?
+
+          node.rigor_each_child { |child| walk(child, prefix, body, in_def, context) }
+        end
+
+        # `M = Module.new do … end`: the block's `self` is the module the write names, so a `refine` in it refines
+        # for `M`. The write's other parts walk as they would anyway.
+        def walked_meta_new_write?(node, prefix, body, in_def, context)
+          call = ScopeIndexer.meta_new_block_call(node)
+          return false if call.nil? || !ScopeIndexer.module_new_call?(call)
+
+          named = meta_new_owner(node, prefix)
+          walk(call.receiver, prefix, body, in_def, context) if call.receiver
+          walk_children(call.arguments, prefix, body, in_def, context)
+          record_call(call, prefix, body, in_def, context)
+          walk_children(call.block, prefix, body, in_def, RefineSelf.module_body(named))
+          true
+        end
+
+        def meta_new_owner(node, prefix)
+          case node
+          when Prism::ConstantWriteNode, Prism::ConstantOrWriteNode then (prefix + [node.name.to_s]).join("::")
+          else Source::ConstantPath.declaration_prefix(prefix, node.target)&.join("::")
+          end
+        end
+
+        def record_call(node, prefix, body, in_def, context)
+          record_refine_string_contexts(node, context)
+          record_refine_context(node, context) if node.name == :refine
+          owners = RefineSelf.charged_modules(context)
+          owners = nil if owners.include?(RefineCensus.wildcard)
+          if context.here == RefineSelf::CLASS && ScopeIndexer.refine_call?(node)
+            record_class_body_refine(node)
+          elsif (target = ScopeIndexer.refine_target(node))
+            record_refine_block(node, owners, ScopeIndexer.constant_receiver_candidates(target, prefix), context)
+          elsif ScopeIndexer.refine_call?(node)
+            # ADR-121 WD7 — a target the walk cannot name (`refine(k)`): the block is still a refine body, in effect
+            # inside itself, with no class to file its defs under.
+            record_refine_block(node, owners, EMPTY, context)
+          elsif using_call?(node) && !in_def
+            record_using(node, prefix, body)
+          elsif node.name == :refined
+            record_refined_chain(node, prefix)
+          end
+        end
+
+        # By `order`; activations a `.refined` chain recorded share the literal's offset and keep their recording (call)
+        # order, so only then does the sort carry the index.
+        def sort_activations
+          if @chained_refined_calls.nil?
+            @activations.sort_by!(&:order)
+          else
+            @activations = @activations.sort_by.with_index { |activation, index| [activation.order, index] }
+          end
+        end
+
+        # ADR-121 WD1's `Proc#refined` source (#1666). The walk meets a chain's outermost `.refined` first, so it
+        # records the whole chain from the literal outwards — the call order — and marks the inner calls done.
+        def record_refined_chain(node, prefix)
+          return if @chained_refined_calls&.include?(node)
+
+          @chained_refined_calls ||= Set.new.compare_by_identity
+          literal, chain = ProcLiterals.refined_chain(node)
+          chain.each { |call| @chained_refined_calls << call }
+          return if literal.nil?
+
+          chain.each do |call|
+            (call.arguments&.arguments || EMPTY).each do |argument|
+              record_block_activation(literal, refined_argument_candidates(argument, prefix))
+            end
+          end
+        end
+
+        # A constant argument's lexical candidates, or nil ({UNKNOWN}) for any other argument: a local, a splat, a call.
+        def refined_argument_candidates(argument, prefix)
+          return nil unless argument.is_a?(Prism::ConstantReadNode) || argument.is_a?(Prism::ConstantPathNode)
+
+          candidates = ScopeIndexer.constant_receiver_candidates(argument, prefix)
+          candidates.empty? ? nil : candidates
+        end
+
+        # An activation over a block's body (`block` a `Prism::BlockNode` or `Prism::LambdaNode`) that puts `names` in
+        # effect after the block site's lexical list, each expanded through its includes as a `using`'s is; nil names
+        # contribute {UNKNOWN}.
+        def record_block_activation(block, names)
+          start, stop = span_of(block)
+          @activations << Activation.new(order: start, start: start, stop: stop, names: names, expand: true,
+                                         refine_block: false)
+        end
+
+        # `owners` are the refining module's names (several where its spelling can denote several), or nil; `context`
+        # is the `RefineSelf::Context` the `refine` call runs in.
+        def record_refine_block(node, owners, targets, context)
+          start, stop = span_of(node.block)
+          @activations << Activation.new(order: start, start: start, stop: stop, names: owners, expand: false,
+                                         refine_block: true)
+          body = node.block.body
+          return if body.nil?
+
+          ScopeIndexer.each_refinement_def(body) { |def_node| @refinement_defs << def_node.location.start_offset }
+          return if owners.nil? || targets.empty?
+
+          # ADR-121 WD7 (issue #1799) — a `def`, and an alias of a `def` the body wrote earlier; a later definer with no
+          # body (`define_method`, `attr_*`, `undef`) clears the name, which then types as `Dynamic[top]`. A `refine`
+          # that runs inside a method (issue #1749) creates its refinement only when the method runs, after or before a
+          # `using` and over or under a module-body `def` of the name, an order no walk can decide: no body of its names
+          # is kept, and no later `def` of one replaces that ({RefineDefs#record}).
+          RefineCensus.read_body(body).defs.each do |name, def_node|
+            @refine_defs.record(owners, targets, name, def_node, @nesting, created: context.deferred)
+          end
+        end
+
+        def record_class_body_refine(node) = (@class_body_refines ||= Set.new) << node.block.location.start_offset
+
+        def record_refine_string_contexts(node, context)
+          return unless RefineCensus.string_literal_call?(node)
+
+          node.arguments&.arguments&.each do |argument|
+            record_refine_context(argument, context) if RefineCensus.refine_string?(argument)
+          end
+        end
+
+        def using_call?(node)
+          node.name == :using && (node.receiver.nil? || node.receiver.is_a?(Prism::SelfNode)) &&
+            node.arguments&.arguments&.size == 1
+        end
+
+        def record_using(node, prefix, body)
+          argument = node.arguments.arguments.first
+          order = node.location.end_offset
+          candidates =
+            if argument.is_a?(Prism::ConstantReadNode) || argument.is_a?(Prism::ConstantPathNode)
+              ScopeIndexer.constant_receiver_candidates(argument, prefix)
+            end
+          if candidates && !candidates.empty?
+            @activations << Activation.new(order: order, start: order, stop: body.last, names: candidates,
+                                           expand: true, refine_block: false)
+          else
+            @unresolved_using = true
+            location = @root.location
+            @activations << Activation.new(order: order, start: location.start_offset, stop: location.end_offset,
+                                           names: nil, expand: false, refine_block: false)
+          end
+        end
+
+        def span_of(node)
+          location = node.location
+          [location.start_offset, location.end_offset]
+        end
+      end
+    end
+  end
+end