rigortype 0.4.6 → 0.4.8

data/plugins/rigor-activesupport-core-ext/sig/active_support/core_ext.rbs

@@ -604,6 +604,35 @@ class Float
   def gigabytes: () -> Float
 end
 
+# ---------------------------------------------------------------
+# NumericWithFormat — ActiveSupport's `core_ext/numeric/conversions`, included into Integer, Float and
+# BigDecimal. Declared on the module and included, not as a `def` on each class, so a project `sig/` that
+# declares `Integer#to_fs` itself overrides it instead of raising `DuplicatedMethodDefinitionError` (the
+# `process.rbs` shape). Not pure: the Symbol formats read `I18n` for their locale. An Integer or String
+# format is `to_s(format)`, and no format is `to_s`, so every form answers a String. `options` is any
+# Hash-like value: ActiveSupport calls `symbolize_keys` on it, so String keys and a HashWithIndifferentAccess
+# are both valid.
+# ---------------------------------------------------------------
+
+module ActiveSupport
+  module NumericWithFormat
+    def to_fs: (?(Symbol | Integer | String | nil) format, ?Hash[untyped, untyped]? options) -> String
+    def to_formatted_s: (?(Symbol | Integer | String | nil) format, ?Hash[untyped, untyped]? options) -> String
+  end
+end
+
+class Integer
+  include ActiveSupport::NumericWithFormat
+end
+
+class Float
+  include ActiveSupport::NumericWithFormat
+end
+
+class BigDecimal
+  include ActiveSupport::NumericWithFormat
+end
+
 # ---------------------------------------------------------------
 # ActiveSupport::Duration — issue #632
 # ---------------------------------------------------------------
@@ -1565,28 +1594,35 @@ class Hash[unchecked out K, unchecked out V]
   # non-bang half is `%a{pure}`. `assert_valid_keys` raises rather than
   # mutating (raising is not an effect label).
   %a{pure}
-  def symbolize_keys: () -> Hash[Symbol, V]
+  # `key.to_sym rescue key` keeps a key without `to_sym`, so no one key type is right: `Hash[untyped, V]` here,
+  # and the plugin's `dynamic_return` hook (#2433) maps each key member where it can.
+  def symbolize_keys: () -> Hash[untyped, V]
+  # `symbolize_keys!` keeps `-> self`: `key.to_sym rescue key` leaves a key without `to_sym` as it is, so
+  # `Hash[Symbol, V]` is wrong for an Integer-keyed receiver (#2424 review). The other bang forms below
+  # answer the re-keyed or re-valued hash.
   def symbolize_keys!: () -> self
   %a{pure}
   def deep_symbolize_keys: () -> Hash[untyped, untyped]
-  def deep_symbolize_keys!: () -> self
+  def deep_symbolize_keys!: () -> Hash[untyped, untyped]
   %a{pure}
   def stringify_keys: () -> Hash[String, V]
-  def stringify_keys!: () -> self
+  def stringify_keys!: () -> Hash[String, V]
   %a{pure}
   def deep_stringify_keys: () -> Hash[untyped, untyped]
-  def deep_stringify_keys!: () -> self
+  def deep_stringify_keys!: () -> Hash[untyped, untyped]
   %a{pure}
   def assert_valid_keys: (*K | Array[K]) -> self
+  # The block's result is the new key at every level, so the keys are its type, not `K`: `{ a: 1 }
+  # .deep_transform_keys(&:to_s)` has String keys. Nested values are re-keyed too, so they read `untyped`.
   %a{pure}
-  def deep_transform_keys: () { (K) -> K } -> Hash[K, untyped]
-  def deep_transform_keys!: () { (K) -> K } -> self
+  def deep_transform_keys: [X] () { (K) -> X } -> Hash[X, untyped]
+  def deep_transform_keys!: [X] () { (K) -> X } -> Hash[X, untyped]
   %a{pure}
   def deep_transform_values: () { (V) -> untyped } -> Hash[K, untyped]
