rigortype 0.3.2 → 0.3.4

data/lib/rigor/inference/pre_eval_constants.rb

@@ -0,0 +1,189 @@
+# frozen_string_literal: true
+
+require "prism"
+
+require_relative "../scope"
+require_relative "../type"
+require_relative "scope_indexer"
+
+module Rigor
+  module Inference
+    # Issue #352 / [ADR-17](../../../docs/adr/17-monkey-patch-pre-evaluation.md) — the constant half of the
+    # `pre_eval:` publication surface.
+    #
+    # ADR-17 slice 2 gave `pre_eval:` a project-wide **method** registry ({ProjectPatchedMethods}). A
+    # constant declared in the same file stayed invisible across the file boundary: `Scope#in_source_constants`
+    # is per-file and is deliberately not part of `Runner#project_scope_seed_tables`, so only class-shaped
+    # constants (a `class` / `module` declaration, or one of the four meta-new forms `ScopeIndexer`'s
+    # `record_class_new_constant_decl` promotes) ever crossed. `TIMEOUT = 30` in a listed file read as
+    # `Dynamic[top]` everywhere else.
+    #
+    # This collector closes that half. It walks the `pre_eval:` files with the SAME constant pre-pass the
+    # per-file path uses ({ScopeIndexer.build_in_source_constants}) and publishes the result — widened — into
+    # the project seed. Files not listed under `pre_eval:` are untouched, so the feature is opt-in by
+    # construction and its cost stays proportional to the listed file count (ADR-17 WD1's cost-bounded
+    # argument, which is also why slice 5's full-project two-pass stayed rejectable).
+    #
+    # ## The widening rule — why the published type is not the same-file type
+    #
+    # Same-file constant propagation is **value-pinned**: `42`, `"hello"`, a `Tuple`, a `HashShape`. Carrying
+    # that verbatim across a file boundary would land diagnostics in files whose author never opened the
+    # constant's definition — `CONFIG = { a: 1 }` arriving as a closed `HashShape` makes `CONFIG.fetch(:b)`
+    # fire, `ARR = [1, 2]` arriving as a `Tuple` routes through `ShapeDispatch` instead of the RBS overload a
+    # call site relied on. Today's cross-file `Dynamic[top]` is false-positive-free *by construction*, so
+    # precision here can only spend that budget; AGENTS.md § "Implementation Guidelines" ranks false positives
+    # above worst-case static reading, so this slice spends as little of it as possible.
+    #
+    # {.widen} therefore publishes the **erased class**, never the value:
+    #
+    # | Declared | Same file | Published cross-file |
+    # | --- | --- | --- |
+    # | `INT_LIT = 42` | `42` | `Integer` |
+    # | `STR_LIT = "hello"` | `"hello"` | `String` |
+    # | `ARR_LIT = [1, 2]` | `[1, 2]` (Tuple) | `Array` (raw, elements dropped) |
+    # | `HSH_LIT = { a: 1 }` | `{ a: 1 }` (HashShape) | `Hash` (raw, keys dropped) |
+    # | `ALIAS_CLS = String` | `singleton(String)` | `singleton(String)` |
+    # | `Nest::NESTED_INT = 7` | `7` | `Integer` |
+    #
+    # Anything the rule does not recognise **declines** — the name is simply not published and reads exactly
+    # as it does today. Declining is always the safe answer here, which is why the `else` arm is `nil` rather
+    # than a fallback. `Constant[nil]` declines on purpose: a `X = nil` at declaration position is a
+    # placeholder for a value assigned at runtime far more often than it is a genuine `NilClass`, and
+    # publishing `NilClass` project-wide would make every use of it a diagnostic.
+    #
+    # Value-pinning a *provably* frozen single-write literal cross-file is a strictly later question; it needs
+    # its own FP measurement and is deliberately not attempted here.
+    #
+    # ## The multi-file write rule — widen on conflict, all the way to `Dynamic[top]`
+    #
+    # Within one file, `ScopeIndexer#record_constant_write` unions repeated writes; that union is widened as a
+    # whole (`X = 1; X = "a"` in one file publishes `Integer | String`). ACROSS files the same union would be
+    # a type neither author can see, so the rule is **widen on conflict**: when two listed files publish the
+    # same qualified name with different widened types, the name is dropped from the table entirely and reads
+    # as `Dynamic[top]` — the widest type there is, and the one the name already had. Agreeing writes (`X = 1`
+    # here, `X = 2` there — both `Integer`) are not a conflict at all, which is the point of widening first:
+    # `1 | 2` is never produced.
+    #
+    # ## Ordering
+    #
+    # The published table seeds `Scope#in_source_constants`, which `Reflection.constant_type_at` consults
+    # AFTER the class registry and `discovered_classes`. A published entry can therefore never mask a
+    # class-shaped constant that already crossed, and the per-file table always wins over the seed (see
+    # {ScopeIndexer.index}'s merge) — same-file remains the most specific authority.
+    module PreEvalConstants
+      EMPTY = {}.freeze
+
+      module_function
+
+      # Collects and widens the constants every `pre_eval:` file declares.
+      #
+      # @param paths [Array<String>] absolute paths to the `pre_eval:` files that exist on disk.
+      # @param scope_builder [#call] `path -> Rigor::Scope`; the caller supplies a project-seeded, environment-
+      #   bound scope so the rvalue typer resolves cross-file classes exactly as per-file analysis would.
+      # @param target_ruby [String, nil] the Prism parse version (`Configuration#target_ruby`).
+      # @param buffer [Rigor::Analysis::BufferBinding, nil] editor-mode binding; when set, a listed file that
+      #   matches the in-flight buffer is read from its physical bytes.
+      # @return [Hash{String => Rigor::Type}] frozen qualified-name -> published type table.
+      def collect(paths:, scope_builder:, target_ruby: nil, buffer: nil)
+        published = {}
+        conflicted = {}
+        paths.each do |path|
+          file_constants(path, scope_builder: scope_builder, target_ruby: target_ruby, buffer: buffer)
+            .each { |name, type| merge_publication(published, conflicted, name, type) }
+        end
+        published.freeze
+      end
+
+      # Folds one declaration into the accumulator under the widen-on-conflict rule. A name that has already
+      # conflicted stays out for the rest of the collection — a later agreeing write must not resurrect it.
+      def merge_publication(published, conflicted, name, type)
+        return if conflicted.key?(name)
+
+        widened = widen(type)
+        return if widened.nil?
+
+        existing = published[name]
+        return published[name] = widened if existing.nil?
+        return if existing == widened
+
+        published.delete(name)
+        conflicted[name] = true
+      end
+      private_class_method :merge_publication
+
+      # The per-file constant table, typed through the same pre-pass the per-file path runs. Deliberately NOT
+      # a full `ScopeIndexer.index`: ADR-17 WD4 keeps the pre-eval pass a discovery walk, and the constant
+      # pre-pass (plus the declaration artifacts it needs to resolve in-file class references) is exactly the
+      # discovery facet this feature consumes. Fails soft to the empty table — a pre-eval file that cannot be
+      # read or parsed already surfaces a `pre-eval.parse-error` warning from {ProjectPatchedScanner}, and it
+      # must never break the run.
+      def file_constants(path, scope_builder:, target_ruby: nil, buffer: nil)
+        physical = buffer ? buffer.resolve(path) : path
+        parse_result = Prism.parse(File.read(physical), filepath: path, version: target_ruby)
+        return EMPTY unless parse_result.errors.empty?
+
+        root = parse_result.value
+        ScopeIndexer.build_in_source_constants(root, declaration_seeded_scope(root, scope_builder.call(path)))
+      rescue StandardError
+        EMPTY
+      end
+      private_class_method :file_constants
+
+      # Mirrors the head of {ScopeIndexer.index}: seed the file's own declaration overrides and discovered
+      # classes onto the project-seeded scope so a `CONST = SomeClassDefinedRightHere.new` rvalue types the
+      # same way it does during real analysis.
+      def declaration_seeded_scope(root, scope)
+        declared_types, discovered_classes = ScopeIndexer.build_declaration_artifacts(root)
+        scope.with_discovery(
+          scope.discovery.with(
+            declared_types: declared_types,
+            discovered_classes: scope.discovered_classes.merge(discovered_classes)
+          )
+        )
+      end
+      private_class_method :declaration_seeded_scope
+
+      # The publication widening. Returns the type to publish, or `nil` to decline (the name keeps today's
+      # `Dynamic[top]` cross-file reading). See the module doc for why declining is the safe default.
+      def widen(type)
+        case type
+        when Type::Constant then widen_constant(type)
+        when Type::Refined then widen(type.base)
+        when Type::IntegerRange then Type::Combinator.nominal_of("Integer")
+        when Type::Tuple then Type::Combinator.nominal_of("Array")
+        when Type::HashShape then Type::Combinator.nominal_of("Hash")
+        when Type::Nominal then type.type_args.empty? ? type : Type::Combinator.nominal_of(type.class_name)
+        when Type::Singleton then type
+        when Type::DataInstance, Type::StructInstance then nominal_for_class_name(type.class_name)
+        when Type::Union then widen_union(type)
+        end
+      end
+
+      # `Constant[v]` publishes `v`'s class. `nil` declines (see the module doc); so does a value whose class
+      # is anonymous, which has no name to publish under.
+      def widen_constant(type)
+        return nil if type.value.nil?
+
+        nominal_for_class_name(type.value.class.name)
+      end
+      private_class_method :widen_constant
+
+      def nominal_for_class_name(class_name)
+        return nil unless class_name.is_a?(String) && !class_name.empty?
+
+        Type::Combinator.nominal_of(class_name)
+      end
+      private_class_method :nominal_for_class_name
+
+      # A union publishes only when EVERY member widens: one unrecognised arm means the union's real extent is
+      # unknown, and a partial union would be narrower than the truth — the false-positive direction.
+      def widen_union(type)
+        widened = type.members.map { |member| widen(member) }
+        return nil if widened.any?(&:nil?)
+
+        Type::Combinator.union(*widened)
+      end
+      private_class_method :widen_union
+    end
+  end
+end

