rigortype 0.1.16 → 0.1.18

data/lib/rigor/inference/narrowing.rb

@@ -123,6 +123,66 @@ module Rigor
         end
       end
 
+      # Three-valued truthiness certainty of a predicate's type,
+      # derived from the truthy / falsey fragments above: `:truthy`
+      # when no inhabitant is falsey (the falsey fragment is `Bot`),
+      # `:falsey` when no inhabitant is truthy, nil when both
+      # fragments are inhabited — or when the type itself is nil /
+      # `Bot` (dead code is not a certainty claim). This is the single
+      # owner of the judgment both branch-elision consumers read
+      # (`ExpressionTyper#elide_or_union` on the value side,
+      # `StatementEvaluator#live_branch_for_if` on the scope side), so
+      # the type a dead branch is elided from and the scope that stops
+      # flowing through it can never disagree.
+      def predicate_certainty(type)
+        return nil if type.nil? || type.is_a?(Type::Bot)
+
+        truthy_bot = narrow_truthy(type).is_a?(Type::Bot)
+        falsey_bot = narrow_falsey(type).is_a?(Type::Bot)
+
+        return :falsey if truthy_bot && !falsey_bot
+        return :truthy if !truthy_bot && falsey_bot
+
+        nil
+      end
+
+      # Three-valued certainty of `C === subject` for a class / module
+      # `when` pattern, derived from {.narrow_class} /
+      # {.narrow_not_class}: `:no` when no inhabitant of the subject
+      # matches, `:yes` when every inhabitant matches, `:maybe`
+      # otherwise. The value-side counterpart of the scope narrowing
+      # {.case_when_scopes} performs for the same condition shape, kept
+      # here so the branch a `case` expression's type drops and the
+      # clause whose body scope goes dead derive from one judgment.
+      def class_pattern_certainty(subject_type, class_name, environment:)
+        truthy_bot = narrow_class(subject_type, class_name, environment: environment).is_a?(Type::Bot)
+        falsey_bot = narrow_not_class(subject_type, class_name, environment: environment).is_a?(Type::Bot)
+
+        return :no if truthy_bot && !falsey_bot
+        return :yes if !truthy_bot && falsey_bot
+
+        :maybe
+      end
+
+      # Classes whose `===` is plain value equality, so a literal
+      # `when` pattern against a pinned `Constant` subject is exact in
+      # both directions. Anything else keeps custom-`===` semantics
+      # and stays `:maybe` in {.value_pattern_certainty}.
+      VALUE_EQUALITY_CLASSES = [Integer, Float, Rational, Complex, String, Symbol,
+                                TrueClass, FalseClass, NilClass].freeze
+
+      # Three-valued certainty of `<literal> === subject` for a
+      # value-equality literal pattern: exact (`:yes` / `:no`) only
+      # when the subject is itself a pinned `Constant` of a
+      # value-equality class; `:maybe` otherwise (the runtime value
+      # isn't pinned, or `===` may be user-defined).
+      def value_pattern_certainty(subject_type, pattern_value)
+        return :maybe unless subject_type.is_a?(Type::Constant)
+        return :maybe unless VALUE_EQUALITY_CLASSES.any? { |klass| subject_type.value.is_a?(klass) }
+
+        pattern_value == subject_type.value ? :yes : :no
+      end
+
       # Equality fragment of `type` against a trusted literal.
       #
       # String/Symbol/Integer equality narrows only when the current
@@ -960,7 +1020,7 @@ module Rigor
         end
 
         def simple_dispatch_name?(name)
-          %i[nil? ! is_a? kind_of? instance_of? == != === =~].include?(name)
+          %i[nil? ! is_a? kind_of? instance_of? == != === =~ key? has_key? empty? any? none?].include?(name)
         end
 
         def dispatch_call_simple(node, scope, name)
