rigortype 0.1.15 → 0.1.16

data/plugins/rigor-factorybot/lib/rigor/plugin/factorybot/analyzer.rb

@@ -2,6 +2,7 @@
 
 require "did_you_mean"
 require "prism"
+require "rigor/source/literals"
 
 module Rigor
   module Plugin
@@ -20,35 +21,34 @@ module Rigor
       module Analyzer
         ENTRY_METHODS = %i[create build build_stubbed attributes_for create_list build_list build_stubbed_list].freeze
 
-        Diagnostic = Data.define(:path, :line, :column, :message, :severity, :rule)
+        # One violation. Carries its own `location` because a single
+        # entry call yields diagnostics at different positions — the
+        # matcher/method name (`message_loc`) for factory-call /
+        # unknown-factory, and the attribute key node for
+        # unknown-attribute. The caller positions each via
+        # `Plugin::Base#diagnostic(node, location:)`.
+        Violation = Data.define(:location, :message, :severity, :rule)
 
         module_function
 
-        def diagnose(path:, root:, factory_index:, model_index: nil)
-          diagnostics = []
-          spell_checker = DidYouMean::SpellChecker.new(dictionary: factory_index.names)
-
-          walk_entry_calls(root) do |call_node|
-            factory_name = first_positional_symbol_or_string(call_node)
-            next if factory_name.nil?
-
-            entry = factory_index.find(factory_name)
-            diagnostics.concat(
-              diagnostics_for_call(path, call_node, factory_name, entry, spell_checker, model_index)
-            )
-          end
-
-          diagnostics
-        end
+        # The violations for a single entry call (`FactoryBot.create(...)`
+        # etc.), or `[]` when the node is not an entry call or its first
+        # argument is not a literal factory name. ADR-37: the engine owns
+        # the walk.
+        #
+        # @param call_node [Prism::Node]
+        # @param factory_index [FactoryIndex]
+        # @param model_index [Hash, nil]
+        # @return [Array<Violation>]
+        def violations_for(call_node:, factory_index:, model_index: nil)
+          return [] unless entry_call?(call_node)
 
-        # Walk the AST yielding only call nodes whose receiver
-        # is `FactoryBot` (or the `FactoryGirl` legacy alias)
-        # and whose method name is in {ENTRY_METHODS}.
-        def walk_entry_calls(node, &)
-          return unless node.is_a?(Prism::Node)
+          factory_name = first_positional_symbol_or_string(call_node)
+          return [] if factory_name.nil?
 
-          yield node if entry_call?(node)
-          node.compact_child_nodes.each { |child| walk_entry_calls(child, &) }
+          spell_checker = DidYouMean::SpellChecker.new(dictionary: factory_index.names)
+          entry = factory_index.find(factory_name)
+          violations_for_call(call_node, factory_name, entry, spell_checker, model_index)
         end
 
         def entry_call?(node)
@@ -70,18 +70,14 @@ module Rigor
         end
 
         def first_positional_symbol_or_string(call_node)
-          first_arg = call_node.arguments&.arguments&.first
-          case first_arg
-          when Prism::SymbolNode then first_arg.value
-          when Prism::StringNode then first_arg.unescaped
-          end
+          Rigor::Source::Literals.symbol_or_string_name(call_node.arguments&.arguments&.first)
         end
 
-        def diagnostics_for_call(path, call_node, factory_name, entry, spell_checker, model_index)
-          return [unknown_factory_diagnostic(path, call_node, factory_name, spell_checker)] if entry.nil?
+        def violations_for_call(call_node, factory_name, entry, spell_checker, model_index)
+          return [unknown_factory_violation(call_node, factory_name, spell_checker)] if entry.nil?
 
-          unknown_attribute_diagnostics(path, call_node, entry, model_index) +
-            [factory_call_diagnostic(path, call_node, factory_name, entry)]
+          unknown_attribute_violations(call_node, entry, model_index) +
+            [factory_call_violation(call_node, factory_name, entry)]
         end
 
         # The keyword-argument attribute keys come from the
@@ -98,7 +94,7 @@ module Rigor
         # accepts any AR attribute regardless of whether the
         # factory declared it, so the cross-check broadens the
         # acceptance accordingly.