data/lib/rigor/inference/scope_indexer.rb

@@ -7,6 +7,7 @@ require_relative "../type"
 require_relative "../source/constant_path"
 require_relative "../source/node_children"
 require_relative "../cache/file_digest"
+require_relative "anonymous_meta_class"
 require_relative "def_handle"
 require_relative "mutation_widening"
 require_relative "narrowing"
@@ -87,10 +88,13 @@ module Rigor
         # program and types its rvalue under a scope that carries the surrounding qualified prefix as `self_type`, so
         # the rvalue typer sees in-class references resolve correctly. Multiple writes to the same qualified name union
         # via `Type::Combinator.union`.
+        # Issue #352 — the per-file table merges OVER whatever the base scope already published (the
+        # `pre_eval:` constant seed `Runner#project_scope_seed_tables` applies). Same-file declarations are the
+        # most specific authority, exactly as `merged_classes` above resolves the same collision. Without the
+        # merge, the assignment below would silently drop the project seed on every file.
         in_source_constants = build_in_source_constants(root, seeded_scope)
-        seeded_scope = seeded_scope.with_discovery(
-          seeded_scope.discovery.with(in_source_constants: in_source_constants)
-        )
+        merged_constants = merge_seeded_constants(default_scope.in_source_constants, in_source_constants)
+        seeded_scope = seeded_scope.with_discovery(seeded_scope.discovery.with(in_source_constants: merged_constants))
 
         # Slice 7 phase 12. In-source method discovery. Walks every class/module body for `Prism::DefNode` and
         # recognised `define_method` calls and records the introduced method names. `rigor check` consults the table to