@@ -971,9 +1031,177 @@ module Rigor
           when :==, :!= then analyse_equality_predicate(node, scope, equality: name)
           when :=== then analyse_case_equality_predicate(node, scope)
           when :=~ then analyse_regex_match_predicate(node, scope)
+          when :key?, :has_key? then analyse_key_presence_predicate(node, scope)
+          when :empty?, :any?, :none? then analyse_array_emptiness_predicate(node, scope, name)
+          end
+        end
+
+        # ADR-47 §4-4 (Elixir `tuple_size`/non-empty analogue) — a bare
+        # `arr.empty?` / `arr.any?` / `arr.none?` (no block, no args)
+        # narrows an Array-typed receiver to `non-empty-array[T]` on the
+        # edge that implies "at least one element":
+        #
+        #   - `empty?` → false edge   (the array is NOT empty)
+        #   - `any?`   → true  edge   (a truthy element exists ⇒ non-empty)
+        #   - `none?`  → false edge   (a truthy element exists ⇒ non-empty)
+        #
+        # The opposite edge is the conservative no-op (`any?`/`none?`
+        # falseness does not imply emptiness — the array may hold only
+        # falsey elements; `empty?` truth could narrow to an empty array
+        # but that carrier move is deferred). Only `Nominal[Array, [T]]`
+        # receivers narrow — `Tuple` is already known-length, `Dynamic`
+        # is left alone (gradual guarantee), and a non-Array receiver
+        # (`String#empty?`, `Range#any?`, …) bails so the existing string
+        # / predicate paths still run.
+        def analyse_array_emptiness_predicate(node, scope, name)
+          return nil if node.block
+          return nil unless node.arguments.nil? || node.arguments.arguments.empty?
+
+          reader, writer = emptiness_receiver_accessors(node.receiver)
+          return nil if reader.nil?
+
+          current = scope.public_send(reader, node.receiver.name)
+          return nil if current.nil?
+
+          non_empty = narrow_to_non_empty_array(current)
+          return nil if non_empty.equal?(current) # receiver is not an Array shape → opaque
+
+          non_empty_scope = scope.public_send(writer, node.receiver.name, non_empty)
+          name == :any? ? [non_empty_scope, scope] : [scope, non_empty_scope]
+        end
+
+        def emptiness_receiver_accessors(receiver)
+          case receiver
+          when Prism::LocalVariableReadNode then %i[local with_local]
+          when Prism::InstanceVariableReadNode then %i[ivar with_ivar]
+          else [nil, nil]
           end
         end
 