-  def deep_transform_values!: () { (V) -> untyped } -> self
+  def deep_transform_values!: () { (V) -> untyped } -> Hash[K, untyped]
   # `alias_method`s of `symbolize_keys` / `symbolize_keys!`.
   %a{pure}
-  def to_options: () -> Hash[Symbol, V]
+  def to_options: () -> Hash[untyped, V]
   def to_options!: () -> self
 
   # `core_ext/hash/deep_dup` — allocates a deep copy, never touches the
@@ -1600,11 +1636,17 @@ class Hash[unchecked out K, unchecked out V]
   # `core_ext/hash/deep_merge` — the block receives `(key, this_val,
   # other_val)` and returns the merged value; neither `deep_merge` nor its
   # block mutates either hash (containment covers the block itself).
-  %a{pure}
-  def deep_merge: (Hash[K, V]) -> Hash[K, V]
-                | (Hash[K, V]) { (K, V, V) -> V } -> Hash[K, V]
-  def deep_merge!: (Hash[K, V]) -> self
-                 | (Hash[K, V]) { (K, V, V) -> V } -> self
+  # The result carries the argument's keys and values as well as the
+  # receiver's, and a key both hold a Hash under merges into a third Hash
+  # that is neither side's value type (`{ n: { x: 1 } }.deep_merge(n: { y:
+  # "s" })[:n]` is `{ x: 1, y: "s" }`), so the values read `untyped`.
+  # `(Hash[K, V]) -> Hash[K, V]` typed `h.deep_merge(b: "x")[:b]` as the
+  # receiver's value type (#2424 review). The bang form answers the receiver.
+  %a{pure}
+  def deep_merge: [A, B] (Hash[A, B] other_hash) -> Hash[K | A, untyped]
+                | [A, B] (Hash[A, B] other_hash) { (K | A, untyped, untyped) -> untyped } -> Hash[K | A, untyped]
+  def deep_merge!: [A, B] (Hash[A, B] other_hash) -> Hash[K | A, untyped]
+                 | [A, B] (Hash[A, B] other_hash) { (K | A, untyped, untyped) -> untyped } -> Hash[K | A, untyped]
   # `other.is_a?(Hash)` — the hook `ActiveSupport::DeepMergeable` asks before
   # recursing into a value. `:nodoc:`, but public.
   %a{pure}

data/plugins/rigor-alba/lib/rigor/plugin/alba/resource_collector.rb

@@ -2,24 +2,22 @@
 
 require "prism"
 
-require "rigor/inference/declaration_walk"
+require "rigor/reflection"
 
 require_relative "resource_index"
 
 module Rigor
   module Plugin
     class Alba < Rigor::Plugin::Base
-      # A {Rigor::Inference::DeclarationWalk} collector over one file: the classes it declares, whether each
-      # `include Alba::Resource`s, and the association declarations whose resource
-      # class alba infers from the name.
+      # A collector over one file, built on {Rigor::Reflection.class_declarations_in}: the classes it declares, whether
+      # each `include Alba::Resource`s, and the association declarations whose resource class alba infers from
+      # the name.
       #
       # An association is recorded only when alba would take the inference path (`Alba::Association#
       # resource_from`): a literal Symbol/String name, exactly one positional argument, no block, and no
       # `resource:` / `serializer:` keyword. A keyword splat (`**opts`) might carry either, so it is not
       # recorded either — a skipped association costs a root, never invents one.
       class ResourceCollector
-        include Rigor::Inference::DeclarationWalk::Collector
-
         ASSOCIATION_METHODS = %i[association one many has_one has_many].freeze
         RESOURCE_MODULE = "Alba::Resource"
         RESOURCE_KEYWORDS = %i[resource serializer].freeze
@@ -40,22 +38,13 @@ module Rigor
           @associations = []
         end
 
