rigortype 0.2.5 → 0.2.7

data/lib/rigor/sig_gen/generator.rb

@@ -63,6 +63,7 @@ module Rigor
         @namespace_kinds = {}
         @module_function_methods = Set.new
         @class_shells = Set.new
+        @class_superclasses = {}
       end
 
       # Lifts legacy plain-`Array[Type]` observation entries
@@ -116,6 +117,7 @@ module Rigor
         @namespace_kinds = {}
         @module_function_methods = Set.new
         @class_shells = Set.new
+        @class_superclasses = {}
         defs = collect_method_definitions(parse_result.value)
         candidates_from_defs = defs.filter_map do |def_node, class_name, kind|
           # An analyzer bug typing one def's body must cost only that
@@ -195,10 +197,32 @@ module Rigor
 
         full = (prefix + [name]).join("::")
         @namespace_kinds[full] = node.is_a?(Prism::ClassNode) ? :class : :module
+        record_superclass(node, full)
         walk_namespace_body(node, prefix + [name], out)
         true
       end
 
+      # ADR-14: a generated subclass declaration MUST carry its
+      # superclass, or the sidecar `sig/` misrepresents the class
+      # (inherited members vanish → receiver dispatch degrades to
+      # `Dynamic`) and, worse, a nested reference to an inherited
+      # type re-declares the class as a bare namespace on the RBS
+      # side and can collapse the whole env (the 2026-07-04 redmine
+      # `GitAdapter < AbstractAdapter` crash). Only a plain constant
+      # superclass is emittable: `class X < Foo` / `class X <
+      # Foo::Bar` yields the source token verbatim (RBS resolves it
+      # relative to the emitted namespace, matching Ruby's lexical
+      # scope). A computed superclass (`Struct.new`, `Data.define`,
+      # `Class.new`, any `CallNode`) is left unrecorded — those flow
+      # through the {#register_data_struct_shell} shell path or are
+      # simply un-representable, and guessing would misfold.
+      def record_superclass(node, full)
+        return unless node.is_a?(Prism::ClassNode)
+
+        superclass = qualified_constant_path(node.superclass)
+        @class_superclasses[full] = superclass if superclass
+      end
+
       # ADR-14 gap-#3 (e): recognises
       # `Const = Data.define(...)` and
       # `Const = Struct.new(...)` as class declarations.
@@ -292,6 +316,7 @@ module Rigor
         MethodCandidate.new(
           namespace_kinds: @namespace_kinds,
           class_shells: @class_shells.to_a,
+          class_superclasses: @class_superclasses,
           **
         )
       end

data/lib/rigor/sig_gen/method_candidate.rb

@@ -25,11 +25,11 @@ module Rigor
     class MethodCandidate
       attr_reader :path, :class_name, :method_name, :kind, :classification,
                   :inferred_return, :declared_return_rbs, :rbs, :skip_reason,
-                  :namespace_kinds, :class_shells
+                  :namespace_kinds, :class_shells, :class_superclasses
 
       def initialize(path:, class_name:, method_name:, kind:, classification:, # rubocop:disable Metrics/ParameterLists
                      inferred_return: nil, declared_return_rbs: nil, rbs: nil, skip_reason: nil,
-                     namespace_kinds: {}, class_shells: [])
+                     namespace_kinds: {}, class_shells: [], class_superclasses: {})
         @path = path
         @class_name = class_name
         @method_name = method_name
@@ -41,6 +41,11 @@ module Rigor
         @skip_reason = skip_reason
         @namespace_kinds = namespace_kinds.freeze
         @class_shells = class_shells.freeze
+        # Qualified-class-name => superclass source token (e.g.
+        # `{ "Foo::Bar" => "Base" }`). Only plain-constant
+        # superclasses appear; computed ones are absent. The Writer
+        # emits `class Bar < Base` for the leaf when present.
+        @class_superclasses = class_superclasses.freeze
         freeze
       end
 

