rigortype 0.4.6 → 0.4.8

data/lib/rigor/inference/method_dispatcher/singleton_folding.rb

@@ -20,7 +20,6 @@ module Rigor
       #
       # Centralising both here keeps the receiver-shape and constant-unwrap knowledge in one place: if
       # `Type::Singleton` or `Type::Constant` ever changes shape, there is a single edit rather than nine.
-      # The per-tier fold bodies stay where they are — only the shared gate moves.
       module SingletonFolding
         module_function
 

data/lib/rigor/inference/method_dispatcher/singleton_mixin_dispatch.rb

@@ -20,8 +20,9 @@ module Rigor
       # The rule is exact rather than heuristic — the receiver must be a `Singleton[C]` whose `C` the project
       # pre-pass recorded as including `Singleton` — so a class that does not include the mixin is untouched,
       # and a project that defines its own `Singleton` module is the one case that would misfire. Guarded by
-      # {project_singleton_shadow?}: a project-declared `Singleton` class or module wins and the tier declines,
-      # because then the name means something else entirely.
+      # {own_singleton_include?}: when the included name resolves to a project-declared class or module (a
+      # top-level `Singleton`, or `M::Singleton` inside `module M`), the tier declines, because then the name
+      # means something else entirely.
       module SingletonMixinDispatch
         MIXIN_NAMES = Ractor.make_shareable(Set["Singleton", "::Singleton"])
         private_constant :MIXIN_NAMES
@@ -31,30 +32,62 @@ module Rigor
 
         module_function
 
-        # @return `Nominal[C]` for `C.instance`, or nil to decline.
+        # @return the instance type of `C` for `C.instance`, or nil to decline.
         def try_dispatch(context)
-          return nil unless context.method_name == SELECTOR
-          return nil unless context.args.empty?
-
           receiver = context.receiver
-          return nil unless receiver.is_a?(Type::Singleton)
-
-          scope = context.scope
-          return nil if scope.nil?
-          return nil unless includes_singleton_mixin?(scope, receiver.class_name)
-          return nil if project_singleton_shadow?(scope)
+          return nil unless answers?(context.scope, receiver, context.method_name, context.args.empty?)
 
           Type::Combinator.nominal_of(receiver.class_name)
         end
 
+        # Issue #2438 — the one predicate behind {try_dispatch} and `CheckRules#undefined_method_diagnostic`, so the
+        # typer and the `call.undefined-method` rule cannot disagree about `C.instance`: a call this tier types is
+        # never reported as undefined, whatever a project sidecar of `C` lists.
+        def answers?(scope, receiver, method_name, no_arguments)
+          return false unless method_name == SELECTOR && no_arguments
+          return false unless receiver.is_a?(Type::Singleton)
+          return false if scope.nil?
+
+          includes_singleton_mixin?(scope, receiver.class_name)
+        end
+
+        # True when `class_name`'s instance ancestry carries the stdlib `Singleton` as an `include` written in the
+        # class itself or in a project class up its superclass chain (Ruby's `Singleton.included` also installs an
+        # `inherited` hook, so `class D < C` answers `instance` with its own instance). Read off
+        # `Scope::ResolutionChain` (the `:constants` flavor, so an empty project `module Singleton` is a project
+        # entry), where the stdlib module is an external entry. Issue #2438 — what is not the mixin:
+        #
+        # - `prepend Singleton`, which runs `prepend_features` instead of the `included` hook and so defines no
+        #   `instance`; a prepended entry sits ahead of its owner on the chain;
+        # - an `include Singleton` in a MODULE the class includes: `Singleton.included` raises `TypeError` for a
+        #   module, so that code never runs;
+        # - a top-level project `Singleton`, which both `Singleton` and `::Singleton` name.
+        #
+        # A NESTED project `N::Singleton` the name resolved to is read as the stdlib mixin: the discovery tables
+        # drop the leading `::` of a mixin argument, so `include ::Singleton` and `include Singleton` inside
+        # `module N` record the same name, and the stdlib reading is the one that types the rooted spelling and
+        # never reports a correct call.
         def includes_singleton_mixin?(scope, class_name)