+        # Refines `Array[T]` (and every Array member of a Union) to
+        # `non-empty-array[T]`; returns the input unchanged when nothing
+        # applies, so the caller can detect "no narrowing".
+        def narrow_to_non_empty_array(type)
+          case type
+          when Type::Nominal
+            return type unless type.class_name == "Array"
+
+            Type::Combinator.non_empty_array(type.type_args.first || Type::Combinator.top)
+          when Type::Union
+            Type::Combinator.union(*type.members.map { |member| narrow_to_non_empty_array(member) })
+          else
+            type
+          end
+        end
+
+        # ADR-47 §4-3 (Elixir `is_map_key/2` analogue) — `h.key?(:foo)`
+        # narrows the receiver on the truthy edge: a `HashShape` whose
+        # `:foo` is an OPTIONAL key has it promoted to REQUIRED, so a
+        # subsequent `h[:foo]` reads the declared value type instead of
+        # `value | nil` (the optionality nil is gone). Sound because key
+        # presence removes only the optionality-injected nil, never the
+        # value's own intrinsic nil (`h = {foo: nil}` keeps `h[:foo]`
+        # nil-typed). The falsey edge is left unchanged — "key absent"
+        # is the conservative no-op. Only literal `Symbol`/`String`
+        # arguments and `LocalVariableReadNode`/`InstanceVariableReadNode`
+        # receivers narrow; everything else (Dynamic, `Nominal[Hash]`,
+        # method-chain receivers, dynamic keys) bails to no narrowing.
+        def analyse_key_presence_predicate(node, scope)
+          return nil if node.arguments.nil?
+          return nil unless node.arguments.arguments.size == 1
+
+          key = static_hash_key(node.arguments.arguments.first)
+          return nil if key.nil?
+
+          case node.receiver
+          when Prism::LocalVariableReadNode
+            key_presence_scopes(node.receiver.name, key, scope, reader: :local, writer: :with_local)
+          when Prism::InstanceVariableReadNode
+            key_presence_scopes(node.receiver.name, key, scope, reader: :ivar, writer: :with_ivar)
+          end
+        end
+
+        def key_presence_scopes(name, key, scope, reader:, writer:)
+          current = scope.public_send(reader, name)
+          return nil if current.nil?
+
+          truthy = narrow_hash_key_present(current, key)
+          # §4-3 false edge — `h.key?(:foo)` being false proves `:foo` is
+          # absent, so on that edge `h[:foo]` reads `nil`. Remove the
+          # (optional) key from the shape; a required key makes the false
+          # edge dead and an unknown key is already nil, both no-ops.
+          falsey = narrow_hash_key_absent(current, key)
+          return nil if truthy.equal?(current) && falsey.equal?(current) # predicate is opaque
+
+          truthy_scope = truthy.equal?(current) ? scope : scope.public_send(writer, name, truthy)
+          falsey_scope = falsey.equal?(current) ? scope : scope.public_send(writer, name, falsey)
+          [truthy_scope, falsey_scope]
+        end
+
+        def static_hash_key(node)
+          case node
+          when Prism::SymbolNode then node.unescaped.to_sym
+          when Prism::StringNode then node.unescaped
+          end
+        end
+
+        # Promotes `key` from optional to required across a HashShape (or
+        # every HashShape member of a Union). Returns the input unchanged
+        # when nothing applies, so the caller can detect "no narrowing".
+        def narrow_hash_key_present(type, key)
+          case type
+          when Type::HashShape
+            promote_hash_key(type, key)
+          when Type::Union
+            Type::Combinator.union(*type.members.map { |member| narrow_hash_key_present(member, key) })
+          else
+            type
+          end
+        end
+
+        def promote_hash_key(shape, key)
+          return shape unless shape.pairs.key?(key) # unknown key → no value type to assert
+          return shape unless shape.optional_key?(key) # already required → nothing to promote
+
+          Type::HashShape.new(
+            shape.pairs,
+            required_keys: shape.required_keys + [key],
+            optional_keys: shape.optional_keys - [key],
+            read_only_keys: shape.read_only_keys,
+            extra_keys: shape.extra_keys
+          )
+        end
+
+        # §4-3 false edge — drops `key` from a HashShape (or every HashShape
+        # member of a Union) so the proven-absent key reads `nil`. Returns
+        # the input unchanged when nothing applies (caller detects "no
+        # narrowing"). Only an *optional* present key is removed: a required
+        # key makes `key?` always true (the false edge is dead, leave the
+        # shape opaque) and a key absent from `pairs` already reads `nil`.
+        def narrow_hash_key_absent(type, key)
+          case type
+          when Type::HashShape
+            remove_hash_key(type, key)
+          when Type::Union
+            Type::Combinator.union(*type.members.map { |member| narrow_hash_key_absent(member, key) })
+          else
+            type
+          end
+        end
+
+        def remove_hash_key(shape, key)
+          return shape unless shape.pairs.key?(key)
+          return shape unless shape.optional_key?(key)
+
+          Type::HashShape.new(
+            shape.pairs.except(key),
+            required_keys: shape.required_keys,
+            optional_keys: shape.optional_keys - [key],
+            read_only_keys: shape.read_only_keys - [key],
+            extra_keys: shape.extra_keys
+          )
+        end
+
         # Survey item (b): `/regex/ =~ str` and `str =~ /regex/`
         # bind the regex match-data globals on each edge.
         #