data/lib/rigor/sig_gen/writer.rb

@@ -51,6 +51,9 @@ module Rigor
         # Empty until then so the single-target `#write` path
         # falls back to per-candidate kinds only.
         @global_namespace_kinds = {}
+        # Run-level qualified-class-name => superclass-token view,
+        # same lifecycle as `@global_namespace_kinds`.
+        @global_superclasses = {}
       end
 
       # Process the full candidate list by resolving each
@@ -71,6 +74,7 @@ module Rigor
         return [] if emittable.empty?
 
         @global_namespace_kinds = build_namespace_kinds(candidates)
+        @global_superclasses = build_superclasses(candidates)
         emittable.group_by { |c| @path_mapper.target_for(c.path, class_name: c.class_name) }
                  .map { |target, group| write_target(target, group) }
       end
@@ -154,7 +158,8 @@ module Rigor
         shells = collect_class_shells(candidates)
         tree = build_namespace_tree(candidates, shells)
         kinds = merged_namespace_kinds(candidates)
-        render_tree_nodes(tree, kinds, 0)
+        supers = merged_superclasses(candidates)
+        render_tree_nodes(tree, kinds, supers, 0)
       end
 
       # Drains `class_shells` from every candidate; the
@@ -191,6 +196,30 @@ module Rigor
         end
       end
 
+      # Superclass twins of {#merged_namespace_kinds} /
+      # {#build_namespace_kinds}: fold every candidate's
+      # per-file `class_superclasses` map into one view keyed by
+      # qualified class name. Only plain-constant superclasses are
+      # ever recorded (the generator skips computed ones), so a
+      # missing key means "emit no superclass", never "unknown".
+      def merged_superclasses(candidates)
+        merged = @global_superclasses.dup
+        candidates.each do |c|
+          next unless c.respond_to?(:class_superclasses)
+
+          (c.class_superclasses || {}).each { |name, sup| merged[name] = sup }
+        end
+        merged
+      end
+
+      def build_superclasses(candidates)
+        candidates.each_with_object({}) do |candidate, acc|
+          next unless candidate.respond_to?(:class_superclasses)
+
+          (candidate.class_superclasses || {}).each { |name, sup| acc[name] = sup }
+        end
+      end
+
       # A `class` declaration is authoritative and MUST win
       # over the `:module` wrapper default: a compact
       # `class Foo::Bar` never names `Foo`, so the only signal
@@ -234,27 +263,43 @@ module Rigor
         end
       end
 
-      def render_tree_nodes(node, kinds, depth)
-        node[:children].values.map { |child| render_tree_node(child, kinds, depth, [node[:name]].compact) }.join("\n")
+      def render_tree_nodes(node, kinds, supers, depth)
+        node[:children].values.map do |child|
+          render_tree_node(child, kinds, supers, depth, [node[:name]].compact)
+        end.join("\n")
       end
 
-      def render_tree_node(node, kinds, depth, prefix)
+      def render_tree_node(node, kinds, supers, depth, prefix)
         indent = INDENT * depth
         qualified = (prefix + [node[:name]]).join("::")
         keyword = node_keyword(node, kinds, qualified)
-        body = render_tree_node_body(node, kinds, depth, prefix)
-        "#{indent}#{keyword} #{node[:name]}\n#{body}#{indent}end\n"
+        header = "#{keyword} #{node[:name]}#{superclass_suffix(keyword, supers, qualified)}"
+        body = render_tree_node_body(node, kinds, supers, depth, prefix)
+        "#{indent}#{header}\n#{body}#{indent}end\n"
       end
 
-      def render_tree_node_body(node, kinds, depth, prefix)
+      def render_tree_node_body(node, kinds, supers, depth, prefix)
         inner_indent = INDENT * (depth + 1)
         method_lines = node[:methods].map { |c| "#{inner_indent}#{c.rbs}\n" }.join
         child_blocks = node[:children].values.map do |child|