-          scope.includes_of(class_name).any? { |name| MIXIN_NAMES.include?(name.to_s) }
+          chain = Scope::ResolutionChain.for(scope, class_name.to_s.delete_prefix("::"), :instance, :constants)
+          chain.record(scope)
+          classes = chain.level_classes.compact
+          chain.entries.each_with_index.any? { |entry, index| singleton_include?(chain, classes, entry, index) }
+        end
+
+        def singleton_include?(chain, classes, entry, index)
+          if entry.external?
+            !entry.superclass_edge && MIXIN_NAMES.include?(entry.raw.to_s) && classes.include?(entry.owner) &&
+              index > chain.index_of(entry.owner)
+          else
+            entry.name.end_with?("::Singleton") && included_by_level_class?(chain, index)
+          end
         end
 
-        # True when the project declares its OWN `Singleton` class / module, in which case `include Singleton`
-        # names that one and the stdlib rule does not apply.
-        def project_singleton_shadow?(scope)
-          MIXIN_NAMES.any? { |name| scope.discovery.discovered_classes.key?(name.to_s.delete_prefix("::")) }
+        # The entry sits after its level's class, so it was included into that level rather than prepended.
+        def included_by_level_class?(chain, index)
+          level = chain.level_starts.rindex { |start| start <= index }
+          klass = level && chain.level_classes[level]
+          !klass.nil? && index > chain.index_of(klass)
         end
       end
     end

data/lib/rigor/inference/method_dispatcher/singleton_type_params.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+require "rbs"
+
+module Rigor
+  module Inference
+    module MethodDispatcher
+      # Issue #2828 — how overload selection reads a parameter spelled `singleton(T)` over a method-level type
+      # variable `T`. RBS parses it as a class singleton whose name is the bare, relative `T`, and the
+      # translator reads that as a class named `T`: an unloadable class whose singleton refuses every class object
+      # the analyzer process has loaded (`Acceptance` rules a loaded class out of an unloadable target's
+      # subtypes). With `Resolv` loaded, `Resolv::DNS#getresources: [T < Resource] (dns_name, singleton(T)) ->
+      # Array[T] | ...` then lost to the base overload.
+      #
+      # Selection instead reads the parameter as "a class object" the variable admits: `singleton(X)` for a
+      # class upper bound `X`, and `Module` otherwise, which takes any class or module object and refuses an
+      # instance. Only names the overload declares in its own `type_params` are read this way; any other
+      # unresolved `singleton(X)` keeps the translator's reading.
+      #
+      # {.selecting} hands the selector the overloads rewritten where a parameter needs it and maps the selected
+      # rewrites back, so the return translation and the argument binding (`RbsDispatch#singleton_param_binding`)
+      # still read the declared `singleton(T)`.
+      module SingletonTypeParams
+        module_function
+
+        # Yields the overloads to select among and answers the block's selection, with each rewrite mapped back to
+        # its declaration. Nearly every method needs no rewrite, and then `declared` is yielded as is.
+        def selecting(declared)
+          return yield(declared) unless declared.any? { |method_type| rewrites?(method_type) }
+
+          originals = {}.compare_by_identity
+          rewritten = declared.map do |method_type|
+            next method_type unless rewrites?(method_type)
+
+            rewrite = rewrite(method_type)
+            originals[rewrite] = method_type
+            rewrite
+          end
+          yield(rewritten).map { |method_type| originals.fetch(method_type, method_type) }
+        end
+
+        def rewrites?(method_type)
+          params = method_type.respond_to?(:type_params) ? method_type.type_params : nil
+          return false if params.nil? || params.empty?
+
+          fun = method_type.type
+          return false unless fun.respond_to?(:required_positionals)
+
+          any_variable_singleton?(fun.required_positionals, params) ||
+            any_variable_singleton?(fun.optional_positionals, params) ||
+            any_variable_singleton?(fun.trailing_positionals, params)
+        end
+
+        def any_variable_singleton?(list, type_params)
+          list.any? { |param| variable_singleton?(param.type, type_params) }
+        end
+
+        def variable_singleton?(type, type_params)
+          return false unless type.is_a?(RBS::Types::ClassSingleton)
+
+          name = type.name
+          return false if name.absolute? || !name.namespace.empty?
+
+          type_params.any? { |type_param| type_param.name == name.name }
+        end
+
+        # One parameter of `method_type` as selection reads it: `call.argument-type-mismatch` checks a call the
+        # same way, and otherwise declines every overload with a `singleton(T)` parameter as naming a class nothing
+        # defines.
+        def selection_param(param, method_type)
+          type_params = method_type.type_params
+          return param unless variable_singleton?(param.type, type_params)
+
+          param.map_type { |type| class_object_type(type.name.name, type_params) }
+        end
+
+        def rewrite(method_type)
+          type_params = method_type.type_params
+          fun = method_type.type.map_type do |type|
+            variable_singleton?(type, type_params) ? class_object_type(type.name.name, type_params) : type
+          end
+          RBS::MethodType.new(type_params: type_params, type: fun, block: method_type.block,
+                              location: method_type.location)
+        end
+
+        # Built per rewrite rather than held in a constant: an RBS type is not `Ractor.shareable?` (#1064), and a
+        # rewrite happens only for the few overloads that spell `singleton(T)`.
+        def module_type
+          RBS::Types::ClassInstance.new(
+            name: RBS::TypeName.new(name: :Module, namespace: RBS::Namespace.root), args: [], location: nil
+          )
+        end
+
+        def class_object_type(name, type_params)
+          type_param = type_params.find { |tp| tp.name == name }
+          bound = type_param.upper_bound
+          return module_type unless bound.is_a?(RBS::Types::ClassInstance)
+
+          RBS::Types::ClassSingleton.new(name: bound.name, location: nil)
+        end
+      end
+    end
+  end
+end