-        def on_declaration(node, context, body_context)
-          return Rigor::Inference::DeclarationWalk::DESCEND unless node.is_a?(Prism::ClassNode)
-
-          name = body_context.prefix.join("::")
-          unless name.empty?
-            @entries[name] = superclass_name(node.superclass)
-            @nestings[name] = context.nesting || []
+        # Walks `root` (a parsed file's `Prism::Node`) and records what it finds; answers the collector itself.
+        def collect(root)
+          Rigor::Reflection.class_declarations_in(root) { |call| on_call(call.node, call.owner) }.each do |declaration|
+            @entries[declaration.name] = superclass_name(declaration.node.superclass)
+            @nestings[declaration.name] = declaration.nesting
           end
-          Rigor::Inference::DeclarationWalk::DESCEND
-        end
-
-        def on_call(node, context)
-          owner = context.prefix.join("::")
-          record_call(node, owner) unless owner.empty? || !node.receiver.nil?
-          remember_block(node)
-          Rigor::Inference::DeclarationWalk::DESCEND
+          self
         end
 
         # The classes this file declares, as {ResourceIndex::ClassEntry} values.
@@ -70,6 +59,11 @@ module Rigor
 
         private
 
+        def on_call(node, owner)
+          record_call(node, owner) unless owner.nil? || !node.receiver.nil?
+          remember_block(node)
+        end
+
         def record_call(node, owner)
           if node.name == :include
             @includes[owner] = true if includes_resource?(node)

data/plugins/rigor-alba/lib/rigor/plugin/alba/resource_discoverer.rb

@@ -2,8 +2,6 @@
 
 require "prism"
 
-require "rigor/inference/declaration_walk"
-
 require_relative "resource_collector"
 require_relative "resource_index"
 
@@ -28,10 +26,7 @@ module Rigor
             parsed = Prism.parse(contents)
             next unless parsed.success?
 
-            collector = ResourceCollector.new
-            Rigor::Inference::DeclarationWalk.run(
-              parsed.value, [collector], Rigor::Inference::DeclarationWalk::Context.root(nesting: [])
-            )
+            collector = ResourceCollector.new.collect(parsed.value)
             entries.concat(collector.class_entries)
             associations.concat(collector.associations)
           end

data/plugins/rigor-alba/lib/rigor/plugin/alba/resource_index.rb

@@ -37,9 +37,9 @@ module Rigor
           @classes.empty?
         end
 
-        # The classes alba infers for the associations that name no resource, limited to
-        #   those that exist in the project. The block receives each association name and returns alba's
-        #   `classify` of it (the caller owns the inflector; ADR-39).
+        # The classes alba infers for the associations that name no resource, limited to those that exist in
+        # the project. The block receives each association name and returns alba's `classify` of it (the
+        # caller owns the inflector; ADR-39).
         def inferred_roots(&classify)
           roots = @associations.filter_map do |association|
             next unless resource?(association.owner)

data/plugins/rigor-dry-schema/lib/rigor/plugin/dry_schema/schema_scanner.rb

@@ -212,9 +212,7 @@ module Rigor
         # ... end` row's own recursive call (see {#each_block_type_info}). It caps the recursion at ONE
         # level deep: with `nested: true`, {#walk_predicate_chain} declines a FURTHER `each do ... end`
         # rather than recursing again (issue #137 deliberately does not model doubly-nested arrays of
-        # arrays). This also keeps `collect_schema_shape` from calling itself — {#each_block_type_info}
-        # is the only caller that ever passes `nested: true}` — so the call graph has no cycle for the
-        # engine's return-type inference to approximate through.
+        # arrays). The recursion through {#each_block_type_info} is therefore bounded and terminates.
         def collect_schema_shape(block_node, type_aliases, nested:)
           required = {}
           optional = {}

data/plugins/rigor-dry-struct/lib/rigor/plugin/dry_struct.rb

@@ -34,9 +34,9 @@ module Rigor
     #
     # The synthetic reader's return type is resolved via ADR-18's `returns_from_arg:` fact lookup: the
     # call-site's second argument (`Types::String` etc.) is looked up through the `:dry_type_aliases`