-          render_tree_node(child, kinds, depth + 1, prefix + [node[:name]])
+          render_tree_node(child, kinds, supers, depth + 1, prefix + [node[:name]])
         end.join
         method_lines + child_blocks
       end
 
+      # ` < Super` for a `class` node whose qualified name has a
+      # recorded superclass, else the empty string. A `module`
+      # never takes a superclass (RBS forbids it), so the keyword
+      # gates emission — a name coincidentally recorded as both
+      # (impossible from one source class, but cheap to guard)
+      # stays a bare module.
+      def superclass_suffix(keyword, supers, qualified)
+        return "" unless keyword == :class
+
+        superclass = supers[qualified]
+        superclass ? " < #{superclass}" : ""
+      end
+
       # Per ADR-14 gap-#3 (a) the keyword for a segment comes
       # from `namespace_kinds` when known. The default for an
       # explicit class shell (gap-#3 (e), `Const =
@@ -277,7 +322,8 @@ module Rigor
         return WriteResult.new(source_path: source_path, target_path: target, action: :noop) if decls.nil?
 
         state = MergeState.new(source: source, decls: decls, applied: [], skipped: [])
-        candidates.group_by(&:class_name).each { |class_name, methods| merge_class(state, class_name, methods) }
+        supers = merged_superclasses(candidates)
+        candidates.group_by(&:class_name).each { |class_name, methods| merge_class(state, class_name, methods, supers) }
         merge_class_shells(state, collect_class_shells(candidates), merged_namespace_kinds(candidates))
 
         action = state.applied.empty? ? :noop : :updated
@@ -367,10 +413,10 @@ module Rigor
         nil
       end
 
-      def merge_class(state, class_name, methods)
+      def merge_class(state, class_name, methods, supers = {})
         decl = find_class_decl(state.decls, class_name)
         state.source = if decl.nil?
-                         append_new_class(state.source, class_name, methods, state.applied)
+                         append_new_class(state.source, class_name, methods, state.applied, supers[class_name])
                        else
                          merge_into_existing_class(state.source, decl, methods, state.applied, state.skipped)
                        end
@@ -405,9 +451,10 @@ module Rigor
       # Appends an entirely new `class Foo … end` block at the
       # end of the file (with a leading blank line as
       # separator).
-      def append_new_class(source, class_name, methods, applied)
+      def append_new_class(source, class_name, methods, applied, superclass = nil)
         body = methods.map { |c| "#{INDENT}#{c.rbs}" }.join("\n")
-        snippet = "\nclass #{class_name}\n#{body}\nend\n"
+        header = superclass ? "class #{class_name} < #{superclass}" : "class #{class_name}"
+        snippet = "\n#{header}\n#{body}\nend\n"
         applied.concat(methods)
         ends_with_newline?(source) ? source + snippet : "#{source}\n#{snippet}"
       end

data/lib/rigor/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Rigor
-  VERSION = "0.2.5"
+  VERSION = "0.2.7"
 end

data/lib/rigor.rb

@@ -10,6 +10,7 @@ require_relative "rigor/environment"
 require_relative "rigor/rbs_extended"
 require_relative "rigor/testing"
 require_relative "rigor/inference/budget_trace"
+require_relative "rigor/inference/dynamic_origin"
 require_relative "rigor/inference/fallback"
 require_relative "rigor/inference/fallback_tracer"
 require_relative "rigor/inference/acceptance"

data/plugins/rigor-actionpack/lib/rigor/plugin/actionpack.rb

@@ -76,8 +76,8 @@ module Rigor
         # resolves as `Admin::DomainBlocksController` (matching the
         # `ControllerDiscoverer`), so render paths and filter-chain
         # validation on nested controllers are correct.