data/lib/rigor/inference/method_dispatcher/struct_folding.rb

@@ -14,8 +14,8 @@ module Rigor
       #
       # A `Struct` instance is mutable (`s.x = v`, `s[:x] = v`, escape), so a member map bound to a
       # variable can be invalidated by a later write. A member read folds off a **fresh** instance (the
-      # transient receiver of a `.new(...).x` / `.with(...).x` chain, unmutatable between materialisation
-      # and the read — slices 1+2), off a **fold-safe stored local** the {Inference::StructFoldSafety} scan
+      # transient receiver of a `.new(...).x` chain, unmutatable between materialisation and the read —
+      # slices 1+2), off a **fold-safe stored local** the {Inference::StructFoldSafety} scan
       # proved is never mutated / aliased / escaped (slice 3), or off a **setter-mutated fold-safe local**
       # whose bindings {#apply_setter_writeback} keeps current (slice 4). Any other stored receiver degrades
       # to `Dynamic[top]` rather than fold a possibly-stale value.
@@ -255,8 +255,8 @@ module Rigor
         end
 
         # A member read is foldable when the receiver is either FRESH (the transient result of a
-        # `.new(...)`/`.with(...)` chain, which cannot have been mutated between materialisation and this
-        # read) or a FOLD-SAFE stored local (ADR-48 slice 3 — `StructFoldSafety` proved the binding is
+        # `.new(...)` chain, which cannot have been mutated between materialisation and this read) or a
+        # FOLD-SAFE stored local (ADR-48 slice 3 — `StructFoldSafety` proved the binding is
         # never mutated / aliased / escaped in its scope).
         def foldable_receiver?(context)
           fresh_receiver?(context) || fold_safe_local_receiver?(context) ||
@@ -308,7 +308,7 @@ module Rigor
         end
 
         # A fresh receiver is the result of a chained call that MATERIALISED the struct — `Point.new(1, 2).x`,
-        # `Point[1, 2].x`, `inst.with(x: 9).y`. Not merely a chained call: slices 1-2 read "chained" as
+        # `Point[1, 2].x`. Not merely a chained call: slices 1-2 read "chained" as
         # "cannot have been mutated between materialisation and the read", and a method that hands back its
         # own receiver falsifies that (issue #595):
         #

