rigortype 0.4.1 → 0.4.2

data/lib/rigor/analysis/dependency_recorder.rb

@@ -391,6 +391,21 @@ module Rigor
       end
       private_class_method :plain_constant_path?
 
+      # {read_name} for prebuilt, frozen `"kind:name"` keys: a caller that files the same keys on every read
+      # (a resolution chain's hook edges, #1641) builds them once and adds them here without a String apiece.
+      def read_keys(keys)
+        accumulator = Thread.current[KEY]
+        return if accumulator.nil?
+
+        captures = Thread.current[CAPTURE_KEY]
+        open = captures && !captures.empty?
+        missing = accumulator.missing
+        keys.each do |entry|
+          tee_missing(captures, entry) if open
+          missing.add(entry)
+        end
+      end
+
       # The miss-only spelling of {read_name}: a cross-file lookup of `name` (kind `:method` / `:class` /
       # `:toplevel` / …) that resolved to nothing. Kept as the name the internal spec's negative-edge
       # contract uses.

data/lib/rigor/analysis/dependency_source_inference/builder.rb

@@ -42,6 +42,9 @@ module Rigor
             @class_to_gem = {}
             @budget_exceeded = []
             @gem_modes = {}
+            @refinements = {}
+            @bound_constants = Set.new
+            @bound_segments = Set.new
           end
 
           def absorb(outcome, budget, builder)
@@ -58,6 +61,9 @@ module Rigor
             @gem_modes[resolved.gem_name] = resolved.mode
             walked = builder.walker_outcome_for(resolved, budget)
             @catalog.merge!(walked.catalog)
+            @refinements = Inference::ScopeIndexer.merge_refinement_tables(@refinements, walked.refinements)
+            @bound_constants.merge(walked.bound)
+            @bound_segments.merge(walked.bound_segments)
             builder.record_class_to_gem(walked.catalog, resolved.gem_name, @class_to_gem)
             @budget_exceeded << resolved.gem_name if walked.truncated?
           end
@@ -68,7 +74,8 @@ module Rigor
               method_catalog: @catalog, budget_exceeded: @budget_exceeded,
               class_to_gem: @class_to_gem,
               budget_overrun_strategy: dependencies.budget_overrun_strategy,
-              gem_modes: @gem_modes
+              gem_modes: @gem_modes, refinements: @refinements, bound_constants: @bound_constants,
+              bound_segments: @bound_segments
             )
           end
         end

data/lib/rigor/analysis/dependency_source_inference/gem_resolver.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "../../cache/descriptor"
+
 module Rigor
   module Analysis
     module DependencySourceInference
@@ -19,6 +21,11 @@ module Rigor
           def descriptor_key
             [gem_name, version, mode].freeze
           end
+
+          # ADR-10 slice 3 — this gem's row of a cache descriptor: its name, resolved version and mode.
+          def dependency_entry
+            Cache::Descriptor::DependencyEntry.new(gem_name: gem_name, gem_version: version, mode: mode)
+          end
         end
 
         # Unresolvable reasons. `:not_in_bundle` covers both the "RubyGems doesn't know this gem" case and the
@@ -43,6 +50,20 @@ module Rigor
           )
         end
 
+        # Issue #1814 — the {Resolved#dependency_entry} of each non-disabled `dependencies.source_inference` entry that
+        # resolves, in configuration order, without walking any gem. The run-result cache key and the incremental
+        # snapshot's fingerprint are built before analysis from inputs that are cheap to read, and a gem's walked
+        # source (its method catalogue, its refinement table, the constants it binds) is an input of the run that no
+        # analysed file records; a `Gemfile.lock` digest covers a `bundle update` and nothing else, so a project with no
+        # lockfile, or a gem installed beside the bundle, would replay the diagnostics of the gem's previous version.
+        # Unresolvable entries have no version to key on and add nothing: the gem appearing later adds its row.
+        def dependency_entries(dependencies)
+          dependencies.source_inference.reject(&:disabled?).filter_map do |entry|
+            resolved = resolve(entry)
+            resolved.dependency_entry if resolved.is_a?(Resolved)
+          end
+        end
+
         # Locator. `Gem.loaded_specs` reflects the bundle (cheap lookup, no filesystem walk); `find_by_name` is
         # the broader fallback for gems present on the gem path but not yet `require`'d. `Gem::MissingSpecError`
         # is a `LoadError` subclass, so the rescue covers both missing-spec and load-error signals.