-    # fact published by `rigor-dry-types`, yielding `Nominal[String]` for common cases. When the lookup
-    # misses (e.g. inline method-chain argument whose chain-head isn't currently extracted), the row
-    # falls back to `Dynamic[Top]` silently.
+    # fact published by `rigor-dry-types`, yielding the aliased class (`String`) for common cases. When the
+    # lookup misses (e.g. inline method-chain argument whose chain-head isn't currently extracted), the row
+    # falls back to the untyped floor silently.
     #
     # ## Scope (slice 2c minimum)
     #
@@ -58,8 +58,8 @@ module Rigor
                      "by consuming `rigor-dry-types`'s `:dry_type_aliases` fact.",
         # ADR-9 consumption — the precision-promotion path below uses `:dry_type_aliases` published by
         # `rigor-dry-types`. The fact is optional: when the `rigor-dry-types` plugin isn't loaded, the
-        # `returns_from_arg:` lookup misses and the synthetic readers fall back to `Dynamic[Top]` (the
-        # pre-ADR-18 floor).
+        # `returns_from_arg:` lookup misses and the synthetic readers fall back to the untyped floor (the
+        # pre-ADR-18 behaviour).
         consumes: [{ plugin_id: "dry-types", name: :dry_type_aliases, optional: true }],
         heredoc_templates: [
           Rigor::Plugin::Macro::HeredocTemplate.new(
@@ -69,7 +69,7 @@ module Rigor
             # ADR-18 — the synthetic reader's return type comes from the call site's second argument
             # (`Types::String` etc.), resolved through the `:dry_type_aliases` fact. When the lookup
             # misses (e.g. inline `attribute :tag, Types::String.constrained(...)`, whose receiver chain
-            # head isn't currently extracted), the row falls back to Dynamic[Top].
+            # head isn't currently extracted), the row falls back to the untyped floor.
             emit: [{
               name: "\#{name}",
               returns_from_arg: {

data/plugins/rigor-dry-types/lib/rigor/plugin/dry_types/alias_scanner.rb

@@ -33,10 +33,9 @@ module Rigor
         # `Coercible::*` (everything-to-target coercion), `Strict::*` (no coercion; raise if mismatch),
         # `Params::*` (HTTP / query-string-style coercion, used by Hanami / Roda / dry-web in request
         # handling), `JSON::*` (JSON-shape coercion). Each category exposes the same set of names as the
-        # canonical shortcuts above, plus a few additions that are category-specific (`Params::Nil`,
-        # `JSON::Symbol`). For Rigor's purposes the underlying class is the same regardless of category —
-        # coercion semantics are a runtime concern. We register every `<module>::<Category>::<Name>`
-        # mapping the upstream gem publishes so call-site references work uniformly.
+        # canonical shortcuts above; only those names are registered here, so a category-specific extra
+        # is not covered. For Rigor's purposes the underlying class is the same regardless of category —
+        # coercion semantics are a runtime concern.
         NESTED_CATEGORIES = %w[Coercible Strict Params JSON].freeze
         private_constant :NESTED_CATEGORIES
 
@@ -229,8 +228,8 @@ module Rigor
 
         # `include Dry.Types()` at the top of the module body is the canonical alias declaration. We
         # accept the call anywhere in the body (some projects guard it with a `if defined?` check). The
-        # argument list must be empty (or a kwargs-only `default: :nominal` style accepted by upstream;
-        # we treat both as "alias-installing").
+        # `Dry.Types(...)` argument list is not inspected: kwargs such as `default: :nominal` install the
+        # aliases too.
         def contains_dry_types_include?(body)
           return false if body.nil?
 

data/plugins/rigor-dry-types/lib/rigor/plugin/dry_types.rb

@@ -21,7 +21,7 @@ module Rigor
     # cross-plugin fact (ADR-9). Other dry-rb adapter plugins consume this fact:
     #
     # - `rigor-dry-struct` reads it so `attribute :city, Types::String` promotes `address.city` from
-    #   `Dynamic[Top]` to `Nominal[String]` via ADR-18's `returns_from_arg:` fact lookup.
+    #   from an untyped value to `String` via ADR-18's `returns_from_arg:` fact lookup.
     # - `rigor-dry-validation` / `rigor-dry-schema` read it for per-key type recognition in `schema { … }`
     #   / `params { … }` blocks (separate plugin slice).
     #

data/plugins/rigor-dry-validation/lib/rigor/plugin/dry_validation/params_shape.rb

@@ -44,9 +44,8 @@ module Rigor
         end
 
         # Renders `Foo` / `Foo::Bar` / `::Foo::Bar` as the `::`-joined String {ContractScanner}'s table is
-        # keyed by. Duplicated from rigor-dry-schema's identical helper rather than shared — five lines,
-        # no dependency on anything ELSE in that plugin, and reusing it would need a `registered_for`
-        # guard here too even though this leaf never touches dry-schema's own type/alias machinery.
+        # keyed by. Duplicated from rigor-dry-schema rather than shared: this leaf must not depend on that
+        # plugin, and reusing the helper would need a `registered_for` guard here too.
         def constant_name(node)
           case node
           when Prism::ConstantReadNode then node.name.to_s

data/plugins/rigor-dry-validation/lib/rigor/plugin/dry_validation.rb

@@ -58,19 +58,16 @@ module Rigor
 
       # ADR-37 dynamic return — refines `NewUserContract.new.call(input).to_h` to the per-contract
       # `HashShape` when {#result_shape_for} finds one. Gated on the method name alone (mirrors
-      # rigor-dry-schema's own `.to_h` rule): the RBS overlay types `Contract#call`'s return as the
-      # generic `Result`, but that alone can't select a PER-CONTRACT shape, so the block does its own
-      # syntactic chain match via {ParamsShape.contract_name} before touching the table. When
-      # rigor-dry-schema isn't loaded, or the chain isn't a Contract call, this returns nil and the RBS
-      # overlay's generic `Hash[Symbol, untyped]` stands.
+      # rigor-dry-schema's `.to_h` rule); the chain match is in {ParamsShape.contract_name}, because the
+      # RBS overlay's generic `Result` cannot select a per-contract shape. Otherwise returns nil and the
+      # overlay's generic hash type stands.
       dynamic_return methods: [:to_h] do |call_node, _scope|
         result_shape_for(call_node)
       end
 
       # ADR-37 slice 1c two-pass — the "collect" half of `dry-validation.rule-key-mismatch`. Reads the
-      # SAME `:dry_type_aliases` fact `#prepare` does (a plain `services.fact_store.read`, not
-      # `#read_fact`'s memoised wrapper — `services` at collect time is the run-wide instance, so an
-      # in-block memo isn't needed here the way it is across many per-call `dynamic_return` invocations).
+      # same `:dry_type_aliases` fact as `#prepare`, straight from `services.fact_store` (no `#read_fact`
+      # memo: `services` here is run-wide, unlike the per-call `dynamic_return` blocks).
       node_file_context do |root, _scope|
         type_aliases = services.fact_store.read(plugin_id: "dry-types", name: :dry_type_aliases) || {}
         ContractScanner.rule_key_issues(root, type_aliases)

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

@@ -14,7 +14,6 @@ module Rigor
         signature_paths: ["sig"]
       )
 
-      # Option catalogue and return types for Easy methods
       EASY_RETURN_TYPES = {
         perform: -> { Rigor::Type::Combinator.nominal_of("Integer") },
         response_code: -> { Rigor::Type::Combinator.nominal_of("Integer") },

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

@@ -115,7 +115,7 @@ module Rigor
         # 3. Inflected from the factory name — `:user` → `"User"`, `:admin_user` → `"AdminUser"`. The
         #    factory name is already singular by FactoryBot convention, so we only need camelization.
         #
-        # Returns a String (the canonical class name).
+        # Returns the canonical class name.
         def factory_model_class(call_node, factory_name)
           explicit = explicit_class_option(call_node)
           return explicit if explicit

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

@@ -84,27 +84,20 @@ module Rigor
         @factory_search_paths = Array(config.fetch("factory_search_paths")).map(&:to_s)
       end
 
-      # ADR-102 WD3 / #350 — the model classes the factories build, published as `:reachability_references`
-      # rather than as `:reachability_roots`.
+      # ADR-102 WD3 / #350 — the factories' model classes are published as `:reachability_references`,
+      # not `:reachability_roots`.
       #
-      # Both halves of that sentence are load-bearing.
-      #
-      # It is a CONTRIBUTION at all because a factory names its class by a mechanism the constant scan cannot
-      # follow: `factory :user, class: "Admin::User"` is a string, and a bare `factory :user` is FactoryBot's
-      # own constantization of the factory name. Neither leaves a constant node anywhere in the project.
-      #
-      # It is a REFERENCE rather than a root because factories live in the test tree. Rooting them would make
-      # every factoried class production-reachable and erase ADR-102 WD8's "reachable only from tests"
-      # category for exactly the classes it is most likely to be about — a model kept alive by its factory
-      # and its spec and nothing else is the archetype of dead production code with a live test, and that is
-      # the single most actionable row this report produces. Carrying the `:test` role keeps the finding.
+      # It is a contribution because a factory names its class by a mechanism the constant scan cannot
+      # follow (`factory :user, class: "Admin::User"` is a string; a bare `factory :user` is constantized by
+      # FactoryBot). It is a reference rather than a root because factories live in the test tree: rooting
+      # them would make every factoried class production-reachable and erase ADR-102 WD8's "reachable only
+      # from tests" category. The `:test` role keeps that finding.
       def prepare(services)
         index = producer_value(:factory_index)
         return if index.nil? || index.empty?
 
-        # The producer value and the ADR-9 fact are different channels (#921) — `producer_value` is this
-        # plugin's own cached computation, read back via `producer_value` above; `fact_store.publish` is
-        # what makes it visible to another plugin's `read_fact`, which is how rigor-rspec binds
+        # The producer value and the ADR-9 fact are different channels (#921): `fact_store.publish` is what
+        # makes the index visible to another plugin's `read_fact`, as rigor-rspec uses it to bind
         # `create(:name)` to the factory's model class.
         services.fact_store.publish(plugin_id: manifest.id, name: :factory_index, value: index)
 
@@ -118,8 +111,7 @@ module Rigor
 
       # 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`.
+      # via `diagnostic(node, location:)`.
       node_rule Prism::CallNode do |node, _scope, path|
         index = producer_value(:factory_index)
         next [] if index.nil? || index.empty?

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

@@ -40,7 +40,6 @@ module Rigor
           all_args = call_node.arguments&.arguments || []
           return nil if all_args.empty?
 
-          # Strip trailing keyword options hash if present
           pos_args = all_args.grep_v(Prism::KeywordHashNode)
           return nil if pos_args.empty?
 

data/plugins/rigor-ffi/lib/rigor/plugin/ffi/discoverer.rb

@@ -149,7 +149,6 @@ module Rigor
               end
             end
           when :callback
-            # Issue 4 fix: extract callback definitions
             args = node.arguments&.arguments || []
             if args.size >= 3
               cb_name = Analyzer.extract_symbol(args[0])
@@ -193,7 +192,6 @@ module Rigor
               end
             end
           else
-            # Issue 5 fix: pass mod_name to sub-plugin recognizers
             FFI.binding_recognizers.each do |recognizer|
               facts = recognizer.recognize(node, mod_name)
               Array(facts).each do |fact|

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

@@ -38,17 +38,17 @@ module Rigor
       # Dynamic return rule for attached FFI functions
       # Gated on known FFI library receivers and attached function names
       #
-      # Issue #701 — both receiver kinds are declared because the block below already resolved
-      # `Nominal` and `Singleton` alike: `attach_function` installs the binding on the library module
-      # itself (`MyLib.strlen`) and `include`ing that module makes the same name an instance call, so
-      # neither kind is an accident. The kind-aware gate makes that intent explicit rather than relying
-      # on a `receivers:` entry answering for both.
+      # Issue #701 — both receiver kinds are declared because the block below already resolves `Nominal`
+      # and `Singleton` alike: `attach_function` installs the binding on the library module itself
+      # (`MyLib.strlen`), and `include`ing that module makes the same name an instance call. The
+      # kind-aware gate makes that intent explicit rather than relying on one `receivers:` entry for both.
       dynamic_return receivers: -> { both_receiver_kinds(producer_value(:ffi_catalog)&.libraries) },
                      methods: -> { producer_value(:ffi_catalog)&.function_method_names || [] } do |call_node, scope|
         catalog = producer_value(:ffi_catalog)
         next nil if catalog.nil?
 
-        receiver_type = call_node.receiver ? scope&.type_of(call_node.receiver) : scope&.self_type
+        receiver = call_node.receiver
+        receiver_type = receiver ? scope&.type_of(receiver) : scope&.self_type
         receiver_class = case receiver_type
                          when Rigor::Type::Nominal, Rigor::Type::Singleton then receiver_type.class_name
                          end
@@ -78,7 +78,8 @@ module Rigor
         catalog = producer_value(:ffi_catalog)
         next nil if catalog.nil?
 
-        receiver_type = call_node.receiver ? scope&.type_of(call_node.receiver) : scope&.self_type
+        receiver = call_node.receiver
+        receiver_type = receiver ? scope&.type_of(receiver) : scope&.self_type
         receiver_class = case receiver_type
                          when Rigor::Type::Nominal, Rigor::Type::Singleton then receiver_type.class_name
                          end

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

@@ -85,7 +85,6 @@ module Rigor
             method_names: NAMESPACE_METHODS,
             self_type: "singleton(Grape::API::Instance)"
           ),
-          # `params do ... end` — body `instance_eval`s on a `ParamsScope` instance.
           Rigor::Plugin::Macro::BlockAsMethod.new(
             receiver_constraint: "Grape::API",
             method_names: %i[params],
@@ -121,7 +120,6 @@ module Rigor
             method_names: %i[desc],
             self_type: "Grape::DSL::Desc::ConfigContext"
           ),
-          # Verb bodies run inside `Grape::Endpoint` instances.
           Rigor::Plugin::Macro::BlockAsMethod.new(
             receiver_constraint: "Grape::API",
             method_names: VERB_METHODS,

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

@@ -23,9 +23,8 @@ module Rigor
         }.freeze
 
         # The base class name a Schema::Object subclass MUST inherit from to be recognised. Match is on
-        # the rightmost segment of the superclass constant chain so both `GraphQL::Schema::Object` and
-        # the locally-aliased `BaseObject = GraphQL::Schema::Object` shape work when the alias's RHS is
-        # the canonical path.
+        # the last two segments of the superclass constant chain (see {#schema_subclass?}), so a locally
+        # aliased base such as `BaseObject = GraphQL::Schema::Object` is not followed.
         SCHEMA_OBJECT_TAIL = "Object"
         SCHEMA_ENUM_TAIL = "Enum"
         SCHEMA_INPUT_OBJECT_TAIL = "InputObject"
@@ -183,7 +182,7 @@ module Rigor
         private_class_method :statement_nodes
 
         # Walks every top-level `value "..."` call inside an enum subclass body and returns the value
-        # names as an Array<String>. Both shapes graphql-ruby accepts work:
+        # names. Both shapes graphql-ruby accepts work:
         #
         #     value "ACTIVE"
         #     value "DISABLED", value: :off, description: "..."
@@ -299,7 +298,7 @@ module Rigor
         end
         private_class_method :parse_field_call
 
-        # Resolves the `Type` positional argument to a `{type: "ClassName", list: bool}` tuple.
+        # Resolves the `Type` positional argument to a `type:` class name and a `list:` flag.
         # ArrayNode forms (`[String]` / `[Types::User]`) unwrap the single element and mark `list: true`.
         # Bare constant refs are not lists. Returns nil for unrecognised shapes (string types `"User"`,
         # Proc lazy types, etc.) so callers drop the field.
@@ -350,8 +349,8 @@ module Rigor
         end
         private_class_method :extract_nullability
 
-        # Returns the constant chain as an Array of String segments (`["GraphQL", "Schema", "Object"]`).
-        # Empty array for unrecognised node kinds.
+        # Returns the constant chain's segments, e.g. `["GraphQL", "Schema", "Object"]`. Empty for
+        # unrecognised node kinds.
         def constant_path_segments(node)
           case node
           when Prism::ConstantReadNode then [node.name.to_s]

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

@@ -77,8 +77,18 @@ module Rigor
         signature_paths: ["sig"],
         # ADR-43 WD4 — the classes the bundled sig covers completely enough that a Ruby-source subclass
         # (`class PostType < GraphQL::Schema::Object`) may bridge inherited calls to the RBS ancestor.
-        # Listing one turns on `call.undefined-method`/arity checks for inherited DSL calls on every
-        # subclass — justified here because the sig IS the authority (graphql-ruby ships none).
+        # The bridge is a signature lookup only: an inherited DSL call resolves to the declaration's
+        # return type and block parameters, and a subclass `def` overriding a declared method other
+        # than `initialize` binds its parameters from it (#2681). The subclass itself stays outside
+        # RBS, so no signature-reading call rule fires on a call it makes, declared or not:
+        # `call.undefined-method`, `call.wrong-arity` and `call.argument-type-mismatch` all stay
+        # silent, while the same calls on a listed class AS THE DIRECT RECEIVER still report.
+        # `open_receivers:` is what covers those direct receivers; it is not what silences the
+        # subclass — the receiver gate is (ADR-43 Context § "Amendment 2026-11-15", which withdrew
+        # the claim that the rules follow the resolution). So listing a class here cannot cost a
+        # false positive on a subclass. The risk runs the other way: a declared member that does not exist at runtime makes a genuinely
+        # failing call resolve silently, so the sig must be accurate — it IS the authority
+        # (graphql-ruby ships none).
         rbs_complete_ancestors: %w[
           GraphQL::Schema
           GraphQL::Schema::Member

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

@@ -20,10 +20,8 @@ module Rigor
           @contracts = contracts
         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.
+        # Per-`ClassNode` check over the engine-owned walk (ADR-37): called once per class node by the
+        # `node_rule` in `hanami.rb`, against every contract whose `path_glob` matches the file.
         def check_class(class_node, path:)
           @contracts.filter_map do |contract|
             next unless path_matches?(contract.path_glob, path)

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

@@ -87,11 +87,8 @@ module Rigor
         @protocol_contracts || manifest.protocol_contracts
       end
 
-      # 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.)
+      # ADR-37 — per-class-node validation over the engine-owned walk; `ActionChecker#check_class` holds the
+      # per-class contract logic. The return type is void, so no `scope` query is needed.
       node_rule Prism::ClassNode do |node, _scope, path|
         contracts = protocol_contracts
         next [] if contracts.empty?

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

@@ -51,8 +51,8 @@ module Rigor
     #
     # - `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 is handled via ADR-36 `nested_class_templates:` in
-    #   this plugin's manifest (Slice A — see `nested_class_templates:` block below).
+    # - The `variants do variant Const, Type end` Enum DSL is not part of the unwrap contribution; it is
+    #   synthesised through the ADR-36 `nested_class_templates:` in this plugin's manifest (Slice A).
     class Mangrove < Rigor::Plugin::Base
       manifest(
         id: "mangrove",
@@ -113,7 +113,13 @@ module Rigor
       # 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]`.
+      # #2717 — the rule has no `methods:` gate, so the name gate does not screen it: the engine also offers it
+      # the compound-write nodes (`x.attr op= v`, `x[i] ||= v`, ...) and the `&:symbol` block's
+      # `Prism::BlockArgumentNode`. None of those has `name`, which the rule reads after `receiver`, so decline
+      # anything that is not a `CallNode` rather than raise into the rescue.
       dynamic_return receivers: (RESULT_CARRIERS + OPTION_CARRIERS) do |call_node, scope|
+        next nil unless call_node.is_a?(Prism::CallNode)
+
         receiver = call_node.receiver
         next nil if receiver.nil?