@@ -1554,13 +1782,42 @@ module Rigor
           return nil if node.arguments.nil?
           return nil unless node.arguments.arguments.size == 1
 
-          local_arg = node.arguments.arguments.first
-          return nil unless local_arg.is_a?(Prism::LocalVariableReadNode)
+          arg = node.arguments.arguments.first
+          case arg
+          when Prism::LocalVariableReadNode
+            current = scope.local(arg.name)
+            return nil if current.nil?
 
-          current = scope.local(local_arg.name)
+            analyse_case_equality_receiver(node.receiver, scope, arg.name, current)
+          when Prism::CallNode
+            analyse_case_equality_on_chain(node.receiver, arg, scope)
+          end
+        end
+
+        # `Class === <local/ivar>.<method>` — the case-equality counterpart
+        # of {.analyse_class_predicate_on_chain}. The `open3` idiom
+        # `if Hash === cmd.last` narrows `cmd.last` to the class inside the
+        # branch, recorded as a single-hop method-chain narrowing keyed on
+        # the chain address (same stability rules as `is_a?` on a chain).
+        # Only static class/module receivers narrow here — the Range /
+        # Regexp literal receivers (`(1..10) === x.foo`) are not a common
+        # method-chain shape and stay deferred.
+        def analyse_case_equality_on_chain(receiver, chain_arg, scope)
+          class_name = static_class_name(receiver)
+          return nil if class_name.nil?
+
+          address = stable_chain_address(chain_arg)
+          return nil if address.nil?
+
+          current = scope.type_of(chain_arg)
           return nil if current.nil?
 
-          analyse_case_equality_receiver(node.receiver, scope, local_arg.name, current)
+          truthy_type = narrow_class(current, class_name, exact: false, environment: scope.environment)
+          falsey_type = narrow_not_class(current, class_name, exact: false, environment: scope.environment)
+          [
+            scope.with_method_chain_narrowing(*address, truthy_type),
+            scope.with_method_chain_narrowing(*address, falsey_type)
+          ]
         end
 
         def analyse_case_equality_receiver(receiver, scope, local_name, current)

data/lib/rigor/inference/scope_indexer.rb

@@ -68,16 +68,17 @@ module Rigor
         # collision — same-file declarations are the most
         # specific authority.
         merged_classes = default_scope.discovered_classes.merge(discovered_classes)
-        seeded_scope = default_scope
-                       .with_declared_types(declared_types)
-                       .with_discovered_classes(merged_classes)
+        seeded_scope = default_scope.with_discovery(
+          default_scope.discovery.with(declared_types: declared_types,
+                                       discovered_classes: merged_classes)
+        )
 
         # Slice 7 phase 2. Pre-pass over every class/module body
         # to collect the per-class ivar accumulator. Seeded after
         # declared_types so the rvalue typer in the pre-pass can
         # see declaration overrides.
         class_ivars = build_class_ivar_index(root, seeded_scope)
-        seeded_scope = seeded_scope.with_class_ivars(class_ivars)
+        seeded_scope = seeded_scope.with_discovery(seeded_scope.discovery.with(class_ivars: class_ivars))
 
         # Slice 7 phase 6. Same pre-pass shape for cvars (per
         # class) and globals (program-wide). Globals are also
@@ -86,9 +87,9 @@ module Rigor
         # not enter a method body) observe the precise type
         # without consulting the accumulator on every lookup.
         class_cvars = build_class_cvar_index(root, seeded_scope)
-        seeded_scope = seeded_scope.with_class_cvars(class_cvars)
+        seeded_scope = seeded_scope.with_discovery(seeded_scope.discovery.with(class_cvars: class_cvars))
         program_globals = build_program_global_index(root, seeded_scope)