data/lib/rigor/analysis/dependency_source_inference/index.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "../../cache/descriptor"
+require_relative "../../inference/scope_indexer"
 
 module Rigor
   module Analysis
@@ -11,7 +12,8 @@ module Rigor
       # entries.
       class Index
         attr_reader :resolved_gems, :unresolvable, :method_catalog, :budget_exceeded,
-                    :class_to_gem, :budget_overrun_strategy, :gem_modes
+                    :class_to_gem, :budget_overrun_strategy, :gem_modes, :refinements, :bound_constants,
+                    :bound_segments
 
         # @param method_catalog — => Symbol}] the flat
         #   `(class_name, method_name) → :instance | :singleton` table produced by {Walker.walk}, aggregated
@@ -30,10 +32,21 @@ module Rigor
         #   gem-source and RBS both contribute under `mode: :full`. The map is keyed on `gem_name` (not
         #   class) because re-opened classes belong to the first gem they appeared in per `class_to_gem`;
         #   `mode_for(class_name)` chains the two lookups.
-        def initialize(
+        # @param refinements — issue #1672: the opt-in gems' `refine X do … end` bodies, `{refined class =>
+        #   {method => [refining modules]}}` ({Walker::Outcome#refinements}). The runner merges it into the
+        #   project's `discovered_refinements` seed, so `using M` for a gem's `M` reaches the check rules.
+        # @param bound_constants — issue #1814: every name the opt-in gems' files bind by a constant write without
+        #   declaring a class or module by it ({Walker::Outcome#bound}: `Shared::Target` for `module Shared; Target =
+        #   String; end`), unioned across the walked gems. A refine key one of them binds may name any value
+        #   (`refine Shared::Target` in the project or in the next gem), which the reader decides at read time
+        #   ({Inference::InEffectRefinements.class_wildcard_key?}) through {#bound_constant?}.
+        # @param bound_segments — the last segment of each such write whose owner the walk cannot spell
+        #   ({Walker::Outcome#bound_segments}: a `const_set`), which matches that segment of any key.
+        def initialize( # rubocop:disable Metrics/ParameterLists
           resolved_gems: [], unresolvable: [], method_catalog: {},
           budget_exceeded: [], class_to_gem: {},
-          budget_overrun_strategy: :walker_cap, gem_modes: {}
+          budget_overrun_strategy: :walker_cap, gem_modes: {}, refinements: {}, bound_constants: Set.new,
+          bound_segments: Set.new
         )
           @resolved_gems = resolved_gems.freeze
           @unresolvable = unresolvable.freeze
@@ -42,6 +55,9 @@ module Rigor
           @class_to_gem = class_to_gem.freeze
           @budget_overrun_strategy = budget_overrun_strategy
           @gem_modes = gem_modes.freeze
+          @refinements = Inference::ScopeIndexer.freeze_refinements(refinements)
+          @bound_constants = bound_constants.to_set.freeze
+          @bound_segments = bound_segments.to_set.freeze
           freeze
         end
 
@@ -62,6 +78,22 @@ module Rigor
           @class_to_gem[class_name]
         end
 
+        # Issue #1814 — does a walked gem bind `name` (a refine key, or a prefix of one: `Shared::Target`, `Pag::Enc`)
+        # by a constant write that declares no class or module, or bind a constant of `name`'s last segment under an
+        # owner the walk could not spell? Such a key may name any value (`module Shared; Target = String; end` then
+        # `refine(Shared::Target)`), which the walker cannot resolve and the reader decides
+        # ({Inference::InEffectRefinements.class_wildcard_key?}). A gem constant that merely shares a core class's name
+        # (`Names::String`) binds nothing a sibling spelling of `refine String` (`Ext::String`) could denote.
+        def bound_constant?(name)
+          @bound_constants.include?(name) || @bound_segments.include?(name.split("::").last)
+        end
+
+        # Does any walked gem bind a constant at all? False for a project that opts in no gem, so a reader asks nothing
+        # per key.
+        def binds_constants?
+          !(@bound_constants.empty? && @bound_segments.empty?)
+        end
+
         # ADR-10 slice 5c — per-class mode lookup. Chains `class_to_gem` + `gem_modes`; returns `nil` when
         # the class isn't owned by any opt-in gem in this run.
         def mode_for(class_name)
@@ -99,14 +131,7 @@ module Rigor
         # surfaces them as `dynamic.dependency-source.gem-not-found` diagnostics. Resolved-but-disabled
         # entries are also absent: the {Builder} skips them before resolution, so they never reach the index.
         def cache_descriptor
-          dependencies = @resolved_gems.map do |resolved|
-            Cache::Descriptor::DependencyEntry.new(
-              gem_name: resolved.gem_name,
-              gem_version: resolved.version,
-              mode: resolved.mode
-            )
-          end
-          Cache::Descriptor.new(dependencies: dependencies)
+          Cache::Descriptor.new(dependencies: @resolved_gems.map(&:dependency_entry))
         end
       end
 

data/lib/rigor/analysis/dependency_source_inference/walker.rb

@@ -5,6 +5,7 @@ require "prism"
 require_relative "return_type_heuristic"
 require_relative "../../source/constant_path"
 require_relative "../../source/node_children"
+require_relative "../../inference/scope_indexer"
 
 module Rigor
   module Analysis
@@ -35,10 +36,47 @@ module Rigor
         # `budget`, and `truncated?` reports whether the cap was reached. The Index records this per-gem so
         # the Runner can surface a single `dynamic.dependency-source.budget-exceeded` warning naming the
         # affected gem(s).
-        class Outcome < Data.define(:catalog, :truncated)
+        #
+        # Issue #1672 — `refinements` is the gem's `refine X do … end` table, `{refined class => {method =>
+        # [refining modules]}}`, the shape `Inference::ScopeIndexer` builds for project files. A refine-body `def`
+        # goes there and never into `catalog`: it is not a method of the refining module, and of the refined class
+        # only after `using`. ADR-121 WD7 (issue #1814) — the table is the one the project walk's census records for
+        # the same source ({Inference::ScopeIndexer.refinement_table}), file by file, so it carries the wildcard rows
+        # a project module's would.
+        #
+        # Issue #1814 — `bound` is every name the gem's files bind by a constant write (an assignment, an operator
+        # write, a multiple assignment, a rooted path write) without declaring a class or module by it, spelled under
+        # the lexical nesting the write sits in (`Shared::Target` for `module Shared; Target = String; end`);
+        # `bound_segments` is the last segment of each write whose owner the walk cannot spell (a path write that is
+        # not rooted, a write under `class << …`, a `const_set` with a literal name) ({.collect_bound_constants}). A
+        # refine key one of these binds (`refine(Shared::Target)` anywhere) may name any value, which the walker cannot
+        # resolve: the rows stay as the census records them, {Index#bound_constant?} unions the names across the walked
+        # gems, and the reader decides the key at read time, by each prefix of it
+        # ({Inference::InEffectRefinements.class_wildcard_key?}).
+        class Outcome < Data.define(:catalog, :truncated, :refinements, :bound, :bound_segments)
+          def initialize(catalog:, truncated:, refinements: {}.freeze, bound: Set.new.freeze,
+                         bound_segments: Set.new.freeze)
+            super
+          end
+
           def truncated? = truncated
         end
 
+        # The walk's accumulators. The budget counts `catalog` only, but stops the whole walk: a file reached after it
+        # trips is not read. `root` is the file being walked and `in_effect` its {Inference::InEffectRefinements}, built
+        # the first time a `refine`-shaped call asks (issue #1689). Issue #1814 — `bound` and `bound_segments` are
+        # {Outcome}'s.
+        Harvest = Struct.new(:catalog, :refinements, :root, :in_effect, :bound, :bound_segments) do
+          # {Inference::ScopeIndexer.module_refine_target} against this file's in-effect refinements.
+          def refine_target_of(node)
+            return nil if Inference::ScopeIndexer.refine_target(node).nil?
+
+            self.in_effect ||= Inference::InEffectRefinements.new(root)
+            Inference::ScopeIndexer.module_refine_target(node, in_effect)
+          end
+        end
+        private_constant :Harvest
+
         # Per-method catalog entry. `kind` is `:instance` or `:singleton`; `return_type` is the
         # {ReturnTypeHeuristic}-extracted static facet (a `Rigor::Type::*`) or `nil` when the heuristic
         # declined. The dispatcher wraps a non-nil `return_type` in `Dynamic[T]`; a `nil` `return_type` falls
@@ -65,14 +103,16 @@ module Rigor
         #   the budget was reached. Methods of identical name on the same class with different kinds (rare;
         #   private API mostly) carry the kind that wins the per-class first walk.
         def walk(gem_dir:, roots:, budget: UNBOUNDED)
-          accumulator = {}
+          harvest = Harvest.new({}, {}, nil, nil, Set.new, Set.new)
           truncated = false
           accepted_roots(roots).each do |root|
             break if truncated
 
-            truncated = walk_root(File.join(gem_dir.to_s, root), accumulator, budget)
+            truncated = walk_root(File.join(gem_dir.to_s, root), harvest, budget)
           end
-          Outcome.new(catalog: accumulator.freeze, truncated: truncated)
+          Outcome.new(catalog: harvest.catalog.freeze, truncated: truncated,
+                      refinements: Inference::ScopeIndexer.freeze_refinements(harvest.refinements),
+                      bound: harvest.bound.freeze, bound_segments: harvest.bound_segments.freeze)
         end
 
         # Drops hard-excluded entries before any filesystem walk happens. Reasoning: we never want a gem's
@@ -84,21 +124,25 @@ module Rigor
 
         # Returns true when the budget tripped during this root's walk so the caller can stop iterating
         # subsequent roots.
-        def walk_root(root_dir, accumulator, budget) # rubocop:disable Naming/PredicateMethod
+        def walk_root(root_dir, harvest, budget) # rubocop:disable Naming/PredicateMethod
           return false unless File.directory?(root_dir)
 
           Dir.glob(File.join(root_dir, "**", "*.rb")).each do |path|
-            harvest_file(path, accumulator, budget)
-            return true if accumulator.size >= budget
+            harvest_file(path, harvest, budget)
+            return true if harvest.catalog.size >= budget
           end
           false
         end
 
-        def harvest_file(path, accumulator, budget)
+        def harvest_file(path, harvest, budget)
           parse_result = Prism.parse_file(path)
           return unless parse_result.errors.empty?
 
-          walk_node(parse_result.value, [], false, accumulator, budget)
+          harvest.root = parse_result.value
+          harvest.in_effect = nil
+          record_refinements(parse_result.value, path, harvest)
+          collect_bound_constants(parse_result.value, [[]], harvest)
+          walk_node(parse_result.value, [], false, harvest, budget)
         rescue StandardError
           # Gem source we can't parse / read silently degrades to "no contribution from this file". The
           # user-facing diagnostic stream is reserved for the project source; opt-in gem source MUST NOT
@@ -106,66 +150,191 @@ module Rigor
           nil
         end
 
+        # ADR-121 WD7 (issue #1814) — the refinement table the file contributes, read by the census the project walk
+        # runs ({Inference::ScopeIndexer.refinement_table}): the `refine` bodies, the computed targets, the `refine`
+        # inside a method, the `:refine` literals, and the wildcard rows each leaves, folded as the project folds its
+        # files' tables (`merge_refinement_tables`). The walker's own descent below records no row.
+        def record_refinements(root, path, harvest)
+          harvest.refinements = Inference::ScopeIndexer.merge_refinement_tables(
+            harvest.refinements, Inference::ScopeIndexer.refinement_table(root, path)
+          )
+        end
+
+        # Issue #1814 — the names the file binds by a constant write without declaring a class or module by them, or
+        # the last segment alone where the walk cannot spell the owner Ruby binds. A bare write (`K = …`, `K ||= …`,
+        # `K += …`, a multiple-assignment target) binds the name under the lexical nesting of the `class` / `module`
+        # headers around it, which a block does not change (a `Module.new do … end` or `module_eval { … }` body assigns
+        # a constant in the lexical scope around it); `prefixes` holds every nesting the headers can denote, since a
+        # nested compact header opens whichever module Ruby finds (`module W; module Shared::Inner` is
+        # `W::Shared::Inner` or `Shared::Inner`), as the census spells a refine target. A write whose value is one of
+        # the class-creating shapes the project walk registers as a declaration (`Class.new`, `Module.new`,
+        # `Struct.new`, `Data.define`, a `.freeze` tail or a `K = K || …` guard stripped:
+        # {Inference::ScopeIndexer.meta_new_rvalue}) declares a class, so `Point = Struct.new(:x); refine(Point)` keeps
+        # a normal row. Where the owner cannot be spelled the segment alone is recorded, which matches that segment of
+        # any key: a write under `class << …` (the singleton's), a path write that is not rooted (`Wrap::K = …` may
+        # bind under an included module's `Wrap`; `self::K = …` in a block binds under the block's `self`), and a
+        # `const_set` with a literal name (`Object.const_set(:K, …)` binds `::K`). A rooted path (`::Shared::K = …`)
+        # binds that name. One pass over the tree; the rows are not touched.
+        def collect_bound_constants(node, prefixes, harvest)
+          return unless node.is_a?(Prism::Node)
+
+          case node
+          when Prism::ClassNode, Prism::ModuleNode then prefixes = header_prefixes(node.constant_path, prefixes)
+          when Prism::SingletonClassNode then prefixes = nil
+          when Prism::ConstantWriteNode, Prism::ConstantOrWriteNode, Prism::ConstantAndWriteNode,
+               Prism::ConstantOperatorWriteNode
+            note_bare_write(node.name.to_s, prefixes, harvest) unless declares_class?(node)
+          when Prism::ConstantTargetNode then note_bare_write(node.name.to_s, prefixes, harvest)
+          when Prism::ConstantPathWriteNode, Prism::ConstantPathOrWriteNode, Prism::ConstantPathAndWriteNode,
+               Prism::ConstantPathOperatorWriteNode
+            note_path_write(node.target, harvest) unless declares_class?(node)
+          when Prism::ConstantPathTargetNode then note_path_write(node, harvest)
+          when Prism::CallNode then note_const_set(node, harvest)
+          end
+          node.rigor_each_child { |child| collect_bound_constants(child, prefixes, harvest) }
+        end
+
+        def declares_class?(write)
+          rvalue = Inference::ScopeIndexer.meta_new_rvalue(write)
+          !rvalue.nil? && Inference::ScopeIndexer.meta_new_constant_rvalue?(rvalue)
+        end
+
+        # The nestings a `class` / `module` body may sit in, given the ones its header is written in: a bare header
+        # opens a module under each; a compact header (`module Shared::Inner`) opens `Inner` under every name its base
+        # can denote there ({Inference::ScopeIndexer.constant_receiver_candidates}); a rooted header resets them. nil,
+        # the unspellable owner, for a header no constant spells or one under `class << …`.
+        def header_prefixes(constant_path, prefixes)
+          return nil if prefixes.nil? || Source::ConstantPath.qualified_name_or_nil(constant_path).nil?
+          return [Source::ConstantPath.qualified_name_or_nil(constant_path).split("::")] if rooted_path?(constant_path)
+
+          name = constant_path.name.to_s
+          return prefixes.map { |prefix| prefix + [name] } if constant_path.is_a?(Prism::ConstantReadNode)
+
+          prefixes.flat_map do |prefix|
+            Inference::ScopeIndexer.constant_receiver_candidates(constant_path.parent, prefix)
+                                   .map { |owner| owner.split("::") + [name] }
+          end.uniq
+        end
+
+        # `::K`, `::A::K`, as a path or a multiple-assignment target: the leftmost segment has no parent.
+        def rooted_path?(path)
+          path.respond_to?(:parent) && (path.parent.nil? || Source::ConstantPath.rooted?(path.parent))
+        end
+
+        def note_bare_write(name, prefixes, harvest)
+          return harvest.bound_segments << name if prefixes.nil?
+
+          prefixes.each { |prefix| harvest.bound << (prefix + [name]).join("::") }
+        end
+
+        # A path write binds its name where its base resolves, which the walk can spell only for a rooted base.
+        def note_path_write(path, harvest)
+          name = path.name.to_s
+          return harvest.bound_segments << name unless rooted_path?(path)
+
+          owner = path.parent && Source::ConstantPath.qualified_name_or_nil(path.parent)
+          harvest.bound << (owner ? "#{owner}::#{name}" : name)
+        end
+
+        # `const_set(:K, value)` / `const_set("K", value)` with a literal name, on any receiver: the owner is a value.
+        # A class-creating value declares a class, as a write of one does.
+        def note_const_set(node, harvest)
+          return unless node.name == :const_set
+
+          name, value = node.arguments&.arguments
+          return unless name.is_a?(Prism::SymbolNode) || name.is_a?(Prism::StringNode)
+          return if value && Inference::ScopeIndexer.meta_new_constant_rvalue?(value)
+
+          harvest.bound_segments << name.unescaped
+        end
+
         # Walks a Prism subtree, accumulating method definitions under their qualified class name. Mirrors
         # the shape of `Inference::ScopeIndexer#walk_methods` but stays decoupled from `Scope` because
         # gem-source inference runs without a scope context.
-        def walk_node(node, qualified_prefix, in_singleton_class, accumulator, budget)
+        def walk_node(node, qualified_prefix, in_singleton_class, harvest, budget)
           return unless node.is_a?(Prism::Node)
-          return if accumulator.size >= budget
+          return if harvest.catalog.size >= budget
 
           case node
           when Prism::ClassNode, Prism::ModuleNode
-            descend_class_or_module(node, qualified_prefix, in_singleton_class, accumulator, budget)
+            descend_class_or_module(node, qualified_prefix, in_singleton_class, harvest, budget)
           when Prism::SingletonClassNode
-            descend_singleton_class(node, qualified_prefix, accumulator, budget)
+            descend_singleton_class(node, qualified_prefix, harvest, budget)
           when Prism::DefNode
-            record_def_node(node, qualified_prefix, in_singleton_class, accumulator, budget)
+            record_def_node(node, qualified_prefix, in_singleton_class, harvest, budget)
+          when Prism::CallNode
+            return walk_refine_body(node, qualified_prefix, harvest, budget) if harvest.refine_target_of(node)
+
+            walk_children(node, qualified_prefix, in_singleton_class, harvest, budget)
           else
-            walk_children(node, qualified_prefix, in_singleton_class, accumulator, budget)
+            walk_children(node, qualified_prefix, in_singleton_class, harvest, budget)
           end
         end
 
-        def walk_children(node, qualified_prefix, in_singleton_class, accumulator, budget)
+        def walk_children(node, qualified_prefix, in_singleton_class, harvest, budget)
           node.rigor_each_child do |child|
-            break if accumulator.size >= budget
+            break if harvest.catalog.size >= budget
 
-            walk_node(child, qualified_prefix, in_singleton_class, accumulator, budget)
+            walk_node(child, qualified_prefix, in_singleton_class, harvest, budget)
           end
         end
 
         # `class Foo` / `module Bar`. The dynamic-prefix shape (`module ::Foo`-rooted variants whose left
         # side is a runtime expression) is treated as opaque — we walk the children under the same prefix
         # so any inner class definitions are still recorded under their own name.
-        def descend_class_or_module(node, qualified_prefix, in_singleton_class, accumulator, budget)
+        def descend_class_or_module(node, qualified_prefix, in_singleton_class, harvest, budget)
           name = Source::ConstantPath.qualified_name_or_nil(node.constant_path)
           if name && node.body
             child_prefix = Source::ConstantPath.declaration_prefix(qualified_prefix, node.constant_path)
-            walk_node(node.body, child_prefix, in_singleton_class, accumulator, budget)
+            walk_node(node.body, child_prefix, in_singleton_class, harvest, budget)
           else
-            walk_children(node, qualified_prefix, in_singleton_class, accumulator, budget)
+            walk_children(node, qualified_prefix, in_singleton_class, harvest, budget)
           end
         end
 
         # `class << self` only — `class << expr` for any other `expr` is treated as opaque so we don't
         # accidentally record per-instance singleton methods under the surrounding class.
-        def descend_singleton_class(node, qualified_prefix, accumulator, budget)
+        def descend_singleton_class(node, qualified_prefix, harvest, budget)
           if node.expression.is_a?(Prism::SelfNode) && node.body
-            walk_node(node.body, qualified_prefix, true, accumulator, budget)
+            walk_node(node.body, qualified_prefix, true, harvest, budget)
           else
-            walk_children(node, qualified_prefix, false, accumulator, budget)
+            walk_children(node, qualified_prefix, false, harvest, budget)
           end
         end
 
-        def record_def_node(node, qualified_prefix, in_singleton_class, accumulator, _budget)
+        def record_def_node(node, qualified_prefix, in_singleton_class, harvest, _budget)
           return if qualified_prefix.empty?
 
           class_name = qualified_prefix.join("::")
           kind = node.receiver.is_a?(Prism::SelfNode) || in_singleton_class ? :singleton : :instance
           key = [class_name, node.name]
-          return if accumulator.key?(key) # first walk wins
+          return if harvest.catalog.key?(key) # first walk wins
 
           return_type = ReturnTypeHeuristic.extract(node)
-          accumulator[key] = CatalogEntry.new(kind: kind, return_type: return_type)
+          harvest.catalog[key] = CatalogEntry.new(kind: kind, return_type: return_type)
+        end
+
+        # Issue #1672 — `refine X do … end`, the shape {Inference::ScopeIndexer.module_refine_target} accepts (not one
+        # whose `self` is a class: that is the class's own method and walks as any other call, issue #1689). The body's
+        # instance `def`s are refinements of X by the enclosing module, and none reaches the catalogue. The refinement
+        # table is not built here: {.record_refinements} runs the project walk's census over the whole file, which reads
+        # this body and every other `refine`-shaped node (ADR-121 WD7, issue #1814). Declarations nested in the body
+        # still walk under the lexical prefix, as they did before.
+        def walk_refine_body(node, qualified_prefix, harvest, budget)
+          body = node.block.body
+          walk_refine_declarations(body, qualified_prefix, harvest, budget) unless body.nil?
+        end
+
+        # The class / module declarations inside a refine body, walked as before; nothing else in it is.
+        def walk_refine_declarations(node, qualified_prefix, harvest, budget)
+          case node
+          when Prism::ClassNode, Prism::ModuleNode
+            walk_node(node, qualified_prefix, false, harvest, budget)
+          when Prism::DefNode, Prism::SingletonClassNode
+            nil
+          else
+            node.rigor_each_child { |child| walk_refine_declarations(child, qualified_prefix, harvest, budget) }
+          end
         end
       end
     end

data/lib/rigor/analysis/erb_template_detector.rb

@@ -25,7 +25,8 @@ module Rigor
         source = parse_result.source.source
         return false unless source.is_a?(String) && !source.empty?
 
-        ERB_CLOSING_MARKER.match?(source)
+        # The marker is ASCII; match bytes so an invalid byte elsewhere in the file cannot raise.
+        ERB_CLOSING_MARKER.match?(source.b)
       end
     end
   end

data/lib/rigor/analysis/incremental.rb

@@ -120,18 +120,22 @@ module Rigor
         appeared.freeze
       end
 
-      # Issue #1120 — the method names whose refinements moved in this edit: a `[refined class, method, refining
-      # module]` entry that appeared in, or vanished from, any file in `paths`. A consumer whose
-      # `call.undefined-method` answer consulted the refinement table recorded a `refinement:<method>` edge
-      # whichever way it answered, because the answer is a function of the whole project's refinements of that
-      # name. `paths` MUST include removed files, whose whole before-table vanished. `before` / `after` map a
-      # path to that file's `{refined class => {method => [modules]}}` table (nil when it refines nothing).
+      # Issue #1120 — the method names whose refinements moved in this edit. A consumer whose answer consulted the
+      # refinement table recorded a `refinement:<method>` edge whichever way it answered, because the answer is a
+      # function of the whole project's refinements of that name. `paths` MUST include removed files, whose whole
+      # before-table vanished. `before` / `after` map a path to that file's `{refined class => {method =>
+      # [modules]}}` table (nil when it refines nothing).
+      #
+      # Issue #1664 — every name a changed file refines, before or after the edit, not only the entries that
+      # appeared or vanished: the typed refined arm answers with a refine body's inferred return, which an edit
+      # inside the body changes while the table stays the same. A changed file's refinements are therefore all
+      # re-checked, which over-reports an edit elsewhere in the file and costs only the consumers of its names.
       def changed_refinement_names(paths, before, after)
         moved = Set.new
         paths.each do |path|
-          entries_before = refinement_entries(before[path])
-          entries_after = refinement_entries(after[path])
-          (entries_before ^ entries_after).each { |(_refined, method_name, _module)| moved << method_name }
+          (refinement_entries(before[path]) | refinement_entries(after[path])).each do |(_refined, method_name, _)|
+            moved << method_name
+          end
         end
         moved.freeze
       end
@@ -146,6 +150,22 @@ module Rigor
         entries
       end
 
+      # Issue #1820 — adds to `per_file` (`{path => Set}`) a frozen `[class, superclass as written]` pair in each file
+      # that declares a class with a superclass, so {changed_class_declarations} reports a subclass edge appearing or
+      # vanishing beside the class names.
+      def add_superclass_edges(per_file, class_sources, superclasses)
+        return per_file if superclasses.nil? || superclasses.empty?
+
+        superclasses.each do |child, parent|
+          edge = [child, parent.nil? ? "*" : parent.to_s].freeze
+          (class_sources[child] || EMPTY_FILES).each { |file| per_file[file] << edge }
+        end
+        per_file
+      end
+
+      EMPTY_FILES = [].freeze
+      private_constant :EMPTY_FILES
+
       # Issue #639 — the SYMMETRIC reading of {appeared_classes}: the names whose declaration in a file
       # appeared OR VANISHED. Appearance alone answered the miss side, which was the only side recording a
       # `class:` edge; a bare reference that RESOLVED now records one too, and what invalidates it is the