data/lib/rigor/inference/method_dispatcher/struct_materialization.rb

@@ -31,12 +31,10 @@ module Rigor
         # nodes; the bound exists so a pathological body cannot turn a per-call-site gate into a walk.
         FACTORY_BODY_SCAN_BUDGET = 200
 
-        # Issue #595 / #525 — the ONE materialisation test. Both places that must answer "was this receiver
-        # expression's struct newly built?" go through it: this module's direct member-read gate above, and
-        # `ExpressionTyper`'s caller-side `:self`-grant arm. They had forked answers once (the grant arm was
-        # tightened for #591 while this one still trusted any chained call), so both consumers must share this
-        # one answer. A `.with` call is never a materialisation: the composed `x.dup_self.with(indent: 9)`
-        # shape once slipped through as one, and `Struct#with` no longer exists to fold (#1335).
+        # Issue #595 / #525 — the ONE materialisation test, shared by {StructFolding#fresh_receiver?} and
+        # `ExpressionTyper`'s `:self`-grant arm so the two gates cannot fork. A `.with` call is never a
+        # materialisation: the composed `x.dup_self.with(indent: 9)` shape once slipped through as one, and
+        # `Struct#with` no longer exists (#1335).
         #
         # @param node — the receiver EXPRESSION.
         # @param scope — the scope the factory and ancestor lookups resolve against.

data/lib/rigor/inference/method_dispatcher/uri_folding.rb

@@ -55,7 +55,7 @@ module Rigor
 
         # A form long enough to suggest generated or accumulated data rather than a literal a reader wrote;
         # past it the folded `Constant[String]` stops being useful in a diagnostic and only costs memory.
-        # Mirrors the byte ceiling `ShapeDispatch`'s own `tuple_join` fold applies for the same reason.
+        # Counts pairs where `ShapeDispatch`'s `tuple_join` fold caps bytes, for the same reason.
         FORM_PAIR_LIMIT = 64
         private_constant :FORM_PAIR_LIMIT
 

data/lib/rigor/inference/method_dispatcher.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "../reflection"
+require_relative "../typing_state"
 require_relative "../type"
 require_relative "../flow_contribution"
 require_relative "../flow_contribution/merger"
@@ -18,6 +19,7 @@ require_relative "method_dispatcher/shape_dispatch"
 require_relative "method_dispatcher/data_folding"
 require_relative "method_dispatcher/struct_folding"
 require_relative "method_dispatcher/rbs_dispatch"
+require_relative "method_dispatcher/declared_constructor"
 require_relative "method_dispatcher/iterator_dispatch"
 require_relative "method_dispatcher/arithmetic_sequence_elements"
 require_relative "method_dispatcher/reduce_folding"
@@ -41,6 +43,7 @@ require_relative "method_dispatcher/universal_object_dispatch"
 require_relative "method_dispatcher/singleton_mixin_dispatch"
 require_relative "method_dispatcher/method_folding"
 require_relative "method_dispatcher/optional_count"
+require_relative "../run_scoped_slots"
 
 module Rigor
   module Inference
@@ -194,7 +197,7 @@ module Rigor
         rbs_result = RbsDispatch.try_dispatch(context)
         if rbs_result
           record_boundary_cross_if_applicable(receiver_type, method_name, rbs_result, environment)
-          if rbs_result.is_a?(Type::Dynamic) && rbs_result.static_facet.is_a?(Type::Top)
+          if Type::Combinator.untyped?(rbs_result)
             scope&.record_dynamic_origin(call_node, DynamicOrigin::EXPLICIT_UNTYPED)
           end
           return rbs_result
@@ -204,8 +207,8 @@ module Rigor
         # user-authored RBS overrides substrate synthesis) and ABOVE the dependency-source
         # inference tier so a plugin's declared emit table beats the generic gem-source fallback
         # for the same class. Slice 6a-TierB (origin_module dispatch) lands precise return types