-        seeded_scope = seeded_scope.with_program_globals(program_globals)
+        seeded_scope = seeded_scope.with_discovery(seeded_scope.discovery.with(program_globals: program_globals))
         program_globals.each { |name, type| seeded_scope = seeded_scope.with_global(name, type) }
 
         # Slice 7 phase 9. In-source constant value tracking.
@@ -99,7 +100,9 @@ module Rigor
         # references resolve correctly. Multiple writes to the
         # same qualified name union via `Type::Combinator.union`.
         in_source_constants = build_in_source_constants(root, seeded_scope)
-        seeded_scope = seeded_scope.with_in_source_constants(in_source_constants)
+        seeded_scope = seeded_scope.with_discovery(
+          seeded_scope.discovery.with(in_source_constants: in_source_constants)
+        )
 
         # Slice 7 phase 12. In-source method discovery. Walks
         # every class/module body for `Prism::DefNode` and
@@ -115,7 +118,7 @@ module Rigor
         discovered_methods = deep_merge_class_methods(
           default_scope.discovered_methods, build_discovered_methods(root)
         )
-        seeded_scope = seeded_scope.with_discovered_methods(discovered_methods)
+        seeded_scope = seeded_scope.with_discovery(seeded_scope.discovery.with(discovered_methods: discovered_methods))
 
         # v0.0.2 #5 + ADR-24 slice 2 — record per-instance-method
         # def nodes, the class -> superclass map, and the
@@ -173,12 +176,21 @@ module Rigor
         method_visibilities = default_scope.discovered_method_visibilities.merge(
           build_discovered_method_visibilities(root)
         ) { |_class, cross_file, per_file| cross_file.merge(per_file) }
+        # ADR-48 — per-file Data member layouts merged OVER the cross-file
+        # seed (same-file declaration is authoritative for its own classes).
+        data_member_layouts = default_scope.data_member_layouts.merge(
+          build_data_member_layouts(root)
+        )
 
-        seeded_scope
-          .with_discovered_def_nodes(def_nodes)
-          .with_discovered_superclasses(superclasses)
-          .with_discovered_includes(includes)
-          .with_discovered_method_visibilities(method_visibilities)
+        seeded_scope.with_discovery(
+          seeded_scope.discovery.with(
+            discovered_def_nodes: def_nodes,
+            discovered_superclasses: superclasses,
+            discovered_includes: includes,
+            discovered_method_visibilities: method_visibilities,
+            data_member_layouts: data_member_layouts
+          )
+        )
       end
 
       # Slice 7 phase 2. Builds the class-level ivar accumulator
@@ -322,7 +334,7 @@ module Rigor
         end
       end
 
