rigortype 0.3.1 → 0.3.3

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"
@@ -133,7 +134,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 +162,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)
@@ -1266,32 +1267,57 @@ 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
 
       # Merges two `class_name => { method => kind }` tables, unioning the per-class method maps (so a seeded cross-file
-      # table and the current file's table combine instead of clobbering).
+      # table and the current file's table combine instead of clobbering). A name recorded on both sides — an instance
+      # `def` here and a `class << self` twin there — merges to {Scope::DiscoveryIndex::METHOD_KIND_BOTH} rather than
+      # letting the overlay's kind win (#239).
       def deep_merge_class_methods(base, overlay)
         return overlay if base.nil? || base.empty?
         return base if overlay.empty?
 
         base.merge(overlay) do |_class_name, base_methods, overlay_methods|
-          base_methods.merge(overlay_methods)
+          merge_method_kinds(base_methods, overlay_methods)
         end
       end
 
+      # `{ method => kind }` union that promotes a kind disagreement to `METHOD_KIND_BOTH` instead of clobbering.
+      def merge_method_kinds(base_methods, overlay_methods)
+        base_methods.merge(overlay_methods) do |_method_name, base_kind, overlay_kind|
+          base_kind == overlay_kind ? base_kind : Scope::DiscoveryIndex::METHOD_KIND_BOTH
+        end
+      end
+
+      # The single write path into a `class_name => { method => kind }` existence table. Every recorder goes through
+      # it so a class that defines one name on both sides keeps both facts: the table is keyed by name alone, so a
+      # bare assignment silently replaced the other side's kind and `Scope#discovered_method?` then answered false for
+      # a method the source plainly defines (#239).
+      def record_method_kind(accumulator, class_name, method_name, kind)
+        table = (accumulator[class_name] ||= {})
+        recorded = table[method_name]
+        table[method_name] =
+          if recorded.nil? || recorded == kind
+            kind
+          else
+            Scope::DiscoveryIndex::METHOD_KIND_BOTH
+          end
+      end
+
       # rubocop:disable Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/AbcSize
       # Combined `walk_methods` + `walk_def_nodes` descent. The two walks had identical class / module / singleton-class
       # / meta-block traversals and both stopped at `DefNode`; the only divergences are leaf actions (recorded into the
       # 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
@@ -1300,21 +1326,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
@@ -1325,14 +1357,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
 
@@ -1342,21 +1403,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
@@ -1393,8 +1471,7 @@ module Rigor
         return if members.empty?
 
         class_name = qualified_prefix.join("::")
-        table = (accumulator[class_name] ||= {})
-        members.each { |member| table[member] ||= :instance }
+        members.each { |member| record_method_kind(accumulator, class_name, member, :instance) }
       end
 
       # The Symbol member names of a `Data.define(*Symbol)` / `Struct.new(*Symbol [, keyword_init:])` call. For
@@ -1412,8 +1489,7 @@ module Rigor
         class_name = qualified_prefix.join("::")
         singleton = def_singleton?(def_node, qualified_prefix, in_singleton_class)
         kind = singleton ? :singleton : :instance
-        accumulator[class_name] ||= {}
-        accumulator[class_name][def_node.name] = kind
+        record_method_kind(accumulator, class_name, def_node.name, kind)
       end
 
       # `def Foo.bar` inside `module Foo` (or `def Meta.init` inside `module Meta`) is semantically equivalent to `def