-        # for Tier B emissions; Tier C emissions still return `Dynamic[T]` at this tier (slice 6b
-        # is the Tier C promotion via ADR-13's resolver chain).
+        # for Tier B emissions; Tier C emissions return their manifest `return_type` when the environment
+        # names that class (slice 6b), and `Dynamic[T]` otherwise.
         synthetic_result = try_synthetic_method(
           receiver_type, method_name, arg_types, block_type, environment
         )
@@ -825,7 +828,7 @@ module Rigor
       end
 
       def rbs_result_untyped?(rbs_result)
-        rbs_result.is_a?(Type::Dynamic) && rbs_result.static_facet.is_a?(Type::Top)
+        Type::Combinator.untyped?(rbs_result)
       end
 
       def rbs_display_for(rbs_result)
@@ -915,8 +918,7 @@ module Rigor
         result || EMPTY_CONTRIBUTIONS
       end
 
-      # Runs the precision tiers (constant fold, shape dispatch, file-path fold, block fold) in
-      # order and returns the first non-nil answer. Each tier owns its own receiver/argument
+      # Runs the precision tiers in order and returns the first non-nil answer. Each tier owns its own receiver/argument
       # shape checks; a tier that does not recognise the receiver returns nil so the next tier
       # can try. The RBS tier sits below this chain and is invoked by the outer `dispatch`
       # method.
@@ -925,7 +927,7 @@ module Rigor
       # (`try_dispatch(CallContext) -> Type?`). Order is significant: ConstantFolding's
       # exact-value folds win first, the stdlib singleton folders sit in the middle (each
       # gates on a distinct `Singleton` receiver, so their relative order is immaterial), and