-        version: "0.8.0",
-        description: "Validates Action Pack route-helper calls and filter chains inside controllers.",
+        version: "0.9.0",
+        description: "Validates Action Pack route-helper calls and filter chains inside controllers, and types the request-context readers (`params` / `session` / `request`).",
         config_schema: {
           "controller_search_paths" => { kind: :array, default: ["app/controllers"] },
           "view_search_paths" => { kind: :array, default: ["app/views"] }
@@ -173,8 +173,69 @@ module Rigor
         diagnostics_for(Analyzer.permit_violations_for(call_node: node, model_index: index), path: path, node: node)
       end
 
+      # Phase 5 (2026-07-04) — type the implicit-self request-context
+      # readers (`params`, `session`, `request`, `flash`, `cookies`)
+      # inside controllers. The
+      # typing-obstacle probe
+      # (docs/notes/20260704-rails-coverage-onboarding-carrier-trap.md,
+      # obstacle O3) found `params` typing to `Dynamic[top]` the single
+      # largest protection-coverage hole on real Rails apps: `params[:x]`
+      # is the #1 dispatch cluster (redmine app+lib: `[]` 2378 sites) and
+      # `session[:x] =` a large share of the `[]=` cluster, all
+      # unprotected because the receiver is Dynamic.
+      #
+      # Each returns a bare nominal with NO bundled RBS on purpose. That
+      # makes the reader a *concrete* receiver (so `coverage --protection`
+      # counts the site as protected and the dispatch resolves against a
+      # named class) while its method surface stays engine-lenient — Rigor
+      # does not fire `undefined-method` on a class it has no RBS for, so
+      # `params.require(...).permit(...)`, `session.delete(:x)`,
+      # `request.xhr?`, and every other method on these stay FP-safe.
+      # Shipping a partial RBS would re-introduce the carrier-additivity
+      # trap (a declared class drops every member the RBS omits → false
+      # `undefined-method`). ADR-5: this types the container, never the
+      # caller's argument, so the values stay lenient.
+      REQUEST_CONTEXT_READER_TYPES = {
+        params: "ActionController::Parameters",
+        session: "ActionDispatch::Request::Session",
+        request: "ActionDispatch::Request",
+        flash: "ActionDispatch::Flash::FlashHash",
+        cookies: "ActionDispatch::Cookies::CookieJar"
+      }.freeze
+
+      dynamic_return methods: REQUEST_CONTEXT_READER_TYPES.keys do |call_node, scope|
+        next nil unless call_node.is_a?(Prism::CallNode)
+        next nil unless call_node.receiver.nil?   # the implicit-self reader
+        next nil unless call_node.arguments.nil?  # `params`, not `params(x)`
+        next nil unless controller_scope?(scope)
+
+        class_name = REQUEST_CONTEXT_READER_TYPES[call_node.name]
+        next nil if class_name.nil?
+
+        Rigor::Type::Combinator.nominal_of(class_name)
+      end
+
       private
 
+      # True when the current `self` is a controller — the enclosing
+      # class is one the discoverer indexed, or its name follows the
+      # Rails `*Controller` convention (covering controllers outside
+      # `controller_search_paths`, e.g. one shipped by an engine).
+      # Typing `params` is precision-additive, so the name-convention
+      # fallback is FP-safe.
+      def controller_scope?(scope)
+        self_type = scope&.self_type
+        return false unless self_type.respond_to?(:class_name)
+
+        name = self_type.class_name
+        return false if name.nil?
+
+        index = producer_value(:controller_index)
+        return true if index && (index.find(name) || index.find("::#{name}"))
+
+        name.end_with?("Controller")
+      end
+
       def controller_file?(path)
         @controller_search_paths.any? do |root|
           # The runner may pass `path` as either an absolute

data/plugins/rigor-activerecord/lib/rigor/plugin/activerecord.rb

@@ -208,9 +208,8 @@ module Rigor
       FINDER_METHOD_NAMES = %i[find find_by! find_by where all order limit none select].freeze
       private_constant :FINDER_METHOD_NAMES
 
-      # v0.1.2 — return-type contribution; ADR-52 slice 5b —
-      # migrated off `flow_contribution_for` onto the run-time
-      # `methods:` name gate. `Model.find(id)` narrows the call
+      # Return-type contribution via the run-time `methods:` name
+      # gate (ADR-52 slice 5b). `Model.find(id)` narrows the call
       # site's return type to `Nominal[Model]`, so chained calls
       # (`User.find(1).name`) resolve through the analyzer's
       # normal dispatch instead of the RBS-level untyped

data/plugins/rigor-hanami/lib/rigor/plugin/hanami/action_checker.rb

@@ -22,17 +22,20 @@ module Rigor
           @contracts = contracts
         end
 
-        def check(path:, root:)
-          @contracts.flat_map do |contract|
-            next [] unless path_matches?(contract.path_glob, path)
-
-            class_nodes(root).filter_map do |class_node|
-              handle_def = find_handle(class_node, contract)
-              if handle_def.nil?
-                missing_handle_diagnostic(contract, path, class_node)
-              else
-                handle_arity_mismatch_diagnostic(contract, path, class_node, handle_def)
-              end
+        # Per-`ClassNode` check over the engine-owned walk (ADR-37):
+        # called once per class node the `node_rule` in `hanami.rb`
+        # dispatches, against every contract whose `path_glob` matches
+        # the file. No cross-class-node state is needed, so the checker
+        # ships no `class_nodes` traversal of its own.
+        def check_class(class_node, path:)
+          @contracts.filter_map do |contract|
+            next unless path_matches?(contract.path_glob, path)
+
+            handle_def = find_handle(class_node, contract)
+            if handle_def.nil?
+              missing_handle_diagnostic(contract, path, class_node)
+            else
+              handle_arity_mismatch_diagnostic(contract, path, class_node, handle_def)
             end
           end
         end
@@ -49,12 +52,6 @@ module Rigor
             File.fnmatch?(File.join("**", glob), path, FNMATCH_FLAGS)
         end
 
-        def class_nodes(root)
-          found = []
-          walk(root) { |node| found << node if node.is_a?(Prism::ClassNode) }
-          found
-        end
-
         def find_handle(class_node, contract)
           direct_defs(class_node).find do |def_node|
             def_node.name == contract.method_name &&
@@ -107,13 +104,6 @@ module Rigor
           path = class_node.constant_path
           path.respond_to?(:slice) ? path.slice : class_node.name.to_s
         end
-
-        def walk(node, &)
-          return if node.nil?
-
-          yield node
-          node.compact_child_nodes.each { |child| walk(child, &) }
-        end
       end
     end
   end

data/plugins/rigor-hanami/lib/rigor/plugin/hanami.rb

@@ -98,11 +98,18 @@ module Rigor
         @protocol_contracts || manifest.protocol_contracts
       end
 
-      def diagnostics_for_file(path:, scope:, root:) # rubocop:disable Lint/UnusedMethodArgument
+      # ADR-37 — per-class-node validation over the engine-owned walk.
+      # Each `Prism::ClassNode` is checked against every contract
+      # independently, so the plugin no longer ships its own `class_nodes`
+      # traversal; `ActionChecker#check_class` keeps the per-class
+      # contract logic. (A per-class contract check is exactly what
+      # `node_rule` is for — the return type is void, so no `scope`
+      # query is needed.)
+      node_rule Prism::ClassNode do |node, _scope, path|
         contracts = protocol_contracts
-        return [] if contracts.empty?
+        next [] if contracts.empty?
 
-        ActionChecker.new(contracts: contracts).check(path: path, root: root)
+        ActionChecker.new(contracts: contracts).check_class(node, path: path)
       end
     end
 

data/plugins/rigor-minitest/lib/rigor/plugin/minitest/assertion_analyzer.rb

@@ -145,7 +145,7 @@ module Rigor
         private_constant :SPEC_MATCHER_FORM
 
         # ADR-37 slice 2 — the method names this analyzer narrows on,
-        # for the plugin's `type_specifier methods:` gate.
+        # for the plugin's `narrowing_facts methods:` gate.
         SUPPORTED_METHODS = (ASSERT_FORM.keys + SPEC_MATCHER_FORM.keys).freeze
 
         def spec_form_fact(call_node, environment:)

data/plugins/rigor-minitest/lib/rigor/plugin/minitest.rb

@@ -78,7 +78,7 @@ module Rigor
       # assertion, method-gated by the engine. The engine routes
       # `:local`-kind facts through
       # `StatementEvaluator#apply_local_post_return_fact`.
-      type_specifier methods: AssertionAnalyzer::SUPPORTED_METHODS do |call_node, scope|
+      narrowing_facts methods: AssertionAnalyzer::SUPPORTED_METHODS do |call_node, scope|
         AssertionAnalyzer.contribution_for(call_node, environment: scope&.environment)&.post_return_facts
       end
     end

data/plugins/rigor-rspec/lib/rigor/plugin/rspec.rb

@@ -110,7 +110,7 @@ module Rigor
       # ADR-37 slice 2 — matcher narrowing
       # (`expect(x).to be_a(T)` → `post_return_facts` on `x`),
       # method-gated by the engine on the expectation verbs.
-      type_specifier methods: %i[to not_to to_not] do |call_node, scope|
+      narrowing_facts methods: %i[to not_to to_not] do |call_node, scope|
         MatcherAnalyzer.contribution_for(call_node, environment: scope&.environment)&.post_return_facts
       end
 

data/plugins/rigor-sorbet/lib/rigor/plugin/sorbet.rb

@@ -147,11 +147,7 @@ module Rigor
         # symlink-bearing form here. Look up under both so the
         # match is symlink-agnostic.
         errors = @parse_errors_by_path[path] || @parse_errors_by_path[canonicalize(path)] || []
-        diagnostics = errors.map { |error| parse_error_diagnostic(path, error) }
-        diagnostics.concat(absurd_reachable_diagnostics(path, root))
-        diagnostics.concat(reveal_type_diagnostics(path, root))
-        diagnostics.concat(assert_type_mismatch_diagnostics(path, root))
-        diagnostics
+        errors.map { |error| parse_error_diagnostic(path, error) }
       end
 
       # ADR-52 slice 4 — per-call return-type path via the
@@ -169,16 +165,45 @@ module Rigor
       end
 
       # ADR-52 slice 4 — `T.bind(self, T)`'s self-narrowing fact,
-      # contributed via the method-gated `type_specifier` DSL. The
+      # contributed via the method-gated `narrowing_facts` DSL. The
       # statement evaluator consults this path for narrowing facts.
       # The return-type half (`Constant[nil]`) flows through the
       # `dynamic_return` rule above; the block re-checks the `T.`
       # receiver via the recogniser, so an unrelated `bind` call
       # contributes nothing.
-      type_specifier methods: [:bind] do |call_node, scope|
+      narrowing_facts methods: [:bind] do |call_node, scope|
         bind_post_return_facts(call_node, scope)
       end
 
+      # ADR-37 — the three per-call diagnostics ride the engine-owned
+      # walk instead of three hand-rolled `walk_for_*` recursions. Each
+      # candidate `T.` call is *recorded by object identity* during the
+      # inference pass (the `dynamic_return` / `narrowing_facts` rules
+      # above call `record_*`), so by the time these node rules fire in
+      # the diagnostics phase the sets are populated; the membership
+      # `delete` both gates the emission and pops the entry so a re-run
+      # cannot double-fire. The recorded set is the gate — no per-node
+      # `AbsurdRecognizer` / name check is needed here.
+      node_rule Prism::CallNode do |node, _scope, path|
+        next [] unless @reachable_absurd_nodes.delete(node)
+
+        [absurd_diagnostic(path, node)]
+      end
+
+      node_rule Prism::CallNode do |node, _scope, path|
+        display = @reveal_type_calls.delete(node)
+        next [] if display.nil?
+
+        [reveal_type_diagnostic(path, node, display)]
+      end
+
+      node_rule Prism::CallNode do |node, _scope, path|
+        recorded = @assert_type_mismatches.delete(node)
+        next [] if recorded.nil?
+
+        [assert_type_mismatch_diagnostic(path, node, *recorded)]
+      end
+
       private
 
       # Run-time method-name gate for the `dynamic_return` rule
@@ -258,7 +283,7 @@ module Rigor
         lookup_signature(call_node, scope)&.return_type
       end
 
-      # The `type_specifier` body for `T.bind` — same sigil gate as
+      # The `narrowing_facts` body for `T.bind` — same sigil gate as
       # the return-type path, then the recogniser's
       # `post_return_facts` (the `Fact(target_kind: :self)` that
       # narrows `scope.self_type` for the rest of the block).
@@ -536,31 +561,9 @@ module Rigor
         nil
       end
 
-      # Walks the per-file AST looking for `T.absurd(x)` call
-      # nodes and emits a `plugin.sorbet.absurd-reachable`
-      # warning for any whose object identity matches
-      # `@reachable_absurd_nodes` (populated during the engine's
-      # earlier pass through the `dynamic_return` rule). Pops
-      # matched entries so a duplicate run doesn't double-emit.
-      def absurd_reachable_diagnostics(path, root)
-        return [] if @reachable_absurd_nodes.empty?
-
-        diagnostics = []
-        walk_for_absurd(root) do |call_node|
-          next unless @reachable_absurd_nodes.delete(call_node)
-
-          diagnostics << absurd_diagnostic(path, call_node)
-        end
-        diagnostics
-      end
-
-      def walk_for_absurd(node, &)
-        return unless node.is_a?(Prism::Node)
-
-        yield node if node.is_a?(Prism::CallNode) && AbsurdRecognizer.absurd_call?(node)
-        node.compact_child_nodes.each { |child| walk_for_absurd(child, &) }
-      end
-
+      # Emits a `plugin.sorbet.absurd-reachable` warning for the
+      # `T.absurd(x)` call recorded in `@reachable_absurd_nodes` during
+      # inference; the node rule above does the identity match and pop.
       def absurd_diagnostic(path, call_node)
         Rigor::Analysis::Diagnostic.from_node(
           call_node,
@@ -591,29 +594,6 @@ module Rigor
         type.respond_to?(:describe) ? type.describe : type.inspect
       end
 
-      def reveal_type_diagnostics(path, root)
-        return [] if @reveal_type_calls.empty?
-
-        diagnostics = []
-        walk_for_reveal_type(root) do |call_node|
-          display = @reveal_type_calls.delete(call_node)
-          next if display.nil?
-
-          diagnostics << reveal_type_diagnostic(path, call_node, display)
-        end
-        diagnostics
-      end
-
-      def walk_for_reveal_type(node, &)
-        return unless node.is_a?(Prism::Node)
-
-        if node.is_a?(Prism::CallNode) && node.name == :reveal_type &&
-           TypeTranslator.sorbet_t_namespaced?(node.receiver)
-          yield node
-        end
-        node.compact_child_nodes.each { |child| walk_for_reveal_type(child, &) }
-      end
-
       def reveal_type_diagnostic(path, call_node, display)
         Rigor::Analysis::Diagnostic.from_node(
           call_node,
@@ -647,29 +627,6 @@ module Rigor
         @assert_type_mismatches[call_node] = [display_for_type(inferred), display_for_type(asserted)]
       end
 
-      def assert_type_mismatch_diagnostics(path, root)
-        return [] if @assert_type_mismatches.empty?
-
-        diagnostics = []
-        walk_for_assert_type(root) do |call_node|
-          recorded = @assert_type_mismatches.delete(call_node)
-          next if recorded.nil?
-
-          diagnostics << assert_type_mismatch_diagnostic(path, call_node, *recorded)
-        end
-        diagnostics
-      end
-
-      def walk_for_assert_type(node, &)
-        return unless node.is_a?(Prism::Node)
-
-        if node.is_a?(Prism::CallNode) && node.name == :assert_type! &&
-           TypeTranslator.sorbet_t_namespaced?(node.receiver)
-          yield node
-        end
-        node.compact_child_nodes.each { |child| walk_for_assert_type(child, &) }
-      end
-
       def assert_type_mismatch_diagnostic(path, call_node, inferred_display, asserted_display)
         Rigor::Analysis::Diagnostic.from_node(
           call_node,

data/sig/rigor/plugin/base.rbs

@@ -26,6 +26,8 @@ class Rigor::Plugin::Base
   def self.dynamic_return: (?receivers: (Array[String] | ^() -> Array[String])?, ?methods: (Array[untyped] | ^() -> Array[untyped])?) { (untyped call_node, untyped scope) -> untyped } -> nil
   def self.dynamic_returns: () -> Array[untyped]
 
+  def self.narrowing_facts: (methods: Array[untyped]) { (untyped call_node, untyped scope) -> untyped } -> nil
+  # Deprecating alias for `narrowing_facts` (ADR-80); removed in 0.3.0.
   def self.type_specifier: (methods: Array[untyped]) { (untyped call_node, untyped scope) -> untyped } -> nil
   def self.type_specifiers: () -> Array[untyped]
 

data/sig/rigor/scope.rbs

@@ -8,6 +8,7 @@ module Rigor
     attr_reader cvars: Hash[Symbol, Type::t]
     attr_reader globals: Hash[Symbol, Type::t]
     attr_reader discovery: DiscoveryIndex
+    attr_reader dynamic_origins: Hash[untyped, Symbol]
     attr_reader indexed_narrowings: Hash[IndexedKey, Type::t]
     attr_reader method_chain_narrowings: Hash[ChainKey, Type::t]
     attr_reader source_path: String?
@@ -32,6 +33,7 @@ module Rigor
     def data_member_layouts: () -> Hash[String, Array[Symbol]]
     def struct_member_layouts: () -> Hash[String, { members: Array[Symbol], keyword_init: bool }]
     def param_inferred_types: () -> Hash[[String, Symbol, Symbol], Hash[Symbol, Type::t]]
+    def record_dynamic_origin: (untyped node, Symbol cause) -> Scope
 
     class DiscoveryIndex
       attr_reader declared_types: Hash[untyped, Type::t]
@@ -71,7 +73,7 @@ module Rigor
 
     def self.empty: (?environment: Environment, ?source_path: String?) -> Scope
 
-    def initialize: (environment: Environment, locals: Hash[Symbol, Type::t], ?fact_store: Analysis::FactStore, ?self_type: Type::t?, ?ivars: Hash[Symbol, Type::t], ?cvars: Hash[Symbol, Type::t], ?globals: Hash[Symbol, Type::t], ?discovery: DiscoveryIndex, ?source_path: String?) -> void
+    def initialize: (environment: Environment, locals: Hash[Symbol, Type::t], ?fact_store: Analysis::FactStore, ?self_type: Type::t?, ?ivars: Hash[Symbol, Type::t], ?cvars: Hash[Symbol, Type::t], ?globals: Hash[Symbol, Type::t], ?discovery: DiscoveryIndex, ?source_path: String?, ?dynamic_origins: Hash[untyped, Symbol]) -> void
     def with_source_path: (String? path) -> Scope
     def with_struct_fold_safe: (Set[Symbol] locals) -> Scope
     def struct_fold_safe?: (String | Symbol name) -> bool