@@ -133,7 +137,7 @@ module Rigor
       # file_def_nodes]` so the caller can thread the def-node table into {#merge_project_method_indexes} without
       # walking the file a second time.
       def seed_discovered_methods(seeded_scope, default_scope, root)
-        file_methods, file_def_nodes = build_methods_and_def_nodes(root)
+        file_methods, file_def_nodes = build_methods_and_def_nodes(root, default_scope.source_path)
         discovered_methods = deep_merge_class_methods(default_scope.discovered_methods, file_methods)
         scope = seeded_scope.with_discovery(seeded_scope.discovery.with(discovered_methods: discovered_methods))
         [scope, file_def_nodes]
@@ -161,7 +165,7 @@ module Rigor
           build_discovered_singleton_def_nodes(root)
         ) { |_class, cross_file, per_file| cross_file.merge(per_file) }
         superclasses = default_scope.discovered_superclasses.merge(
-          build_discovered_superclasses(root)
+          build_discovered_superclasses(root, default_scope.source_path)
         )
         includes = default_scope.discovered_includes.merge(
           build_discovered_includes(root)
@@ -1205,6 +1209,15 @@ module Rigor
         accumulator.freeze
       end
 
+      # Issue #352 — folds the project-wide `pre_eval:` constant seed under this file's own table. Returns the
+      # per-file table unchanged (same frozen object) when nothing was seeded, so a run without `pre_eval:`
+      # constants allocates and compares exactly what it did before.
+      def merge_seeded_constants(seeded, per_file)
+        return per_file if seeded.nil? || seeded.empty?
+
+        seeded.merge(per_file).freeze
+      end
+
       def walk_constant_writes(node, qualified_prefix, default_scope, accumulator)
         return unless node.is_a?(Prism::Node)
 
@@ -1266,10 +1279,10 @@ module Rigor
       # `walk_methods` and `walk_def_nodes` had byte-identical class / module / singleton / meta-block descents (both
       # stop at `DefNode`), so a single combined walk records both accumulators at once instead of traversing every file
       # twice.
-      def build_methods_and_def_nodes(root)
+      def build_methods_and_def_nodes(root, source_path = nil)
         methods = {}
         def_nodes = {}
-        walk_methods_and_def_nodes(root, [], false, methods, def_nodes)
+        walk_methods_and_def_nodes(root, [], false, methods, def_nodes, source_path)
         apply_alias_def_nodes(root, def_nodes)
         [methods.transform_values(&:freeze).freeze, def_nodes.transform_values(&:freeze).freeze]
       end
@@ -1315,7 +1328,8 @@ module Rigor
       # right accumulator) and the original `walk_methods` returning at `AliasMethodNode` (its symbol-only children
       # carry no def / class node, so not descending them is byte-identical for `def_nodes` too). See
       # {#build_methods_and_def_nodes}.
-      def walk_methods_and_def_nodes(node, qualified_prefix, in_singleton_class, methods_acc, def_nodes_acc)
+      def walk_methods_and_def_nodes(node, qualified_prefix, in_singleton_class, methods_acc, def_nodes_acc,
+                                     source_path = nil)
         return unless node.is_a?(Prism::Node)
 
         case node
@@ -1324,21 +1338,27 @@ module Rigor
           if name
             child_prefix = qualified_prefix + [name]
             record_meta_superclass_members(node, child_prefix, methods_acc) if node.is_a?(Prism::ClassNode)
-            walk_methods_and_def_nodes(node.body, child_prefix, false, methods_acc, def_nodes_acc) if node.body
+            if node.body
+              walk_methods_and_def_nodes(node.body, child_prefix, false, methods_acc, def_nodes_acc, source_path)
+            end
             return
           end
         when Prism::SingletonClassNode
           if node.body
             singleton_prefix = singleton_class_prefix(node, qualified_prefix)
             if singleton_prefix
-              walk_methods_and_def_nodes(node.body, singleton_prefix, true, methods_acc, def_nodes_acc)
+              walk_methods_and_def_nodes(node.body, singleton_prefix, true, methods_acc, def_nodes_acc, source_path)
               return
             end
           end
         when Prism::ConstantWriteNode
           if meta_new_block_body(node)
             child_prefix = qualified_prefix + [node.name.to_s]
-            walk_methods_and_def_nodes(meta_new_block_body(node), child_prefix, false, methods_acc, def_nodes_acc)
+            walk_methods_and_def_nodes(meta_new_block_body(node), child_prefix, false, methods_acc, def_nodes_acc,
+                                       source_path)
+            # No anonymous registration here: the constant IS the name, and `StatementEvaluator` never routes a
+            # constant-write rvalue through the block-body narrowing (its scope index still shows `self` as
+            # `Dynamic[top]` inside such a body), so the two passes agree on the constant name alone.
             return
           end
         when Prism::DefNode
@@ -1349,14 +1369,43 @@ module Rigor
           record_alias_method(node, qualified_prefix, in_singleton_class, methods_acc)
           return
         when Prism::CallNode
-          record_define_method(node, qualified_prefix, in_singleton_class, methods_acc) if node.name == :define_method
-          if ATTR_MACROS.include?(node.name)
-            record_attr_methods(node, qualified_prefix, in_singleton_class, methods_acc)
+          anonymous = record_call_node_methods(node, qualified_prefix, in_singleton_class, methods_acc, source_path)
+          if anonymous
+            walk_anonymous_meta_block(node, anonymous, qualified_prefix, in_singleton_class, methods_acc,
+                                      def_nodes_acc, source_path)
+            return
           end
         end
 
         node.rigor_each_child do |child|
-          walk_methods_and_def_nodes(child, qualified_prefix, in_singleton_class, methods_acc, def_nodes_acc)
+          walk_methods_and_def_nodes(child, qualified_prefix, in_singleton_class, methods_acc, def_nodes_acc,
+                                     source_path)
+        end
+      end
+
+      # The `Prism::CallNode` leaf actions of {#walk_methods_and_def_nodes}: the `define_method` / `attr_*` macro
+      # recorders, plus the {AnonymousMetaClass} name of a class-creating meta call carrying a block (nil for
+      # every other call), which the caller uses to decide whether the block body needs the anonymous-class-body
+      # descent.
+      def record_call_node_methods(node, qualified_prefix, in_singleton_class, methods_acc, source_path)
+        record_define_method(node, qualified_prefix, in_singleton_class, methods_acc) if node.name == :define_method
+        record_attr_methods(node, qualified_prefix, in_singleton_class, methods_acc) if ATTR_MACROS.include?(node.name)
+        AnonymousMetaClass.name_for(node, source_path)
+      end
+
+      # #319 — walks a `Class.new do ... end` / `Module.new do ... end` / `Struct.new(*sym) do ... end` /
+      # `Data.define(*sym) do ... end` block body as the class body it is at runtime, keyed by the call site's
+      # synthetic anonymous `name`; the call's other children (receiver, arguments) keep the enclosing prefix.
+      def walk_anonymous_meta_block(call_node, name, qualified_prefix, in_singleton_class, methods_acc,
+                                    def_nodes_acc, source_path)
+        call_node.rigor_each_child do |child|
+          if child.equal?(call_node.block)
+            body = call_node.block.body
+            walk_methods_and_def_nodes(body, [name], false, methods_acc, def_nodes_acc, source_path) if body
+          else
+            walk_methods_and_def_nodes(child, qualified_prefix, in_singleton_class, methods_acc, def_nodes_acc,
+                                       source_path)
+          end
         end
       end
 
@@ -1366,21 +1415,38 @@ module Rigor
       #     (semantically `class << self`).
       #   - `class << Foo` not nested in `class Foo` returns `[Foo]`
       #     so methods defined inside register on Foo's singleton.
+      #   - `class << Foo = <expr>` (#320, the private-singleton-object
+      #     idiom) is the same case: Ruby evaluates the assignment, then
+      #     opens the singleton of the resulting object — which is the
+      #     object `Foo` now holds — so the body's methods are reachable
+      #     as `Foo.<name>` exactly as for a plain constant read.
       #   - Any other expression (variable, method call) returns nil
       #     so the walker falls through and skips the body.
       def singleton_class_prefix(node, qualified_prefix)
-        case node.expression
-        when Prism::SelfNode
+        return qualified_prefix if node.expression.is_a?(Prism::SelfNode)
+
+        rendered = singleton_receiver_constant_name(node.expression)
+        return nil unless rendered
+
+        if !qualified_prefix.empty? && qualified_prefix.last == rendered
           qualified_prefix
-        when Prism::ConstantReadNode, Prism::ConstantPathNode
-          rendered = Source::ConstantPath.qualified_name(node.expression)
-          return nil unless rendered
+        else
+          rendered.split("::")
+        end
+      end
 
-          if !qualified_prefix.empty? && qualified_prefix.last == rendered
-            qualified_prefix
-          else
-            rendered.split("::")
-          end
+      # The constant a `class << X` operand names, or nil when the operand is not constant-shaped. Both the
+      # read spellings (`Foo`, `A::Foo`, `::Foo`) and the two constant-*write* spellings (`Foo = expr`,
+      # `A::Foo = expr`) resolve to the same unqualified rendering the read branch uses, so a body opened on
+      # the assignment and one opened on a later plain read land on the same table key.
+      def singleton_receiver_constant_name(expression)
+        case expression
+        when Prism::ConstantReadNode, Prism::ConstantPathNode
+          Source::ConstantPath.qualified_name(expression)
+        when Prism::ConstantWriteNode
+          expression.name.to_s
+        when Prism::ConstantPathWriteNode
+          Source::ConstantPath.qualified_name(expression.target)
         end
       end
       # rubocop:enable Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/AbcSize
@@ -1483,6 +1549,24 @@ module Rigor
         class_name = qualified_prefix.empty? ? TOP_LEVEL_DEF_KEY : qualified_prefix.join("::")
         accumulator[class_name] ||= {}
         accumulator[class_name][def_node.name] = def_node
+        record_anonymous_body_def_as_toplevel(def_node, qualified_prefix, accumulator)
+      end
+
+      # #319 — a `def` inside an anonymous `Class.new` / `Module.new` body ALSO stays in the `<toplevel>` table.
+      # Before the anonymous class had a name the body was walked with an empty prefix, so every such `def`
+      # landed there; that is the same leniency this key already grants a `def` nested in any other DSL block
+      # (see {TOP_LEVEL_DEF_KEY}), and it is what lets an implicit-self call elsewhere in the file resolve
+      # against a method the anonymous module contributes to some other object's `self` — the
+      # `Module.new { def start; end }` mixed into a spawned actor environment, then called from the sibling
+      # `spawn(...) { start }` block. Giving the body a class of its own must not silently retract it: the call
+      # resolves at runtime, and `call.unresolved-toplevel` firing on it would be a new false positive traded
+      # for the ones this change retires. Never clobbers a real top-level `def` of the same name.
+      def record_anonymous_body_def_as_toplevel(def_node, qualified_prefix, accumulator)
+        return unless qualified_prefix.length == 1
+        return unless Type::AnonymousClassName.match?(qualified_prefix.first)
+
+        table = (accumulator[TOP_LEVEL_DEF_KEY] ||= {})
+        table[def_node.name] ||= def_node
       end
 
       # Module-singleton call resolution (ADR-57 follow-up) — the SINGLETON-side mirror of `build_discovered_def_nodes`.
@@ -1617,16 +1701,18 @@ module Rigor
       # `class Foo < Bar` declaration. Only constant superclasses are recorded (`class Foo < Struct.new(...)` and other
       # non-constant superclasses produce no entry). The as-written name is resolved to a qualified class at the call
       # site against the subclass's lexical nesting — see `ExpressionTyper#resolve_ancestor_class_name`.
-      def build_discovered_superclasses(root)
+      def build_discovered_superclasses(root, source_path = nil)
         accumulator = {}
-        walk_class_superclasses(root, [], accumulator)
+        walk_class_superclasses(root, [], accumulator, source_path)
         accumulator.freeze
       end
 
-      def walk_class_superclasses(node, qualified_prefix, accumulator)
+      def walk_class_superclasses(node, qualified_prefix, accumulator, source_path = nil)
         return unless node.is_a?(Prism::Node)
 
         case node
+        when Prism::CallNode
+          record_anonymous_meta_superclass(node, accumulator, source_path)
         when Prism::ClassNode
           name = Source::ConstantPath.qualified_name(node.constant_path)
           if name
@@ -1645,10 +1731,27 @@ module Rigor
         end
 
         node.rigor_each_child do |child|
-          walk_class_superclasses(child, qualified_prefix, accumulator)
+          walk_class_superclasses(child, qualified_prefix, accumulator, source_path)
         end
       end
 
+      # #319 — `Class.new(Parent) do ... end` names its superclass in the first positional. Recording it under the
+      # call site's anonymous name keeps `Parent`'s surface reachable from the block body (whose `self_type` is now
+      # `Singleton[<anonymous>]`) and from an instance of the resulting class, so giving the anonymous class an
+      # identity does not cost the inheritance the old `Singleton[Parent]` answer carried for free.
+      def record_anonymous_meta_superclass(call_node, accumulator, source_path)
+        return unless AnonymousMetaClass.block_form_receiver(call_node) == :Class
+
+        arg = call_node.arguments&.arguments&.first
+        return if arg.nil?
+
+        superclass = Source::ConstantPath.qualified_name(arg)
+        return if superclass.nil?
+
+        name = AnonymousMetaClass.name_for(call_node, source_path)
+        accumulator[name] = superclass if name
+      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
@@ -2511,7 +2614,7 @@ module Rigor
         # One combined descent yields both the methods existence table and the def-node table; the latter is also
         # consumed by `record_class_sources`, so a def-dense file is walked once here instead of three times (methods +
         # def-nodes ×2). See {#build_methods_and_def_nodes}.
-        file_methods, file_def_nodes = build_methods_and_def_nodes(root)
+        file_methods, file_def_nodes = build_methods_and_def_nodes(root, path)
         merge_discovered_defs(acc[:def_nodes], acc[:def_sources], path, file_def_nodes)
         # ADR-46 slice 4 (singleton) — record the singleton-side `"path:line"` sources alongside the nodes,
         # the exact mirror of the instance-side `merge_discovered_defs`, so a class/singleton-method body edit
@@ -2519,7 +2622,7 @@ module Rigor
         # silently degrading to the file's full ancestry closure.
         merge_discovered_defs(acc[:singleton_def_nodes], acc[:singleton_def_sources], path,
                               build_discovered_singleton_def_nodes(root))
-        superclasses = build_discovered_superclasses(root)
+        superclasses = build_discovered_superclasses(root, path)
         includes = build_discovered_includes(root)
         acc[:superclasses].merge!(superclasses)
         includes.each do |class_name, mods|

data/lib/rigor/inference/singleton_object_constant.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require_relative "../source/constant_path"
+
+module Rigor
+  module Inference
+    # Issue #320 — the *private-singleton-object* idiom: a constant holds a plain object whose singleton
+    # class carries the methods.
+    #
+    #     class << Merger = Object.new
+    #       def merge_attributes!(a, b) = a
+    #     end
+    #     Merger.merge_attributes!({}, {})
+    #
+    # {ScopeIndexer} already records such a body under the constant's own name with kind `:singleton` — that
+    # keying is correct for both spellings, since `Foo.bar` means "call `bar` on the value of constant `Foo`"
+    # whether the value is a class object or an ordinary object. The gap is on the *receiver* side: when the
+    # constant names a class or module the read types as `Singleton[Foo]` and dispatch recovers the name from
+    # the type, but when it holds an ordinary object the read types as `Nominal[Object]` and the name is
+    # gone — so every method in the body is invisible and `call.undefined-method` fires on working code.
+    #
+    # This module recovers the name from the receiver *syntax* instead, for exactly the receivers whose type
+    # has lost it. `Singleton` receivers are excluded so the established class/module path keeps its
+    # precedence; a receiver whose constant has no recorded singleton body yields nil, so an undefined method
+    # on such a constant (`Merger.nope`) still fires.
+    module SingletonObjectConstant
+      module_function
+
+      # The constant name a call's receiver names, when that receiver is a constant reference whose type is
+      # not already a `Singleton` carrier. Nil for every other receiver shape.
+      def receiver_constant_name(call_node, receiver_type)
+        return nil if receiver_type.is_a?(Type::Singleton)
+
+        receiver = call_node.receiver
+        return nil unless receiver.is_a?(Prism::ConstantReadNode) || receiver.is_a?(Prism::ConstantPathNode)
+
+        Source::ConstantPath.qualified_name(receiver)
+      end
+
+      # True when the project recorded `method_name` on the singleton side of the constant this call's
+      # receiver names. The suppression probe for `call.undefined-method`.
+      def recorded?(call_node, receiver_type, method_name, scope)
+        return false if scope.nil?
+
+        name = receiver_constant_name(call_node, receiver_type)
+        return false if name.nil?
+
+        scope.discovered_method?(name, method_name, :singleton)
+      end
+
+      # The `Prism::DefNode` for `method_name` in the constant's singleton body, or nil. The inference tier's
+      # entry point.
+      def def_node_for(call_node, receiver_type, method_name, scope)
+        return nil if scope.nil?
+
+        name = receiver_constant_name(call_node, receiver_type)
+        return nil if name.nil?
+
+        scope.singleton_def_for(name, method_name)
+      end
+    end
+  end
+end

data/lib/rigor/inference/statement_evaluator.rb

@@ -8,6 +8,7 @@ require_relative "../analysis/fact_store"
 require_relative "../source/node_walker"
 require_relative "../source/node_children"
 require_relative "../source/constant_path"
+require_relative "anonymous_meta_class"
 require_relative "block_parameter_binder"
 require_relative "body_fixpoint"
 require_relative "dynamic_origin"
@@ -20,6 +21,7 @@ require_relative "method_parameter_binder"
 require_relative "multi_target_binder"
 require_relative "mutation_widening"
 require_relative "narrowing"
+require_relative "optimistic_origin"
 
 module Rigor
   module Inference
@@ -259,17 +261,11 @@ module Rigor
         optimistic_origin_for(value_node, scope_after_rhs)
       end
 
-      # The effective optimistic-nil-free cause of an expression: the mark on its own node, else — for a bare
-      # local read or a local write used in value position (`if (x = MAP[k])`, where the write has already
-      # bound the mark) — the one propagated onto the binding.
+      # The effective optimistic-nil-free cause of an expression. {Inference::OptimisticOrigin.resolve} owns
+      # the judgment — the mark on the node itself, the binding a bare local / ivar read resolves through, and
+      # the predicate-fold derivation of issue #313.
       def optimistic_origin_for(node, scope)
-        recorded = scope.optimistic_origins[node]
-        return recorded if recorded
-
-        case node
-        when Prism::LocalVariableReadNode, Prism::LocalVariableWriteNode then scope.optimistic_local(node.name)
-        when Prism::InstanceVariableReadNode, Prism::InstanceVariableWriteNode then scope.optimistic_ivar(node.name)
-        end
+        Inference::OptimisticOrigin.resolve(node, scope)
       end
 
       # ADR-82 WD1 — the {Inference::DynamicOrigin} cause to propagate onto a local / ivar being bound to `rhs`.
@@ -1827,7 +1823,20 @@ module Rigor
         return unless block.is_a?(Prism::BlockNode)
 
         block_entry = build_block_entry_scope(node, block)
-        sub_eval(block, block_entry)
+        # #319 — `Class.new do ... end` and friends evaluate their block as a CLASS BODY (`class_eval`
+        # semantics): `self` is the freshly created class, so a `def` inside defines an instance method on it
+        # and `attr_reader` runs as a class-level macro. Enter the block under the same `self_type` /
+        # class-context a `class Foo ... end` body gets, keyed by the call site's anonymous name — the name
+        # `ScopeIndexer` registered the body's methods under. Without it the body inherits the enclosing
+        # scope, and at file top level that means `Scope#toplevel?` (a nil `self_type`) reports every macro
+        # call in the body as `call.unresolved-toplevel`.
+        #
+        # Outer locals stay visible: unlike a `class` keyword body, the block is a closure.
+        anonymous = AnonymousMetaClass.name_for(node, scope.source_path)
+        return sub_eval(block, block_entry) if anonymous.nil?
+
+        sub_eval(block, block_entry.with_self_type(Type::Combinator.singleton_of(anonymous)),
+                 class_context: [ClassFrame.new(name: anonymous, singleton: false)])
       end
 
       # Slice 6 phase C sub-phase 3b/3c. When the call carries a block whose receiving method is NOT proven
@@ -2504,7 +2513,11 @@ module Rigor
       def build_block_entry_scope(call_node, block_node)
         expected = expected_block_param_types_for(call_node)
         bindings = BlockParameterBinder.new(expected_param_types: expected).bind(block_node)
-        scope_with_params = bindings.reduce(scope) { |acc, (name, type)| acc.with_local(name, type) }
+        # Issue #316 — every block body enters with `self` unmodelled (`Scope#entering_opaque_block`); the
+        # yielding method, not the lexical context, decides what `self` is, and Rigor does not track it.
+        scope_with_params = bindings.reduce(scope.entering_opaque_block) do |acc, (name, type)|
+          acc.with_local(name, type)
+        end
         block_local_names(block_node).reduce(scope_with_params) do |acc, name|
           acc.with_local(name, Type::Combinator.constant_of(nil))
         end

data/lib/rigor/plugin/base.rb

@@ -710,6 +710,30 @@ module Rigor
         manifest.protocol_contracts
       end
 
+      # ADR-103 WD6 / WD10 (#387) — the plugin's effect contributions. Each defaults to the manifest field
+      # and each MAY be overridden to fold in per-project facts, exactly as {#protocol_contracts} may.
+      #
+      # {#effect_attributions} is the one that needs it: a Rails app's ActiveJob transport is whatever
+      # `config.active_job.queue_adapter` names, so rigor-activejob answers `io.db.write` for Solid Queue
+      # and `io.net` for Sidekiq by reading the project's own configuration. That read is a plugin-side I/O
+      # boundary read and must not happen on a run with effects off — {Registry#effect_contributions} is
+      # lazy for exactly that reason, and nothing asks unless the project has an `effects:` block.
+      def effect_attributions
+        manifest.effect_attributions
+      end
+
+      def effect_edges
+        manifest.effect_edges
+      end
+
+      def effect_labels
+        manifest.effect_labels
+      end
+
+      def effect_entry_points
+        manifest.effect_entry_points
+      end
+
       # ADR-7 § "Slice 6-A/6-B" — per-plugin {IoBoundary}. Memoised so the boundary's accumulated `FileEntry`
       # rows persist across producer invocations within the same plugin instance and feed cache invalidation
       # via `cache_for`.