-      # BlockFolding runs last because its rules only apply to block-taking calls — the cheaper
+      # BlockFolding runs near the end because its rules only apply to block-taking calls — the cheaper
       # arity folds above it filter the common cases first. Adding a precise tier is a one-line
       # append here rather than another link in a hand-written `||` ladder.
       PRECISE_TIERS_HEAD = Ractor.make_shareable([
@@ -1031,6 +1033,7 @@ module Rigor
         fallback_receiver = user_class_fallback_receiver(receiver_type, environment)
         return nil if fallback_receiver.nil?
         return nil if declared_by_external_ancestor?(receiver_type, environment, context)
+        return nil if project_singleton_definer?(receiver_type, context)
 
         # Preserve the ORIGINAL receiver type as the `self` substitution so `Kernel#dup: () ->
         # self` and other `self`-returning methods route through Object's RBS while still
@@ -1069,27 +1072,114 @@ module Rigor
         scope = context.scope
         return false if scope.nil?
 
+        class_name = receiver_type.class_name
+        method_name = context.method_name
+        if MemoAudit.enabled? && MemoAudit.suspended?
+          return external_ancestor_declares?(class_name, method_name, scope,
+                                             environment)
+        end
+
         memo = external_ancestor_memo(scope, environment)
-        key = [receiver_type.class_name, context.method_name]
-        return memo[key] if memo.key?(key)
+        key = [class_name, method_name]
+        if memo.key?(key)
+          return MemoAudit.check("user class fallback external ancestor", memo[key], class_name, method_name) do
+            external_ancestor_declares?(class_name, method_name, scope, environment)
+          end
+        end
+
+        memo[key] = MemoAudit.key_audit("user class fallback external ancestor") do
+          external_ancestor_declares?(class_name, method_name, scope, environment)
+        end
+      end
+
+      def external_ancestor_declares?(class_name, method_name, scope, environment)
+        !ExternalAncestorResolution.resolve(class_name, method_name, :instance,
+                                            scope: scope, environment: environment, record_dependencies: false).nil?
+      end
+
+      # Issue #2284 — a class object whose singleton chain holds a project definer of the name (its own `def
+      # self.name`, one a project superclass wrote, an `extend`ed module's `def name`) answers from that definer,
+      # not from `Module#name` / `Class#…` on the `Singleton[Object]` fallback: Ruby's singleton ancestry puts
+      # every project entry ahead of `Class`. The fallback declines so the typer's singleton-body inference
+      # answers the definer's return, or `Dynamic` where the slot is contested and the def may not be the one
+      # that runs.
+      #
+      # The chain walk files the class edge of every entry it passes, so it runs only for a name some project file
+      # defines at all ({BlockCallTiming.project_defines_anywhere?}, which files the `defines:<name>` edge either way,
+      # #1459). Without it every class-body `private` / `attr_reader` call on a project class would depend on its
+      # whole ancestry. The by-name answer is memoised per discovery index; the edge is filed on every call.
+      def project_singleton_definer?(receiver_type, context)
+        return false unless receiver_type.is_a?(Type::Singleton)
+
+        scope = context.scope
+        return false if scope.nil?
+        return false unless project_defines_name?(scope, context.method_name)
+
+        !scope.singleton_def_through_ancestors(receiver_type.class_name, context.method_name).last.nil?
+      end
 
-        memo[key] = !ExternalAncestorResolution.resolve(receiver_type.class_name, context.method_name, :instance,
-                                                        scope: scope, environment: environment,
-                                                        record_dependencies: false).nil?
+      def project_defines_name?(scope, method_name)
+        if MemoAudit.enabled? && MemoAudit.suspended?
+          return BlockCallTiming.project_defines_anywhere?(method_name,
+                                                           scope)
+        end
+
+        memo = defines_name_memo(scope)
+        if memo.key?(method_name)
+          Analysis::DependencyRecorder.read_missing(:defines, method_name) if Analysis::DependencyRecorder.active?
+          return MemoAudit.check("user class fallback defines name", memo[method_name], method_name) do
+            BlockCallTiming.project_defines_anywhere?(method_name, scope)
+          end
+        end
+
+        memo[method_name] = MemoAudit.key_audit("user class fallback defines name") do
+          BlockCallTiming.project_defines_anywhere?(method_name, scope)
+        end
+      end
+
+      # ADR-129 WD1 — a run-scoped Memo: one slot keyed on the identity of the discovery index and the environment,
+      # the only inputs the name table's answers read.
+      DEFINES_NAME_MEMO = TypingState.memo(
+        :user_class_fallback_defines_name,
+        run_scoped: true, audit: "user class fallback defines name",
+        reason: "one [discovery, environment, names] slot keyed on the identities of the discovery " \
+                "index and the environment; each name's answer reads only them"
+      )
+      private_constant :DEFINES_NAME_MEMO
+
+      # One slot per discovery index and environment, as {#external_ancestor_memo} keeps its own: the answer reads
+      # only the frozen discovery tables and the environment's `pre_eval:` patches.
+      def defines_name_memo(scope)
+        discovery = scope.discovery
+        environment = scope.environment
+        state = TypingState.current
+        slot = state[DEFINES_NAME_MEMO]
+        unless slot && slot[0].equal?(discovery) && slot[1].equal?(environment)
+          slot = [discovery, environment, {}]
+          state[DEFINES_NAME_MEMO] = slot
+        end
+        slot[2]
       end
 
-      EXTERNAL_ANCESTOR_MEMO_KEY = :__rigor_user_class_fallback_external_ancestor__
-      private_constant :EXTERNAL_ANCESTOR_MEMO_KEY
+      # ADR-129 WD1 — a run-scoped Memo, keyed as {DEFINES_NAME_MEMO} is.
+      EXTERNAL_ANCESTOR_MEMO = TypingState.memo(
+        :user_class_fallback_external_ancestor,
+        run_scoped: true, audit: "user class fallback external ancestor",
+        reason: "one [discovery, environment, answers] slot keyed on the identities of the " \
+                "discovery index and the RBS environment, the only inputs the walk reads"
+      )
+      private_constant :EXTERNAL_ANCESTOR_MEMO
 
       # One slot per discovery index and environment, as `RbsDispatch#ancestor_memo_slot` keeps its own: the answer
       # reads only the frozen discovery tables and the RBS environment, and its walk is withheld from dependency
       # recording, so it may be served again for the same pair.
       def external_ancestor_memo(scope, environment)
         discovery = scope.discovery
-        slot = Thread.current[EXTERNAL_ANCESTOR_MEMO_KEY]
+        state = TypingState.current
+        slot = state[EXTERNAL_ANCESTOR_MEMO]
         unless slot && slot[0].equal?(discovery) && slot[1].equal?(environment)
           slot = [discovery, environment, {}]
-          Thread.current[EXTERNAL_ANCESTOR_MEMO_KEY] = slot
+          state[EXTERNAL_ANCESTOR_MEMO] = slot
         end
         slot[2]
       end
@@ -1138,12 +1228,14 @@ module Rigor
       #
       # `RbsDispatch` already distributes over a `Union` (and erases a `Difference` to its base, #533),
       # but it does so INSIDE one tier, so a member that needs a LOWER tier — a user class with no RBS,
-      # a discovered `def`, an opt-in gem — makes the whole union decline. That is the corpus shape:
-      # rigor-actionpack types `params[:k]` as `ActionController::Parameters | nil`, the `Parameters` arm
-      # resolves only through the user-class fallback, and so `params[:k].present?` / `#==` / `#blank?` /
-      # `#to_s` read opaque on every Rails app. Measured by toggling this file alone: the named-pair
-      # census drains 137 sites on redmine and 56 on mastodon, and `rigor check` reports the same
-      # diagnostics on both arms across eight survey targets.
+      # a discovered `def`, an opt-in gem — makes the whole union decline. That was the corpus shape before
+      # #2430: rigor-actionpack typed `params[:k]` as the bare `ActionController::Parameters | nil` union, the
+      # `Parameters` arm resolved only through the user-class fallback, and so `params[:k].present?` / `#==`
+      # / `#blank?` / `#to_s` read opaque on every Rails app. Measured by toggling this file alone: the
+      # named-pair census drained 137 sites on redmine and 56 on mastodon, and `rigor check` reported the
+      # same diagnostics on both arms across eight survey targets. The plugin now answers a `Dynamic`
+      # carrier, which this projection does not reach, so those off-chain calls read `Dynamic[top]` until
+      # the carrier is projected here too (#2448).
       #
       # **Why the bottom and not next to `RbsDispatch`.** Sitting here, the tier can only ever replace a
       # `Dynamic[top]` the typer was about to produce — the same ADR-5 argument {UniversalObjectDispatch}
@@ -1314,7 +1406,13 @@ module Rigor
         class_new_lift = class_new_lift(receiver_type.class_name, arg_types, context)
         return class_new_lift if class_new_lift
 
-        Type::Combinator.nominal_of(receiver_type.class_name)
+        declared_or_nominal(receiver_type.class_name, context)
+      end
+
+      # Issue #2884 — the `meta_new` tail: a declared `def self.new` ({DeclaredConstructor}), else `Nominal[X]`.
+      def declared_or_nominal(class_name, context)
+        declared = context && DeclaredConstructor.try_dispatch(class_name, context)
+        declared || Type::Combinator.nominal_of(class_name)
       end
 
       # `Struct.new(:a, :b)` synthesises an anonymous Struct *subclass* (a class object), not a
@@ -1346,8 +1444,8 @@ module Rigor
       # class is representable as the parent's singleton type — its singleton-method surface is
       # the parent's (plus whatever the block defines, which we do not statically track here),
       # so `Singleton[Parent]` lets downstream `klass.some_class_method` resolve. No parent →
-      # `singleton(Object)`. Anything else (dynamic parent, more than one positional, …) falls
-      # back to `Nominal[Class]` via the surrounding `meta_new` tail.
+      # `singleton(Object)` (or the block's anonymous class, #319 below). Anything else (dynamic parent, more
+      # than one positional, …) falls back to `Nominal[Class]` via the surrounding `meta_new` tail.
       # #319 — a `Class.new do ... end` with no parent is NOT `Object`: the block body is a class body, so the
       # class owns whatever that body defines. Answering `Singleton[Object]` handed the call site `Object`'s
       # zero-arity `new` and `Object`'s method surface, so an `initialize(bucket)` written right there produced