-      def walk_class_ivars(node, qualified_prefix, default_scope, accumulator, mutated_ivars,
+      def walk_class_ivars(node, qualified_prefix, default_scope, accumulator, mutated_ivars, # rubocop:disable Metrics/CyclomaticComplexity
                            read_before_write = nil, init_writes = nil)
         return unless node.is_a?(Prism::Node)
 
@@ -357,6 +369,13 @@ module Rigor
           collect_def_ivar_writes(node, qualified_prefix, default_scope, accumulator,
                                   mutated_ivars, read_before_write, init_writes)
           return
+        when Prism::CallNode
+          if init_writes && !qualified_prefix.empty? &&
+             node.block.is_a?(Prism::BlockNode) &&
+             block_initializer?(qualified_prefix.join("::"), node.name, default_scope)
+            collect_block_ivar_writes(node.block, qualified_prefix, default_scope,
+                                      accumulator, mutated_ivars, init_writes)
+          end
         end
 
         node.compact_child_nodes.each do |child|
@@ -393,6 +412,53 @@ module Rigor
         collect_read_before_write_evidence(def_node, class_name, read_before_write, init_writes, default_scope)
       end
 
+      # ADR-38 block-form: collects ivar writes from a CallNode's
+      # block body (e.g. RSpec `before { @x = … }` / `let(:x) { … }`)
+      # and folds them into `init_writes`, suppressing the
+      # read-before-write nil contribution the same way a def-form
+      # initializer does. The block body is always treated as an
+      # initializer (the caller has already verified the method name
+      # is declared as a block_method initializer), so there is no
+      # read-before-write evidence collection step here.
+      def collect_block_ivar_writes(block_node, qualified_prefix, default_scope, accumulator,
+                                    mutated_ivars, init_writes)
+        return if block_node.body.nil? || qualified_prefix.empty?
+
+        class_name = qualified_prefix.join("::")
+        self_type = Type::Combinator.nominal_of(class_name)
+        body_scope = default_scope.with_self_type(self_type)
+
+        gather_ivar_writes(block_node.body, body_scope, class_name, accumulator,
+                           EMPTY_GUARDED_IVARS, mutated_ivars)
+
+        seen_writes = Set.new
+        read_first = Set.new
+        detect_read_before_write(block_node.body, seen_writes, read_first)
+        init_set = (init_writes[class_name] ||= Set.new)
+        seen_writes.each { |name| init_set << name }
+      end
+
+      # ADR-38 block-form gate: true when a loaded plugin declares
+      # `method_name` a block-form initializer for `class_name` (or
+      # an ancestor). Mirrors `additional_initializer?` but queries
+      # `covers_block_method?` instead of `covers_method?`.
+      def block_initializer?(class_name, method_name, default_scope)
+        return false if class_name.nil? || default_scope.nil?
+
+        environment = default_scope.environment
+        registry = environment&.plugin_registry
+        return false if registry.nil?
+        return false if registry.respond_to?(:empty?) && registry.empty?
+        return false unless registry.respond_to?(:additional_initializers)
+
+        registry.additional_initializers.any? do |entry|
+          entry.covers_block_method?(method_name) &&
+            class_matches_constraint?(class_name, entry.receiver_constraint, environment)
+        end
+      rescue StandardError
+        false
+      end
+
       # Walks the method body in AST (== execution) order
       # tracking ivar names whose first reference is a read.
       # The set is unioned into the class-wide
@@ -865,7 +931,7 @@ module Rigor
         end
       end
 
-      # rubocop:disable Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/AbcSize
+      # rubocop:disable Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/AbcSize, Metrics/PerceivedComplexity
       def walk_methods(node, qualified_prefix, in_singleton_class, accumulator)
         return unless node.is_a?(Prism::Node)
 
@@ -874,6 +940,7 @@ module Rigor
           name = qualified_name_for(node.constant_path)
           if name
             child_prefix = qualified_prefix + [name]
+            record_meta_superclass_members(node, child_prefix, accumulator) if node.is_a?(Prism::ClassNode)
             walk_methods(node.body, child_prefix, false, accumulator) if node.body
             return
           end
@@ -933,7 +1000,7 @@ module Rigor
           end
         end
       end
-      # rubocop:enable Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/AbcSize
+      # rubocop:enable Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/AbcSize, Metrics/PerceivedComplexity
 
       # v0.1.2 — when a `Const = Data.define(*sym) do ... end`
       # / `Const = Struct.new(*sym) do ... end` constant write
@@ -958,6 +1025,40 @@ module Rigor
         rvalue.block&.body
       end
 
+      # `class Foo < Data.define(:a, :b)` / `class Bar < Struct.new(:x)`
+      # synthesizes reader methods (`a`, `b`, `x`) on the subclass that no
+      # `def` / `attr_*` declares. Register them in the discovered-methods
+      # existence table so an implicit-self read of a member inside the
+      # class body is known to exist — both for the existing
+      # undefined-method suppression and for the ADR-24 slice-4 self-call
+      # recorder, which must treat a synthesized member as an existing
+      # method, not an unresolved call. The block-form
+      # (`Const = Data.define(:a) do ... end`) is handled by the
+      # `ConstantWriteNode` branch's block recursion; its members type
+      # `self` as `Object`, out of scope here.
+      def record_meta_superclass_members(class_node, qualified_prefix, accumulator)
+        superclass = class_node.superclass
+        return unless data_define_call?(superclass) || struct_new_call?(superclass)
+
+        members = meta_member_names(superclass)
+        return if members.empty?
+
+        class_name = qualified_prefix.join("::")
+        table = (accumulator[class_name] ||= {})
+        members.each { |member| table[member] ||= :instance }
+      end
+
+      # The Symbol member names of a `Data.define(*Symbol)` /
+      # `Struct.new(*Symbol [, keyword_init:])` call. For `Struct.new` the
+      # optional leading String name and trailing `keyword_init:` hash are
+      # stripped by {#struct_new_positionals}; `Data.define` args are all
+      # Symbols already.
+      def meta_member_names(call_node)
+        raw = call_node.arguments&.arguments || []
+        symbols = struct_new_call?(call_node) ? (struct_new_positionals(raw) || []) : raw
+        symbols.filter_map { |arg| arg.unescaped.to_sym if arg.is_a?(Prism::SymbolNode) }
+      end
+
       def record_def_method(def_node, qualified_prefix, in_singleton_class, accumulator)
         return if qualified_prefix.empty?
 
@@ -1114,6 +1215,58 @@ module Rigor
         end
       end
 
+      # ADR-48 — per qualified class name -> ordered `Data.define`
+      # member-name list, for both the named-subclass form
+      # (`class Point < Data.define(:x, :y)`) and the constant-assigned
+      # form (`Point = Data.define(:x, :y)`). Only `Data.define` is
+      # recorded: `Struct.new` instances are mutable, so member-value
+      # folding would be unsound (the Struct follow-up is deferred — see
+      # ADR-48 § "Struct follow-up"). Consumed by
+      # {Inference::MethodDispatcher::DataFolding} via
+      # {Scope#data_member_layout}.
+      def build_data_member_layouts(root)
+        accumulator = {}
+        walk_data_member_layouts(root, [], accumulator)
+        accumulator.freeze
+      end
+
+      def walk_data_member_layouts(node, qualified_prefix, accumulator)
+        return unless node.is_a?(Prism::Node)
+
+        case node
+        when Prism::ClassNode
+          name = qualified_name_for(node.constant_path)
+          if name
+            record_data_member_layout(accumulator, qualified_prefix + [name], node.superclass)
+            walk_data_member_layouts(node.body, qualified_prefix + [name], accumulator) if node.body
+            return
+          end
+        when Prism::ModuleNode
+          name = qualified_name_for(node.constant_path)
+          if name
+            walk_data_member_layouts(node.body, qualified_prefix + [name], accumulator) if node.body
+            return
+          end
+        when Prism::ConstantWriteNode
+          record_data_member_layout(accumulator, qualified_prefix + [node.name.to_s], node.value)
+        end
+
+        node.compact_child_nodes.each do |child|
+          walk_data_member_layouts(child, qualified_prefix, accumulator)
+        end
+      end
+
+      # Records `qualified -> [members]` when `expr` is a
+      # `Data.define(*Symbol)` call with at least one literal-Symbol member.
+      def record_data_member_layout(accumulator, qualified_parts, expr)
+        return unless data_define_call?(expr)
+
+        members = meta_member_names(expr)
+        return if members.empty?
+
+        accumulator[qualified_parts.join("::")] = members.freeze
+      end
+
       MIXIN_CALL_NAMES = %i[include prepend].freeze
 
       # ADR-24 slice 2 — per-class/module table mapping a fully
@@ -1480,9 +1633,10 @@ module Rigor
       # @param paths  [Array<String>] project file paths.
       # @param buffer [Rigor::Analysis::BufferBinding, nil]
       # @return [Hash{Symbol => Hash}]
-      #   `{ def_nodes:, def_sources:, superclasses:, includes: }`
+      #   `{ def_nodes:, def_sources:, superclasses:, includes:, class_sources: }`
       def discovered_def_index_for_paths(paths, buffer: nil)
-        acc = { def_nodes: {}, def_sources: {}, superclasses: {}, includes: {}, method_visibilities: {}, methods: {} }
+        acc = { def_nodes: {}, def_sources: {}, superclasses: {}, includes: {}, method_visibilities: {}, methods: {},
+                class_sources: {}, data_member_layouts: {} }
         paths.each do |path|
           physical = buffer ? buffer.resolve(path) : path
           root = Prism.parse(File.read(physical), filepath: path).value
@@ -1501,7 +1655,9 @@ module Rigor
         # intact while still letting `attr_reader :x` in one file
         # suppress a false undefined-method for `obj.x` in another.
         acc[:methods] = subtract_def_methods(acc[:methods], acc[:def_nodes])
-        %i[def_nodes def_sources includes method_visibilities methods].each { |key| acc[key].each_value(&:freeze) }
+        %i[def_nodes def_sources includes method_visibilities methods class_sources].each do |key|
+          acc[key].each_value(&:freeze)
+        end
         acc.transform_values(&:freeze)
       end
 
@@ -1522,10 +1678,21 @@ module Rigor
       # visibility declared in a sibling file.
       def accumulate_project_index(acc, path, root)
         merge_discovered_defs(acc[:def_nodes], acc[:def_sources], path, root)
-        acc[:superclasses].merge!(build_discovered_superclasses(root))
-        build_discovered_includes(root).each do |class_name, mods|
+        superclasses = build_discovered_superclasses(root)
+        includes = build_discovered_includes(root)
+        acc[:superclasses].merge!(superclasses)
+        includes.each do |class_name, mods|
           acc[:includes][class_name] = ((acc[:includes][class_name] || []) + mods).uniq
         end
+        record_class_sources(acc[:class_sources], path, root, superclasses, includes)
+        merge_class_keyed_index_tables(acc, root)
+        acc[:data_member_layouts].merge!(build_data_member_layouts(root))
+      end
+
+      # Folds the per-class method-visibility and method-existence tables of
+      # one file into the cross-file accumulator (kept out of
+      # {#accumulate_project_index} to hold its ABC budget).
+      def merge_class_keyed_index_tables(acc, root)
         build_discovered_method_visibilities(root).each do |class_name, table|
           (acc[:method_visibilities][class_name] ||= {}).merge!(table)
         end
@@ -1534,6 +1701,26 @@ module Rigor
         end
       end
 
+      # ADR-46 slice 1 — accumulates, per qualified user class/module
+      # name, the set of files that declare it. A class's declaration
+      # shape (its body `def`s, its `class Foo < Bar` superclass, its
+      # `include`s) lives wherever the class is opened, so every file that
+      # contributes a def / superclass / include for a name is a source of
+      # that name's ancestry edges. {Scope#superclass_of} /
+      # {Scope#includes_of} record this set when resolving the edge during
+      # dependency recording (ADR-46). The class-declaration walk
+      # (`collect_class_decls`) catches bodyless / def-less reopenings the
+      # other three builders miss.
+      def record_class_sources(class_sources, path, root, superclasses, includes)
+        names = Set.new
+        collect_class_decls(root, [], decls = {})
+        names.merge(decls.keys)
+        names.merge(superclasses.keys)
+        names.merge(includes.keys)
+        names.merge(build_discovered_def_nodes(root).keys)
+        names.each { |name| (class_sources[name] ||= Set.new) << path }
+      end
+
       # Merges one file's `class → method → DefNode` map into the
       # cross-file `def_nodes` index and records each method's first-
       # seen `"path:line"` definition site in `def_sources` (ADR-17 —