@@ -1461,6 +1537,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`.
@@ -1595,16 +1689,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
@@ -1623,10 +1719,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
@@ -1918,7 +2031,7 @@ module Rigor
         class_name = qualified_prefix.join("::")
         new_name = alias_node.new_name.unescaped.to_sym
         kind = in_singleton_class ? :singleton : :instance
-        (accumulator[class_name] ||= {})[new_name] = kind
+        record_method_kind(accumulator, class_name, new_name, kind)
       end
 
       # Post-pass over the `def_nodes` accumulator: for every `alias` declaration inside a class body, if the original
@@ -1981,8 +2094,7 @@ module Rigor
         return if method_name.nil?
 
         class_name = qualified_prefix.join("::")
-        accumulator[class_name] ||= {}
-        accumulator[class_name][method_name] = in_singleton_class ? :singleton : :instance
+        record_method_kind(accumulator, class_name, method_name, in_singleton_class ? :singleton : :instance)
       end
 
       # The `attr_*` accessor macros that introduce methods Rigor must treat as source-declared. Without this, a class
@@ -2005,9 +2117,8 @@ module Rigor
           base = literal_method_name(arg)
           next if base.nil?
 
-          accumulator[class_name] ||= {}
-          accumulator[class_name][base] = kind if reader
-          accumulator[class_name][:"#{base}="] = kind if writer
+          record_method_kind(accumulator, class_name, base, kind) if reader
+          record_method_kind(accumulator, class_name, :"#{base}=", kind) if writer
         end
       end
 
@@ -2352,7 +2463,7 @@ module Rigor
         file_index[:def_nodes].each { |cn, methods| (acc[:def_nodes][cn] ||= {}).merge!(methods) }
         file_index[:singleton_def_nodes].each { |cn, methods| (acc[:singleton_def_nodes][cn] ||= {}).merge!(methods) }
         file_index[:method_visibilities].each { |cn, table| (acc[:method_visibilities][cn] ||= {}).merge!(table) }
-        file_index[:methods].each { |cn, table| (acc[:methods][cn] ||= {}).merge!(table) }
+        file_index[:methods].each { |cn, table| acc[:methods][cn] = merge_method_kinds(acc[:methods][cn] || {}, table) }
         fold_def_sources(acc, :def_sources, file_index[:def_sources])
         fold_def_sources(acc, :singleton_def_sources, file_index[:singleton_def_sources])
       end
@@ -2468,10 +2579,18 @@ module Rigor
 
       # Removes, per class, the method names that have a project `def` node, leaving only
       # accessor/alias/define_method-introduced methods in the cross-file suppression table.
+      #
+      # `def_nodes` is the INSTANCE-side table, so a name recorded on both sides keeps its singleton half: that half
+      # comes from a `def self.x` / `class << self` definition this rule never covered, and dropping it whole would
+      # reintroduce #239's false `call.undefined-method` across files.
       def subtract_def_methods(methods, def_nodes)
         methods.each_with_object({}) do |(class_name, table), out|
           defs = def_nodes[class_name] || {}
-          kept = table.reject { |method_name, _kind| defs.key?(method_name) }
+          kept = table.each_with_object({}) do |(method_name, kind), acc|
+            next acc[method_name] = kind unless defs.key?(method_name)
+
+            acc[method_name] = :singleton if kind == Scope::DiscoveryIndex::METHOD_KIND_BOTH
+          end
           out[class_name] = kept unless kept.empty?
         end
       end
@@ -2483,7 +2602,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
@@ -2491,7 +2610,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|
@@ -2517,7 +2636,7 @@ module Rigor
           (acc[:method_visibilities][class_name] ||= {}).merge!(table)
         end
         file_methods.each do |class_name, table|
-          (acc[:methods][class_name] ||= {}).merge!(table)
+          acc[:methods][class_name] = merge_method_kinds(acc[:methods][class_name] || {}, table)
         end
       end
 
@@ -2570,24 +2689,47 @@ module Rigor
         node.rigor_each_child { |child| collect_class_decls(child, qualified_prefix, accumulator) }
       end
 
-      # T1 (template-corpora survey) — record a `Const = Class.new(Super)` (and the bare `Class.new` / `Module.new`)
-      # class-creating constant in the cross-file discovery table so a reference to `Const` from ANOTHER file under the
-      # same namespace resolves to the project class instead of falling through to a core same-named class
+      # T1 (template-corpora survey) — record a class-creating constant write (`Const = Class.new(Super)`, the bare
+      # `Class.new` / `Module.new`, and the `Data.define(*sym)` / `Struct.new(*sym)` forms, each with or without a
+      # block) in the cross-file discovery table so a reference to `Const` from ANOTHER file under the same namespace
+      # resolves to the project class instead of falling through to a same-named class elsewhere
       # (`Liquid::SyntaxError = Class.new(Error)` referenced in a sibling file's `rescue SyntaxError => e`, which
       # otherwise resolved to core `::SyntaxError`). Mirrors the single-file `in_source_constants` answer, which types
-      # `Class.new(Super)` as `Singleton[Super]` (the constructed class answers method lookups through Super's chain).
-      # The superclass name is resolved lexically against the enclosing prefix; a bare `Class.new` with no superclass
-      # (or `Module.new`) types as `Singleton[Const]` itself. The block form is left to the existing
-      # `meta_new_block_body` machinery — only the plain `Class.new(Super)` constant (the namespaced-sibling-error
-      # idiom) is added here.
+      # `Class.new(Super)` as `Singleton[Super]` (the constructed class answers method lookups through Super's chain)
+      # and every other recognised form as `Singleton[Const]`.
+      #
+      # #271 — the Data/Struct forms are here because their absence was an ACTIVE false positive, not merely a missed
+      # resolution: a nested `Const = Data.define(...)` invisible cross-file lets Ruby's lexical walk continue to the
+      # PARENT namespace's same-named sibling, so `Analysis::PluginFactFingerprint.from_registry(...).opaque?` typed
+      # its receiver as the unrelated `Rigor::Analysis::Result` and reported `call.undefined-method` on correct code.
+      # Nested `Result` / `Entry` / `Config` Data constants shadowing a sibling are ordinary Ruby, and only the
+      # DEFINING file's `in_source_constants` (never part of the project seed) knew about them.
       def record_class_new_constant_decl(node, qualified_prefix, accumulator)
         rvalue = node.value
-        return unless class_new_call?(rvalue) || module_new_call?(rvalue)
-        return if rvalue.block # block form: handled by meta_new_block_body walks
+        return unless meta_new_constant_rvalue?(rvalue)
 
         full = (qualified_prefix + [node.name.to_s]).join("::")
-        super_name = class_new_superclass_name(rvalue, qualified_prefix, accumulator)
-        accumulator[full] = Type::Combinator.singleton_of(super_name || full)
+        accumulator[full] = Type::Combinator.singleton_of(
+          meta_new_constant_decl_name(rvalue, full, qualified_prefix, accumulator)
+        )
+      end
+
+      # The four recognised class-creating rvalue shapes at constant-write position — the same set
+      # {#meta_new_block_body} recognises, so the cross-file table and the per-file block-as-method walk agree on what
+      # counts as a declaration.
+      def meta_new_constant_rvalue?(rvalue)
+        class_new_call?(rvalue) || module_new_call?(rvalue) ||
+          data_define_call?(rvalue) || struct_new_call?(rvalue)
+      end
+
+      # The name the constant's `Singleton[...]` carries. Only a block-less `Class.new(Super)` borrows its superclass's
+      # name (the constructed class answers lookups through `Super`'s chain and declares nothing of its own); every
+      # other form — Data/Struct members, any block body — owns methods under its OWN qualified name, which is exactly
+      # what the per-file `meta_new_constant_type` answers.
+      def meta_new_constant_decl_name(rvalue, full, qualified_prefix, accumulator)
+        return full if rvalue.block || data_define_call?(rvalue) || struct_new_call?(rvalue)
+
+        class_new_superclass_name(rvalue, qualified_prefix, accumulator) || full
       end
 
       # Lexically-qualified name of a `Class.new(Super)` superclass argument, or nil when there is no positional

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
@@ -247,9 +249,25 @@ module Rigor
 
         bound = bound.without_inferred_param_mark(node.name)
         bound = bound.with_local_origin(node.name, rhs_origin(node.value, post_rhs, rhs_type))
+        bound = bound.with_optimistic_local(node.name, optimistic_rhs_origin(node.value, post_rhs))
         [rhs_type, bound]
       end
 
+      # Issue #286 — the optimistic-nil-free counterpart of {#rhs_origin}, differing in two ways. It does not
+      # gate on `Dynamic`: the values this channel marks are ordinary `Union` / `Constant` / `Nominal`
+      # carriers, which is the whole point. And it resolves a bare local read through its binding, so
+      # `w = v` keeps the mark — the same propagation `OriginLookup` performs for the Dynamic channel.
+      def optimistic_rhs_origin(value_node, scope_after_rhs)
+        optimistic_origin_for(value_node, scope_after_rhs)
+      end
+
+      # 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)
+        Inference::OptimisticOrigin.resolve(node, scope)
+      end
+
       # ADR-82 WD1 — the {Inference::DynamicOrigin} cause to propagate onto a local / ivar being bound to `rhs`.
       # Returns the cause recorded on the assignment's rhs node when the value is `Dynamic` (so a later
       # `x` / `@x` receiver-read resolves to why it is dynamic), else `nil` — `with_local_origin` /
@@ -277,6 +295,7 @@ module Rigor
         rhs_type, post_rhs = sub_eval(node.value, scope)
         bound = post_rhs.with_ivar(node.name, rhs_type)
         bound = bound.with_ivar_origin(node.name, rhs_origin(node.value, post_rhs, rhs_type))
+        bound = bound.with_optimistic_ivar(node.name, optimistic_rhs_origin(node.value, post_rhs))
         [rhs_type, bound]
       end
 
@@ -543,19 +562,34 @@ module Rigor
       # non-falsey carriers like `Nominal[Integer]` (Integer is always truthy in Ruby — including 0) also collapse the
       # dead else.
       def live_branch_for_if(node, pred_type, post_pred)
-        case Narrowing.predicate_certainty(pred_type)
+        verdict = optimistic_carrier?(node.predicate, post_pred) ? nil : Narrowing.predicate_certainty(pred_type)
+        case verdict
         when :truthy then eval_branch_or_nil(node.statements, post_pred)
         when :falsey then eval_branch_or_nil(node.subsequent, post_pred)
         end
       end
 
       def live_branch_for_unless(node, pred_type, post_pred)
-        case Narrowing.predicate_certainty(pred_type)
+        verdict = optimistic_carrier?(node.predicate, post_pred) ? nil : Narrowing.predicate_certainty(pred_type)
+        case verdict
         when :truthy then eval_branch_or_nil(node.else_clause, post_pred)
         when :falsey then eval_branch_or_nil(node.statements, post_pred)
         end
       end
 
+      # ADR-101 — the branch elision MUST NOT conclude truthiness from a carrier whose nil-freeness rests on
+      # the `%a{implicitly-returns-nil}` that `RbsDispatch` reads past. Such a value is optimistic, not proof
+      # (see {Inference::OptimisticOrigin} and docs/internal-spec/inference-engine.md), so eliding an arm on
+      # it deletes a branch the program really takes when the lookup misses.
+      #
+      # The decline lives here and NOT in `Narrowing.falsey_nominal?` / `.narrow_falsey`: `&&=` / `||=` and
+      # the and/or surviving-left edge read those too, and widening the falsey fragment there would re-admit
+      # `nil` into a bound local and buy `possible nil receiver` false positives — a soundness fix paid for
+      # in FPs, which is the wrong trade.
+      def optimistic_carrier?(predicate, scope)
+        !optimistic_origin_for(predicate, scope).nil?
+      end
+
       def eval_else(node)
         return [Type::Combinator.constant_of(nil), scope] if node.statements.nil?
 
@@ -1789,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
@@ -2466,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