-        def unknown_attribute_diagnostics(path, call_node, entry, model_index)
+        def unknown_attribute_violations(call_node, entry, model_index)
           accepted_keys, suggestion_dictionary = effective_keys(entry, model_index)
           attr_spell_checker = DidYouMean::SpellChecker.new(dictionary: suggestion_dictionary)
           attribute_assoc_nodes(call_node).filter_map do |assoc|
@@ -107,7 +103,7 @@ module Rigor
             attr_name = assoc.key.value
             next if accepted_keys.include?(attr_name)
 
-            unknown_attribute_diagnostic(path, assoc, entry, attr_name, attr_spell_checker)
+            unknown_attribute_violation(assoc, entry, attr_name, attr_spell_checker)
           end
         end
 
@@ -139,35 +135,34 @@ module Rigor
           last.elements.grep(Prism::AssocNode)
         end
 
-        def factory_call_diagnostic(path, call_node, factory_name, entry)
+        def factory_call_violation(call_node, factory_name, entry)
           loc = call_node.message_loc || call_node.location
           attrs = entry.attribute_names.empty? ? "(no attributes)" : entry.attribute_names.join(", ")
-          Diagnostic.new(
-            path: path, line: loc.start_line, column: loc.start_column + 1,
+          Violation.new(
+            location: loc,
             message: "FactoryBot.#{call_node.name}(:#{factory_name}) — declared attributes: #{attrs}.",
             severity: :info, rule: "factory-call"
           )
         end
 
-        def unknown_factory_diagnostic(path, call_node, factory_name, spell_checker)
+        def unknown_factory_violation(call_node, factory_name, spell_checker)
           loc = call_node.message_loc || call_node.location
           base = "FactoryBot.#{call_node.name}(:#{factory_name}) — factory not declared in any " \
                  "factory_search_paths file."
           suggestion = spell_checker.correct(factory_name).first
           message = suggestion ? "#{base} Did you mean `:#{suggestion}`?" : base
-          Diagnostic.new(
-            path: path, line: loc.start_line, column: loc.start_column + 1,
+          Violation.new(
+            location: loc,
             message: message, severity: :error, rule: "unknown-factory"
           )
         end
 
-        def unknown_attribute_diagnostic(path, assoc, entry, attr_name, spell_checker)
-          loc = assoc.key.location
+        def unknown_attribute_violation(assoc, entry, attr_name, spell_checker)
           base = "FactoryBot factory `:#{entry.name}` has no declared attribute `:#{attr_name}`."
           suggestion = spell_checker.correct(attr_name).first
           message = suggestion ? "#{base} Did you mean `:#{suggestion}`?" : base
-          Diagnostic.new(
-            path: path, line: loc.start_line, column: loc.start_column + 1,
+          Violation.new(
+            location: assoc.key.location,
             message: message, severity: :error, rule: "unknown-attribute"
           )
         end

data/plugins/rigor-factorybot/lib/rigor/plugin/factorybot/factory_discoverer.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "prism"
+require "rigor/source/literals"
 
 require_relative "factory_index"
 
@@ -112,11 +113,7 @@ module Rigor
         end
 
         def literal_name_arg(call_node)
-          first_arg = call_node.arguments&.arguments&.first
-          case first_arg
-          when Prism::SymbolNode then first_arg.value
-          when Prism::StringNode then first_arg.unescaped
-          end
+          Rigor::Source::Literals.symbol_or_string_name(call_node.arguments&.arguments&.first)
         end
 
         # Pillar 2 Slice 3 — resolve the model class name for
@@ -136,7 +133,11 @@ module Rigor
           explicit = explicit_class_option(call_node)
           return explicit if explicit
 
-          camelize(factory_name)
+          # ADR-39: the real ActiveSupport::Inflector camelizes the factory
+          # name to its class (`admin_user` → `AdminUser`,
+          # `admin/user` → `Admin::User`), so the model-class fallback
+          # matches Rails' real convention rather than an approximation.
+          Rigor::Plugin::Inflector.camelize(factory_name)
         end
 
         def explicit_class_option(call_node)
@@ -180,17 +181,6 @@ module Rigor
           end
         end
 
-        # Pure-Ruby camelize for the factory-name fallback.
-        # `user` → `User`, `blog_post` → `BlogPost`, `admin_user`
-        # → `AdminUser`. Factory names with `/` separators
-        # (`admin/user`) camelize per-segment and join with `::`
-        # (`Admin::User`), mirroring Rails inflection.
-        def camelize(snake)
-          snake.to_s.split("/").map do |segment|
-            segment.split("_").map { |part| part.empty? ? part : part[0].upcase + part[1..] }.join
-          end.join("::")
-        end
-
         def collect_attribute_names(block_node)
           return [] unless block_node.is_a?(Prism::BlockNode)
 

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

@@ -80,18 +80,13 @@ module Rigor
                      "publishes per-factory attribute set + inferred model class as the " \
                      ":factory_index ADR-9 fact (Pillar 2 Slice 3).",
         config_schema: {
-          "factory_search_paths" => :array
+          "factory_search_paths" => { kind: :array, default: ["spec/factories", "spec/factories.rb"] }
         },
         consumes: [
           { plugin_id: "activerecord", name: :model_index, optional: true }
         ]
       )
 
-      DEFAULT_FACTORY_SEARCH_PATHS = [
-        "spec/factories",
-        "spec/factories.rb"
-      ].freeze
-
       producer :factory_index do |_params|
         FactoryDiscoverer.new(
           io_boundary: io_boundary,
@@ -101,22 +96,29 @@ module Rigor
 
       def init(services)
         @services = services
-        @factory_search_paths = Array(
-          config.fetch("factory_search_paths", DEFAULT_FACTORY_SEARCH_PATHS)
-        ).map(&:to_s)
+        @factory_search_paths = Array(config.fetch("factory_search_paths")).map(&:to_s)
         @factory_index = nil
         @model_index = nil
         @model_index_resolved = false
       end
 
-      def diagnostics_for_file(path:, scope:, root:) # rubocop:disable Lint/UnusedMethodArgument
+      # ADR-37 — per-call factory/attribute validation over the
+      # engine-owned walk. Each violation carries its own location
+      # (the call's message_loc, or the offending attribute key), so it
+      # is positioned via `diagnostic(node, location:)`. No file-level
+      # diagnostic remains, so there is no `diagnostics_for_file`.
+      node_rule Prism::CallNode do |node, _scope, path|
         index = factory_index_or_nil
-        return [] if index.nil? || index.empty?
-
-        Analyzer.diagnose(
-          path: path, root: root,
-          factory_index: index, model_index: model_index_or_nil
-        ).map { |diag| build_diagnostic(diag) }
+        next [] if index.nil? || index.empty?
+
+        Analyzer.violations_for(
+          call_node: node, factory_index: index, model_index: model_index_or_nil
+        ).map do |violation|
+          diagnostic(
+            node, path: path, location: violation.location,
+                  message: violation.message, severity: violation.severity, rule: violation.rule
+          )
+        end
       end
 
       private
@@ -138,35 +140,11 @@ module Rigor
       def factory_index_or_nil
         return @factory_index if @factory_index
 
-        prime_io_boundary_for_index
-        @factory_index = cache_for(:factory_index, params: {}).call
+        descriptor = glob_descriptor(@factory_search_paths, "**/*.rb")
+        @factory_index = cache_for(:factory_index, params: {}, descriptor: descriptor).call
       rescue StandardError
         nil
       end
-
-      def prime_io_boundary_for_index
-        @factory_search_paths.each do |root|
-          absolute = File.expand_path(root)
-          if File.file?(absolute)
-            safely_read(absolute)
-          elsif File.directory?(absolute)
-            Dir.glob(File.join(absolute, "**", "*.rb")).each { |p| safely_read(p) }
-          end
-        end
-      end
-
-      def safely_read(path)
-        io_boundary.read_file(path)
-      rescue Plugin::AccessDeniedError, Errno::ENOENT
-        nil
-      end
-
-      def build_diagnostic(diag)
-        Rigor::Analysis::Diagnostic.new(
-          path: diag.path, line: diag.line, column: diag.column,
-          message: diag.message, severity: diag.severity, rule: diag.rule
-        )
-      end
     end
 
     Rigor::Plugin.register(Factorybot)

data/plugins/rigor-graphql/lib/rigor/plugin/graphql/type_scanner.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "prism"
+require "rigor/source/literals"
 
 module Rigor
   module Plugin
@@ -255,13 +256,14 @@ module Rigor
 
           name_node = args[0]
           type_node = args[1]
-          return nil unless name_node.is_a?(Prism::SymbolNode)
+          name = Rigor::Source::Literals.symbol_name(name_node)
+          return nil if name.nil?
 
           type_info = resolve_field_type(type_node)
           return nil if type_info.nil?
 
           {
-            name: name_node.unescaped,
+            name: name,
             type: type_info[:type],
             list: type_info[:list],
             required: extract_required_flag(args)
@@ -304,13 +306,14 @@ module Rigor
 
           name_node = args[0]
           type_node = args[1]
-          return nil unless name_node.is_a?(Prism::SymbolNode)
+          name = Rigor::Source::Literals.symbol_name(name_node)
+          return nil if name.nil?
 
           type_info = resolve_field_type(type_node)
           return nil if type_info.nil?
 
           {
-            name: name_node.unescaped,
+            name: name,
             type: type_info[:type],
             list: type_info[:list],
             nullable: extract_nullability(args)

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

@@ -82,11 +82,9 @@ module Rigor
           req_count = def_node.parameters ? def_node.parameters.requireds.size : 0
           return nil if req_count == 2
 
-          location = def_node.location
-          Rigor::Analysis::Diagnostic.new(
+          Rigor::Analysis::Diagnostic.from_location(
+            def_node.location,
             path: path,
-            line: location.start_line,
-            column: location.start_column + 1,
             message: "`#{class_name(class_node)}#handle` must accept exactly 2 parameters " \
                      "(request, response), got #{req_count}",
             severity: contract.severity,
@@ -95,11 +93,9 @@ module Rigor
         end
 
         def missing_handle_diagnostic(contract, path, class_node)
-          location = (class_node.constant_path || class_node).location
-          Rigor::Analysis::Diagnostic.new(
+          Rigor::Analysis::Diagnostic.from_location(
+            (class_node.constant_path || class_node).location,
             path: path,
-            line: location.start_line,
-            column: location.start_column + 1,
             message: "`#{class_name(class_node)}` must define `#handle(request, response)` — " \
                      "required of every Hanami action under `#{contract.path_glob}`",
             severity: contract.severity,

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

@@ -0,0 +1,188 @@
+# frozen_string_literal: true
+
+require "prism"
+require "rigor/plugin"
+
+module Rigor
+  module Plugin
+    # rigor-mangrove — precision plugin for the
+    # [Mangrove](https://github.com/kazzix14/mangrove) functional
+    # toolkit (Result / Option carriers).
+    #
+    # ## Why this plugin exists (and what it deliberately is NOT)
+    #
+    # Mangrove is a Sorbet-first library: every carrier method is
+    # annotated with an inline `sig { ... }`, and the Enum DSL's
+    # dynamic variants are materialised by a bundled Tapioca DSL
+    # compiler. So the *type source* for Mangrove is already
+    # covered by `rigor-sorbet` (sig ingestion + RBI walking) —
+    # this plugin is NOT a parallel type source. See
+    # `docs/notes/20260530-mangrove-library-survey.md`.
+    #
+    # What sig-ingestion (Sorbet-level precision) structurally
+    # cannot do is **instantiate the carrier's generic
+    # type-member at the unwrap call site**. Mangrove's `Result`
+    # interface declares:
+    #
+    #     sig { abstract.returns(OkType) }
+    #     def unwrap!; end
+    #
+    # `OkType` is a `type_member(:out)`. When the receiver's
+    # static type is `Mangrove::Result[String, StandardError]`,
+    # `unwrap!` *should* yield `String` — but resolving the
+    # abstract `OkType` to the receiver's first type argument is
+    # generic instantiation, which neither `rigor-sorbet` (it
+    # contributes the cataloged sig's return type verbatim) nor a
+    # bare-`def unwrap!: () -> untyped` RBS stub performs. The
+    # call degrades to `Dynamic[top]`.
+    #
+    # This plugin closes exactly that gap. At every recognised
+    # unwrap-family call on a known Mangrove carrier, it reads the
+    # receiver's `Rigor::Type::Nominal#type_args` and contributes
+    # the first argument (the `OkType` / `InnerType`) as the
+    # call's return type. The receiver type is already known, so
+    # this only ever *sharpens* an existing `Dynamic[top]` into a
+    # concrete type — it never invents a receiver type and never
+    # emits a diagnostic of its own, so it cannot frighten working
+    # code (Rigor's false-positive discipline).
+    #
+    # ## Scope (slice 1)
+    #
+    # - Result unwrap family → `OkType` (`type_args[0]`):
+    #   `unwrap!`, `unwrap_in`, `expect!`, `expect_with!`,
+    #   `unwrap_or_raise!`, `unwrap_or_raise_with!`,
+    #   `unwrap_or_raise_inner!`.
+    # - Option unwrap family → `InnerType` (`type_args[0]`):
+    #   `unwrap`, `unwrap!`, `unwrap_or`, `expect!`,
+    #   `expect_with!`.
+    #
+    # The contribution fires only when the receiver resolves to a
+    # carrier Nominal carrying a non-empty `type_args` — i.e. when
+    # the Result/Option came from a method whose declared return
+    # type is an applied generic (`-> Result[String, E]`), the
+    # realistic Mangrove shape. The bare-constructor shape
+    # (`Result::Ok.new("x")`) currently yields a raw Nominal with
+    # no `type_args` (the engine does not infer generics from
+    # constructor arguments), so the plugin no-ops there rather
+    # than guessing — a conservative floor, not a regression.
+    #
+    # ## Out of scope (tracked elsewhere)
+    #
+    # - `is_a?(Result::Ok)` / `Some` / `None` exhaustive
+    #   narrowing — core control-flow analysis over a sealed
+    #   hierarchy, not a plugin surface.
+    # - The `variants do variant Const, Type end` Enum DSL — needs
+    #   an ADR-16 nested-class emission tier (ADR-36). Today's
+    #   contract has no `const_set`-emitting macro substrate.
+    class Mangrove < Rigor::Plugin::Base
+      manifest(
+        id: "mangrove",
+        version: "0.2.0",
+        description: "Instantiates Mangrove Result/Option carrier generics at unwrap call sites, " \
+                     "sharpening `unwrap!` / `unwrap_in` / `unwrap_or` from `untyped` to the carried type; " \
+                     "synthesises `Enum` variant subclasses from the `variants do … end` DSL (ADR-36).",
+        # ADR-36 nested-class emission — Mangrove's `Enum`:
+        #
+        #   class Shape
+        #     extend Mangrove::Enum
+        #     variants do
+        #       variant Circle, Float
+        #     end
+        #   end
+        #
+        # mints `Shape::Circle < Shape` with `#inner : Float`. The
+        # substrate resolves the variant constant + its `#inner`
+        # reader statically so `Shape::Circle.new(1.0).inner`
+        # types as `Float` without running Mangrove's `const_missing`.
+        nested_class_templates: [
+          Rigor::Plugin::Macro::NestedClassTemplate.new(
+            receiver_constraint: "Mangrove::Enum",
+            block_method: :variants,
+            variant_method: :variant,
+            name_arg_position: 0,
+            inner_arg_position: 1,
+            inner_reader: :inner
+          )
+        ]
+      )
+
+      # Carrier class names whose FIRST type argument is the
+      # value the unwrap family yields (`OkType` for Result,
+      # `InnerType` for Option). Matched with and without a
+      # leading `::` because `scope.type_of` reports the lexical
+      # form while user code may root the constant.
+      RESULT_CARRIERS = [
+        "Mangrove::Result",
+        "Mangrove::Result::Ok",
+        "Mangrove::Result::Err"
+      ].freeze
+
+      OPTION_CARRIERS = [
+        "Mangrove::Option",
+        "Mangrove::Option::Some",
+        "Mangrove::Option::None"
+      ].freeze
+
+      # Methods on the Result carriers that return `OkType`
+      # (`type_args[0]`). All of these are documented as yielding
+      # the success value, raising / short-circuiting on `Err`.
+      RESULT_UNWRAP_METHODS = %i[
+        unwrap! unwrap_in expect! expect_with!
+        unwrap_or_raise! unwrap_or_raise_with! unwrap_or_raise_inner!
+      ].freeze
+
+      # Methods on the Option carriers that return `InnerType`
+      # (`type_args[0]`).
+      OPTION_UNWRAP_METHODS = %i[unwrap unwrap! unwrap_or expect! expect_with!].freeze
+
+      # ADR-37 slice 2 — a pure return-type contributor. The engine
+      # gates on the receiver being a known carrier class (so the block
+      # only runs on Result/Option receivers); the block then confirms
+      # the call is an unwrap method on an instantiated carrier and
+      # yields the carried `type_args[0]`.
+      dynamic_return receivers: (RESULT_CARRIERS + OPTION_CARRIERS) do |call_node, scope|
+        receiver = call_node.receiver
+        next nil if receiver.nil?
+
+        receiver_type = receiver_type_of(receiver, scope)
+        next nil unless receiver_type.is_a?(Rigor::Type::Nominal)
+
+        carried_type(receiver_type, call_node.name)
+      end
+
+      private
+
+      # @return [Rigor::Type, nil] the receiver's inferred type, or
+      #   nil when the engine raises on a synthetic / unrecognised
+      #   node (mirrors rigor-sorbet's defensive degrade).
+      def receiver_type_of(receiver, scope)
+        scope.type_of(receiver)
+      rescue StandardError
+        nil
+      end
+
+      # The value the unwrap family yields for this receiver, or
+      # nil when the call is not an unwrap on a known carrier, or
+      # the carrier is raw (no `type_args` to instantiate).
+      def carried_type(receiver_type, method_name)
+        class_name = normalize(receiver_type.class_name)
+        type_args = receiver_type.type_args
+        return nil if type_args.empty?
+
+        if RESULT_CARRIERS.include?(class_name)
+          return type_args.first if RESULT_UNWRAP_METHODS.include?(method_name)
+        elsif OPTION_CARRIERS.include?(class_name)
+          return type_args.first if OPTION_UNWRAP_METHODS.include?(method_name)
+        end
+
+        nil
+      end
+
+      def normalize(class_name)
+        class_name.start_with?("::") ? class_name.delete_prefix("::") : class_name
+      end
+    end
+
+    Rigor::Plugin.register(Mangrove)
+  end
+end

data/plugins/rigor-mangrove/lib/rigor-mangrove.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative "rigor/plugin/mangrove"

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

@@ -144,6 +144,10 @@ module Rigor
         }.freeze
         private_constant :SPEC_MATCHER_FORM
 
+        # ADR-37 slice 2 — the method names this analyzer narrows on,
+        # for the plugin's `type_specifier methods:` gate.
+        SUPPORTED_METHODS = (ASSERT_FORM.keys + SPEC_MATCHER_FORM.keys).freeze
+
         def spec_form_fact(call_node, environment:)
           shape_negative = SPEC_MATCHER_FORM[call_node.name]
           return nil if shape_negative.nil?

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

@@ -54,16 +54,32 @@ module Rigor
         id: "minitest",
         version: "0.1.0",
         description: "Narrows locals through Minitest / Test::Unit `assert_*` / `refute_*` " \
-                     "and Minitest/spec `_(x).must_*` / `.wont_*` matchers."
+                     "and Minitest/spec `_(x).must_*` / `.wont_*` matchers.",
+        # ADR-38 — `def setup` runs before every `def test_*`, so
+        # ivars it assigns are initialised by the time a test body
+        # reads them. Declaring it an additional initializer stops
+        # the read-before-write nil widening that would otherwise
+        # type `@conn` (set in `setup`, read in a test) as
+        # `T | nil` and surface a false nil-receiver diagnostic.
+        additional_initializers: [
+          Rigor::Plugin::AdditionalInitializer.new(
+            receiver_constraint: "Minitest::Test", methods: [:setup]
+          ),
+          Rigor::Plugin::AdditionalInitializer.new(
+            receiver_constraint: "ActiveSupport::TestCase", methods: [:setup]
+          ),
+          Rigor::Plugin::AdditionalInitializer.new(
+            receiver_constraint: "Test::Unit::TestCase", methods: [:setup]
+          )
+        ]
       )
 
-      # Pillar 2 Slice 1 (rigor-minitest sibling) — emits
-      # `post_return_facts` for every recognised assertion. The
-      # engine routes `:local`-kind facts through
-      # `StatementEvaluator#apply_local_post_return_fact` (added
-      # in v0.1.8 for the rigor-rspec slice).
-      def flow_contribution_for(call_node:, scope:)
-        AssertionAnalyzer.contribution_for(call_node, environment: scope&.environment)
+      # ADR-37 slice 2 — emits `post_return_facts` for every recognised
+      # 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|
+        AssertionAnalyzer.contribution_for(call_node, environment: scope&.environment)&.post_return_facts
       end
     end