rigortype 0.3.8 → 0.3.9

data/lib/rigor/inference/version_guard.rb

@@ -48,6 +48,8 @@ module Rigor
     #   with the running Ruby**, where "the analyzer's Ruby is the target's Ruby" already covers them.
     #   A third-party gem's `VERSION` is not read: its version is the project's `Gemfile.lock`'s to say,
     #   and the lockfile is not visible from the inference layer.
+    # * The ROOTED spelling of any of the above — `::RUBY_VERSION`, `::RUBY_ENGINE`, `::Psych::VERSION` —
+    #   names the same constant as its bare twin and folds identically; see {.read_constant}.
     # * `RUBY_PLATFORM` — **never** folded. Every comparison against it is by construction
     #   platform-dependent, and the machine running `rigor` need not be the machine running the program.
     # * `<=>` — never folded (it yields -1/0/1, not a branch verdict), and neither are `defined?(Ractor)`
@@ -68,7 +70,7 @@ module Rigor
 
       # Predefined constants read from the analyzer's runtime, mapped to the operand kind they produce.
       # `:string` operands accept every comparison; `:engine` operands accept equality only.
-      PREDEFINED = { RUBY_VERSION: :string, RUBY_ENGINE: :engine }.freeze
+      PREDEFINED = { "RUBY_VERSION" => :string, "RUBY_ENGINE" => :engine }.freeze
       private_constant :PREDEFINED
 
       # Operand kinds that carry a plain Ruby String, i.e. the ones `Gem::Version.new` may wrap and the
@@ -88,8 +90,8 @@ module Rigor
       GEM_VERSION_PATH = "Gem::Version"
       private_constant :GEM_VERSION_PATH
 
-      # @param node [Prism::Node, nil] an `if` / `unless` predicate
-      # @return [Symbol, nil] `:truthy` / `:falsey` when the guard is decidable on the analyzer's Ruby,
+      # @param node — an `if` / `unless` predicate
+      # @return `:truthy` / `:falsey` when the guard is decidable on the analyzer's Ruby,
       #   otherwise nil (both arms stay live)
       def verdict(node)
         return nil unless node.is_a?(Prism::CallNode)
@@ -109,35 +111,40 @@ module Rigor
       end
 
       # Reads one side of the comparison into `[kind, value]`, or nil when it is not readable.
-      #
-      # @return [Array(Symbol, Object), nil]
       def read_operand(node)
         case node
         when Prism::StringNode then [:literal_string, node.unescaped]
-        when Prism::ConstantReadNode then read_predefined(node)
-        when Prism::ConstantPathNode then read_version_constant(node)
+        when Prism::ConstantReadNode, Prism::ConstantPathNode then read_constant(node)
         when Prism::CallNode then read_gem_version(node)
         end
       end
       private_class_method :read_operand
 
-      def read_predefined(node)
-        kind = PREDEFINED[node.name]
-        return nil unless kind
-
-        value = runtime_value(node.name.to_s)
-        value && [kind, value]
-      end
-      private_class_method :read_predefined
-
-      def read_version_constant(node)
+      # Dispatches on the RESOLVED name rather than on the node class. `::RUBY_VERSION` names the very
+      # constant `RUBY_VERSION` names — the leading `::` only makes the top-level lookup explicit — but
+      # Prism spells it as a `ConstantPathNode` with a nil parent, so a node-class dispatch sent it down
+      # the `X::VERSION` path and declined it for not being a curated qualified name. The same program
+      # then had two diagnostic sets for two spellings of one guard
+      # ([#877](https://github.com/rigortype/rigor/issues/877)).
+      #
+      # The foldable set is unchanged and stays closed: an unqualified name folds only when it is one of
+      # {PREDEFINED}, a qualified one only when it is in {VERSION_CONSTANTS}.
+      def read_constant(node)
         path = Source::ConstantPath.qualified_name_or_nil(node)
-        return nil unless path && VERSION_CONSTANTS.include?(path)
+        return nil unless path
+
+        kind =
+          if path.include?("::")
+            :string if VERSION_CONSTANTS.include?(path)
+          else
+            PREDEFINED[path]
+          end
+        return nil unless kind
 
         value = runtime_value(path)
-        value && [:string, value]
+        value && [kind, value]
       end
-      private_class_method :read_version_constant
+      private_class_method :read_constant
 
       # `Gem::Version.new(<readable>)`. The inner operand must be a plain version String — an engine name
       # is not a version, and `Gem::Version.new` raises on anything `Gem::Version.correct?` rejects, so a
@@ -165,7 +172,7 @@ module Rigor
       # `const_get` would execute the target file inside the analyzer. `Module#autoload?` is what
       # separates the two ([#680](https://github.com/rigortype/rigor/issues/680)).
       #
-      # @return [String, nil] the constant's value when it is a non-empty String
+      # @return the constant's value when it is a non-empty String
       def runtime_value(path)
         mod = ::Object
         path.split("::").each do |part|

data/lib/rigor/inference/void_origin.rb

@@ -9,11 +9,11 @@ module Rigor
     # consistency, normalization, or erasure.
     #
     # @!attribute class_name
-    #   @return [String] the receiver class whose method declared `-> void`.
+    #   @return the receiver class whose method declared `-> void`.
     # @!attribute method_name
-    #   @return [Symbol] the method whose return was recovered.
+    #   @return the method whose return was recovered.
     # @!attribute kind
-    #   @return [Symbol] `:instance` or `:singleton`.
+    #   @return `:instance` or `:singleton`.
     VoidOrigin = Data.define(:class_name, :method_name, :kind) do
       # A human-facing `Class#method` / `Class.method` label for the diagnostic message.
       def label

data/lib/rigor/inference/void_tail_summary.rb

@@ -75,10 +75,8 @@ module Rigor
       # consult; the memo persists across consults for the run. The memo is probed before the visited
       # set is allocated so the common post-warmup hit path allocates nothing.
       #
-      # @param def_node [Prism::DefNode]
-      # @param owner [String] the qualified receiver class the `def` belongs to.
-      # @param kind [Symbol] `:instance` or `:singleton`.
-      # @return [Inference::VoidOrigin, nil]
+      # @param owner — the qualified receiver class the `def` belongs to.
+      # @param kind — `:instance` or `:singleton`.
       def origin_for(def_node, owner, kind)
         return nil if def_node.nil?
 

data/lib/rigor/language_server/buffer_table.rb

@@ -51,7 +51,7 @@ module Rigor
       # computed from the stale text would be wrong. Consumers check {#desynchronized?} and decline to answer
       # rather than answering wrongly; the mark clears on the next `didOpen` or full-text change.
       #
-      # @return [Boolean] true when the changes were applied.
+      # @return true when the changes were applied.
       def apply_changes(uri:, changes:, version:)
         text = IncrementalSync.apply_all(@entries[uri]&.bytes, changes)
         @desynchronized.delete(uri)
@@ -63,13 +63,13 @@ module Rigor
         false
       end
 
-      # @return [Boolean] true when the last `didChange` for `uri` could not be applied, so the held text no
+      # @return true when the last `didChange` for `uri` could not be applied, so the held text no
       #   longer matches the editor's.
       def desynchronized?(uri)
         @desynchronized.key?(uri)
       end
 
-      # @return [String, nil] why `uri` is desynchronised, for the log line; nil when it is in sync.
+      # @return why `uri` is desynchronised, for the log line; nil when it is in sync.
       def desynchronization_reason(uri)
         @desynchronized[uri]
       end
@@ -91,7 +91,7 @@ module Rigor
         @dirty.delete(uri)
       end
 
-      # @return [Boolean] true when `uri` has unsaved changes. A buffer that is dirty may only be published
+      # @return true when `uri` has unsaved changes. A buffer that is dirty may only be published
       #   from an analysis that bound ITS bytes — see the publish-set invariant in
       #   `docs/design/20260517-language-server.md`.
       def dirty?(uri)

data/lib/rigor/language_server/completion_provider.rb

@@ -42,7 +42,7 @@ module Rigor
         @project_context = project_context
       end
 
-      # @return [Array<Hash>, nil] LSP `CompletionItem[]` or nil
+      # @return LSP `CompletionItem[]` or nil
       #   when the cursor isn't at a position the provider can
       #   enumerate completions for. Returning nil maps to
       #   `result: null` per the LSP spec — clients treat it as

data/lib/rigor/language_server/debouncer.rb

@@ -68,7 +68,7 @@ module Rigor
         end
       end
 
-      # @return [Integer] number of currently-pending tasks.
+      # @return number of currently-pending tasks.
       def pending_size
         @mutex.synchronize { @tasks.size }
       end

data/lib/rigor/language_server/diagnostic_publisher.rb

@@ -30,13 +30,13 @@ module Rigor
         hint: 4
       }.freeze
 
-      # @param debouncer [Rigor::LanguageServer::Debouncer, nil]
+      # @param debouncer —
       #   when present, `publish_for` schedules its work through
       #   the debouncer (cancels prior pending task for the same
       #   URI, fires after `debounce_seconds` quiet-time). Nil
       #   keeps the slice 4-7 synchronous behaviour — primarily
       #   useful for specs.
-      # @param debounce_seconds [Numeric] quiet-time before the
+      # @param debounce_seconds — quiet-time before the
       #   debounced publish fires. 0 with a debouncer means
       #   "schedule on next-tick" (still async); without a
       #   debouncer the value is unused.
@@ -212,7 +212,7 @@ module Rigor
         notify(uri, diagnostics)
       end
 
-      # @return [Hash, nil] `{ uri:, path:, bytes: }` when `uri` is eligible for the batch, or nil to
+      # @return `{ uri:, path:, bytes: }` when `uri` is eligible for the batch, or nil to
       #   exclude it. Mirrors `#run_and_notify`'s own guards: a buffer closed during the debounce window is
       #   dropped silently (its didClose empty publish already cleared the markers); a desynchronised buffer
       #   publishes an EMPTY set immediately (same as the single-buffer path) rather than joining the batch.
@@ -320,7 +320,7 @@ module Rigor
         end
       end
 
-      # @return [Hash, nil] the LSP `Diagnostic` Hash, or nil to
+      # @return the LSP `Diagnostic` Hash, or nil to
       #   skip diagnostics outside the buffer's own path (e.g.
       #   `.rigor.yml`-anchored info diagnostics get filtered —
       #   they belong to the project, not the buffer).

data/lib/rigor/language_server/document_symbol_provider.rb

@@ -30,7 +30,7 @@ module Rigor
         @project_context = project_context
       end
 
-      # @return [Array<Hash>, nil] LSP `DocumentSymbol[]` for the
+      # @return LSP `DocumentSymbol[]` for the
       #   buffer at `uri`. Returns nil when the URI isn't open or
       #   doesn't parse cleanly enough to surface symbols — LSP
       #   clients fall back to no-outline in that case.

data/lib/rigor/language_server/folding_range_provider.rb

@@ -23,7 +23,7 @@ module Rigor
         @project_context = project_context
       end
 
-      # @return [Array<Hash>, nil] LSP `FoldingRange[]` for the
+      # @return LSP `FoldingRange[]` for the
       #   buffer, or nil when the URI isn't open / parseable.
       def provide(uri)
         path, entry = buffer_for(uri)

data/lib/rigor/language_server/hover_provider.rb

@@ -29,7 +29,7 @@ module Rigor
         @renderer = renderer
       end
 
-      # @return [Hash, nil] an LSP `Hover` payload or nil when no
+      # @return an LSP `Hover` payload or nil when no
       #   expression sits at the queried position. Returning nil
       #   maps to `result: null` per the LSP spec — clients
       #   suppress the hover popup in that case.

data/lib/rigor/language_server/hover_renderer.rb

@@ -13,7 +13,7 @@ module Rigor
     # (method call, constant, local, ivar, literal) gets the most relevant type-aware presentation per
     # `docs/design/20260517-lsp-hover-completion.md`.
     class HoverRenderer
-      # @param node_scope_lookup [#[]] node-to-scope table built by `ScopeIndexer.index`. The renderer indexes
+      # @param node_scope_lookup — node-to-scope table built by `ScopeIndexer.index`. The renderer indexes
       #   into it to retrieve the receiver's narrow scope when specialising on `CallNode`. The lookup never
       #   returns nil (the indexer's Hash carries `default_scope` as its default value), so the renderer trusts
       #   the lookup result.
@@ -83,7 +83,7 @@ module Rigor
         )
       end
 
-      # @return [[RBS::Definition::Method, String, Symbol], nil] the resolved method definition, the receiver
+      # @return , nil] the resolved method definition, the receiver
       #   class name, and the dispatch kind (`:instance` or `:singleton`); nil when the receiver shape isn't
       #   yet supported or the method doesn't resolve through the RBS env.
       def lookup_method(receiver_type, method_name, scope)

data/lib/rigor/language_server/incremental_sync.rb

@@ -46,10 +46,10 @@ module Rigor
       # Applies every change in order, each against the result of the previous — the LSP contract for a
       # multi-change `didChange` notification.
       #
-      # @param text [String, nil] the held buffer text; nil when no buffer is open for the URI.
-      # @param changes [Array<Hash>] the `contentChanges` array.
-      # @return [String] the new buffer text.
-      # @raise [UnappliableChange] if any change cannot be applied.
+      # @param text — the held buffer text; nil when no buffer is open for the URI.
+      # @param changes — the `contentChanges` array.
+      # @return the new buffer text.
+      # @raise UnappliableChange — if any change cannot be applied.
       def apply_all(text, changes)
         raise UnappliableChange, "contentChanges must be an Array, got #{changes.class}" unless changes.is_a?(Array)
 
@@ -64,7 +64,7 @@ module Rigor
       # companion to `range` and is accepted-but-ignored: it is redundant with `range`, historically ambiguous
       # about its units, and `range` is the authoritative field.
       #
-      # @raise [UnappliableChange]
+      # @raise UnappliableChange
       def apply(text, change)
         raise UnappliableChange, "contentChanges entry must be a Hash, got #{change.class}" unless change.is_a?(Hash)
 
@@ -95,7 +95,7 @@ module Rigor
         raise UnappliableChange, "held text is not valid UTF-8: #{e.message}"
       end
 
-      # @return [Array<Array(Integer, Integer)>] one `[content_start, content_end]` pair per line, in Ruby
+      # @return one `[content_start, content_end]` pair per line, in Ruby
       #   character indices. `content_end` excludes the line terminator, so it doubles as the clamp target for
       #   an over-long `character`. A trailing terminator yields a final empty span — the virtual last line an
       #   editor puts the cursor on, and the anchor for an end-of-document insert.

data/lib/rigor/language_server/project_context.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "../environment"
+require_relative "../project_environment"
 require_relative "../cache/store"
 require_relative "../analysis/runner"
 require_relative "../analysis/incremental_session"
@@ -74,11 +75,7 @@ module Rigor
           dependency_source_index: project_scan.dependency_source_index,
           synthetic_method_index: project_scan.synthetic_method_index,
           project_patched_methods: project_scan.project_patched_methods,
-          bundler_bundle_path: @configuration.bundler_bundle_path,
-          bundler_auto_detect: @configuration.bundler_auto_detect,
-          bundler_lockfile: @configuration.bundler_lockfile,
-          rbs_collection_lockfile: @configuration.rbs_collection_lockfile,
-          rbs_collection_auto_detect: @configuration.rbs_collection_auto_detect
+          **ProjectEnvironment.dependency_discovery_options(@configuration)
         )
       end
 

data/lib/rigor/language_server/publish_batcher.rb

@@ -15,10 +15,10 @@ module Rigor
     # dropped. The same claim/consume shape `DiagnosticPublisher#run_project_round` already uses for the
     # whole-project save round (#246), generalised to an arbitrary key type and an arbitrary batch action.
     class PublishBatcher
-      # @param on_batch [#call] `(keys) -> void`, called with the deduplicated Array of keys pending at the
+      # @param on_batch — `(keys) -> void`, called with the deduplicated Array of keys pending at the
       #   start of one round. May be called more than once in a row when keys keep arriving while a round
       #   runs.
-      # @param on_error [#call, nil] `(exception) -> void`, called when `on_batch` raises. A round must
+      # @param on_error — `(exception) -> void`, called when `on_batch` raises. A round must
       #   never wedge the coalescing lock for every future `#enqueue` call — ownership is always released
       #   before this fires. Whatever was mid-flight when the round raised is lost; anything enqueued by a
       #   concurrent `#enqueue` call after this round's drain but before the rescue stays pending and rides

data/lib/rigor/language_server/selection_range_provider.rb

@@ -20,9 +20,9 @@ module Rigor
         @project_context = project_context
       end
 
-      # @param positions [Array<Hash>] LSP `Position[]` — each
+      # @param positions — LSP `Position[]` — each
       #   `{ line:, character: }` 0-based.
-      # @return [Array<Hash>, nil] one `SelectionRange` per
+      # @return one `SelectionRange` per
       #   position, or nil when the URI / buffer isn't resolvable.
       def provide(uri, positions)
         path, entry = buffer_for(uri)

data/lib/rigor/language_server/server.rb

@@ -42,11 +42,11 @@ module Rigor
                   :signature_help_provider, :folding_range_provider,
                   :selection_range_provider, :project_context
 
-      # @param completion_provider [Rigor::LanguageServer::CompletionProvider, nil]
+      # @param completion_provider —
       #   resolves `textDocument/completion`. Nil → `MethodNotFound`.
-      # @param signature_help_provider [Rigor::LanguageServer::SignatureHelpProvider, nil]
+      # @param signature_help_provider —
       #   resolves `textDocument/signatureHelp`. Nil → `MethodNotFound`.
-      # @param project_context [Rigor::LanguageServer::ProjectContext, nil] the per-session cache of
+      # @param project_context — the per-session cache of
       #   `Environment` + `Cache::Store` the providers read on every request. When present,
       #   `workspace/didChangeWatchedFiles` and `workspace/didChangeConfiguration` invalidate the cache; nil
       #   means "no project context": each request rebuilds env from scratch (mainly for specs and backward
@@ -69,7 +69,7 @@ module Rigor
         @project_context = project_context
       end
 
-      # @return [Boolean] true once the client has called `exit` and
+      # @return true once the client has called `exit` and
       #   the server has set its terminal exit code. The CLI loop
       #   reads this between dispatches to know when to stop.
       def exited?
@@ -78,10 +78,10 @@ module Rigor
 
       # Routes one LSP method call.
       #
-      # @param method [String] the LSP method name (e.g. "initialize").
-      # @param params [Hash, nil] the LSP `params` payload (Hash for
+      # @param method — the LSP method name (e.g. "initialize").
+      # @param params — the LSP `params` payload (Hash for
       #   request / notification methods; nil for the empty case).
-      # @return [Hash, nil] one of:
+      # @return one of:
       #   - the response result Hash for request methods,
       #   - nil for notification methods,
       #   - { error: { code:, message: } } for state / shape errors.
@@ -191,8 +191,8 @@ module Rigor
         caps
       end
 
-      # `initialized` is a notification — no response body. Slice 7 will hook this to register
-      # `workspace/didChangeWatchedFiles` if the client advertised the capability.
+      # `initialized` is a notification — no response body. Nothing is registered here yet: the server handles
+      # `workspace/didChangeWatchedFiles` when a client sends it, but does not register for it dynamically.
       def handle_initialized
         nil
       end

data/lib/rigor/language_server/signature_help_provider.rb

@@ -44,7 +44,7 @@ module Rigor
         @project_context = project_context
       end
 
-      # @return [Hash, nil] LSP `SignatureHelp` payload or nil
+      # @return LSP `SignatureHelp` payload or nil
       #   when the cursor isn't inside a resolvable method call.
       def provide(uri:, line:, character:, context: nil)
         _ = context # Trigger info accepted but not routed in v1.

data/lib/rigor/language_server/uri.rb

@@ -14,7 +14,7 @@ module Rigor
       FILE_SCHEME = "file://"
       private_constant :FILE_SCHEME
 
-      # @return [String, nil] absolute filesystem path for a
+      # @return absolute filesystem path for a
       #   `file://` URI, or nil for unsupported schemes.
       def to_path(uri)
         return nil unless uri.is_a?(String) && uri.start_with?(FILE_SCHEME)

data/lib/rigor/plugin/base.rb

@@ -40,6 +40,13 @@ module Rigor
     #
     #   Rigor::Plugin.register(MyRailsPlugin)
     class Base # rubocop:disable Metrics/ClassLength
+      # Issue #701 — the kind wrapper a `dynamic_return receivers:` entry may carry, spelled as RBS spells a
+      # class object and as the `call.undefined-method` message prints one, so an author writes the gate the
+      # way the diagnostic they are answering names the receiver. Declared on the class rather than inside
+      # `class << self` because both the load-time validator and the per-dispatch gate read it.
+      SINGLETON_RECEIVER_PATTERN = /\Asingleton\((.+)\)\z/
+      private_constant :SINGLETON_RECEIVER_PATTERN
+
       class << self
         # Declares the plugin's manifest. Called once at class definition time — the resulting {Manifest} is
         # cached on the class so {Rigor::Plugin::Loader} reads it without constructing the plugin.
@@ -241,8 +248,21 @@ module Rigor
         #   end
         #
         # `receivers:` is a non-empty Array of class names; the engine calls the block only when the call's
-        # receiver type's class equals or inherits from one of them (via `Environment#class_ordering`). It
-        # MAY be omitted — then the rule is receiver-independent and fires on `methods:` alone.
+        # receiver type's class equals or inherits from one of them (via `Environment#class_ordering`) AND
+        # is of the kind the entry names. It MAY be omitted — then the rule is receiver-independent and
+        # fires on `methods:` alone.
+        #
+        # Issue #701 — an entry carries the receiver KIND in RBS's own spelling. `"Widget"` matches an
+        # INSTANCE receiver; `"singleton(Widget)"` matches the class object itself; a rule that wants both
+        # lists both:
+        #
+        #   dynamic_return receivers: ["Widget"], methods: [:price]                  # Widget#price
+        #   dynamic_return receivers: ["singleton(Widget)"], methods: [:build]       # Widget.build
+        #   dynamic_return receivers: ["Widget", "singleton(Widget)"]                # either
+        #
+        # An instance rule that also answered on the class typed a call the plugin never modelled, and since
+        # #653 a plugin's answer suppresses `call.undefined-method` — so the class-level miss went silent on
+        # the say-so of a rule written for the instance.
         #
         # `methods:` is an Array of Symbol method names. When provided, the block is skipped unless
         # `call_node.name` is in the list — declarative and cheaper than an in-block guard (the engine
@@ -261,6 +281,9 @@ module Rigor
         #     # found; the block does the precise per-call lookup
         #   end
         #
+        # A callable's entries carry the kind the same way — `-> { names.map { "singleton(#{_1})" } }` for a
+        # discovered set of class-level receivers.
+        #
         # The callable runs through `instance_exec`, so it reads the plugin's own `#prepare`-built indexes.
         # It MUST be idempotent and post-`#prepare`-safe — reference a lazily-built / memoised index (as
         # activestorage's `attachment_index` and activerecord's `model_index` are), never a value captured at
@@ -376,11 +399,23 @@ module Rigor
           # ADR-52 slice 3 — a run-time callable is resolved per instance after `#prepare`; its shape is
           # checked at resolution time.
           return if receivers.respond_to?(:call)
-          return if receivers.is_a?(Array) && !receivers.empty? && receivers.all? { |r| r.is_a?(String) && !r.empty? }
+          return if receivers.is_a?(Array) && !receivers.empty? &&
+                    receivers.all? { |r| valid_dynamic_return_receiver?(r) }
 
           raise ArgumentError,
                 "Plugin::Base.dynamic_return receivers: must be a non-empty Array of class-name Strings " \
-                "or a callable, got #{receivers.inspect}"
+                "(\"Foo\" for an instance receiver, \"singleton(Foo)\" for the class itself) or a " \
+                "callable, got #{receivers.inspect}"
+        end
+
+        # Issue #701 — the entry grammar: a non-empty class name, optionally wrapped in RBS's own
+        # `singleton(...)`. A bare `singleton()` is rejected rather than read as a class literally named
+        # that, so a typo in the kind wrapper fails at load instead of never matching.
+        def valid_dynamic_return_receiver?(entry)
+          return false unless entry.is_a?(String) && !entry.empty?
+          return SINGLETON_RECEIVER_PATTERN.match?(entry) if entry.start_with?("singleton(")
+
+          true
         end
 
         def validate_dynamic_return_methods!(methods)
@@ -397,7 +432,8 @@ module Rigor
         end
 
         private :validate_dynamic_return_gate!, :validate_dynamic_return_receivers!,
-                :validate_dynamic_return_methods!, :validate_dynamic_return_file_methods!
+                :validate_dynamic_return_methods!, :validate_dynamic_return_file_methods!,
+                :valid_dynamic_return_receiver?
 
         # ADR-37 slice 2 — declares a predicate/assertion narrowing contribution, method-gated. The narrow
         # successor to the `post_return_facts` slot of the deleted `flow_contribution_for` hook (ADR-52 WD3):
@@ -545,19 +581,15 @@ module Rigor
 
       # ADR-37 slice 2 — the return type contributed by this plugin's {.dynamic_return} rules for a call, or
       # nil. The engine calls this from `MethodDispatcher`; a rule fires only when `receiver_type`'s class
-      # equals or inherits from one of its declared `receivers:`. First non-nil wins (declaration order).
-      # Failures isolate to nil.
+      # equals or inherits from one of its declared `receivers:` AND is of that entry's kind (#701). First
+      # non-nil wins (declaration order). Failures isolate to nil.
       def dynamic_return_type(call_node:, scope:, receiver_type:)
         rules = self.class.dynamic_returns
         return nil if rules.empty? || receiver_type.nil?
 
-        # `class_name` is nil for a receiver carrier with no nominal class (a refinement dimension, an
-        # inferred shape) — fine for a receiver-less (methods-only) rule (ADR-52 WD2), which gates on the
-        # method name alone and reads the receiver shape inside its own block.
-        class_name = dynamic_return_receiver_class_name(receiver_type)
         environment = scope&.environment
         rules.each do |rule|
-          next unless dynamic_return_rule_applies?(rule, call_node, class_name, environment, scope)
+          next unless dynamic_return_rule_applies?(rule, call_node, receiver_type, environment, scope)
 
           result = instance_exec(call_node, scope, &rule[:block])
           return result if result
@@ -803,10 +835,9 @@ module Rigor
       # survives only as the building block for the rare producer that needs `FileEntry` rows directly;
       # plugin code calls `watch:`.
       #
-      # @param roots    [Array<String>] search roots (relative to the project root, or absolute paths)
-      # @param patterns [Array<String>] glob suffixes joined under each root via `File.join(root, pattern)`.
+      # @param roots — search roots (relative to the project root, or absolute paths)
+      # @param patterns — glob suffixes joined under each root via `File.join(root, pattern)`.
       #   Multiple patterns union into one descriptor (`"**/*.erb", "**/*.html"` etc.).
-      # @return [Rigor::Cache::Descriptor]
       def glob_descriptor(roots, *patterns)
         files = collect_glob_files(Array(roots), patterns)
         entries = files.map do |path|
@@ -836,7 +867,9 @@ module Rigor
 
       # ADR-37 slice 2 — the class name to match a `dynamic_return` `receivers:` entry against, from a
       # receiver `Type`. Covers the instance (`Nominal[X]`) and class (`Singleton[X]`) shapes; other carriers
-      # decline (nil → no match).
+      # decline (nil → no match). Which of the two KINDS the name is then matched as is
+      # {#dynamic_return_receiver_matches?}'s question — the `Result` / `Maybe` carriers are instances of
+      # their class, like `Nominal`.
       def dynamic_return_receiver_class_name(receiver_type)
         case receiver_type
         when Rigor::Type::Nominal, Rigor::Type::Singleton then receiver_type.class_name
@@ -848,7 +881,7 @@ module Rigor
       # The gate for one `dynamic_return` rule. Method-name gate first — a Symbol-array probe vs the receiver
       # ancestry resolution below (ADR-52 WD1); both are pure predicates, so order only affects cost. A
       # receiver-less rule (ADR-52 WD2) skips the ancestry check entirely and fires on the method name alone.
-      def dynamic_return_rule_applies?(rule, call_node, class_name, environment, scope)
+      def dynamic_return_rule_applies?(rule, call_node, receiver_type, environment, scope)
         return false if rule[:methods] && !resolved_dynamic_return_methods(rule).include?(call_node.name)
 
         if rule[:file_methods]
@@ -858,11 +891,29 @@ module Rigor
           return false unless resolved_dynamic_return_file_methods(rule, path).include?(call_node.name)
         end
 
-        receivers = resolved_dynamic_return_receivers(rule)
-        return true if receivers.nil?
+        entries = resolved_dynamic_return_receiver_entries(rule)
+        return true if entries.nil?
+
+        dynamic_return_receiver_matches?(entries, receiver_type, environment)
+      end
+
+      # Issue #701 — the receiver gate, kind included. An entry written for an instance (`"Widget"`) must not
+      # answer for the class object: the block was never given the class-level call to model, and since #653
+      # its answer would suppress that call's `call.undefined-method`, hiding a genuine miss on the plugin's
+      # say-so. A rule that wants the class object declares `"singleton(Widget)"`, and one that wants both
+      # lists both.
+      #
+      # A nil class name is a carrier with no nominal class (a refinement dimension, an inferred shape); a
+      # receiver-gated rule cannot speak about it and declines. A receiver-less rule (ADR-52 WD2) never
+      # reaches here.
+      def dynamic_return_receiver_matches?(entries, receiver_type, environment)
+        class_name = dynamic_return_receiver_class_name(receiver_type)
         return false if class_name.nil?
 
-        receivers.any? { |c| class_matches_receiver?(class_name, c, environment) }
+        singleton = receiver_type.is_a?(Rigor::Type::Singleton)
+        entries.any? do |name, singleton_entry|
+          singleton_entry == singleton && class_matches_receiver?(class_name, name, environment)
+        end
       end
 
       # ADR-52 slice 4 — the rule's method-name set. A static Array is returned as-is (`#include?` over
@@ -910,6 +961,24 @@ module Rigor
           Array(instance_exec(&receivers)).map { |c| c.to_s.dup.freeze }.freeze
       end
 
+      # Issue #701 — the resolved `receivers:` entries as `[class_name, singleton?]` pairs, or nil for a
+      # receiver-less rule. Memoised per rule beside the callable resolution above, so the kind is parsed
+      # once per run rather than once per dispatch (this sits on the per-dispatch plugin path).
+      def resolved_dynamic_return_receiver_entries(rule)
+        receivers = resolved_dynamic_return_receivers(rule)
+        return nil if receivers.nil?
+
+        (@dynamic_return_runtime_cache ||= {})[[:receiver_entries, rule]] ||=
+          receivers.map { |entry| parse_dynamic_return_receiver(entry) }.freeze
+      end
+
+      def parse_dynamic_return_receiver(entry)
+        match = SINGLETON_RECEIVER_PATTERN.match(entry)
+        return [match[1].freeze, true].freeze if match
+
+        [entry, false].freeze
+      end
+
       # True when `class_name` equals or inherits from `constraint`, matched through
       # `Environment#class_ordering` (the mechanism `MacroBlockSelfType` / `additional_initializers` use).
       # Degrades to "no match" on any resolution failure (false-positive-safe).
@@ -976,7 +1045,7 @@ module Rigor
         Cache::Descriptor.new(
           files: boundary.files,
           configs: boundary.configs,
-          globs: watch_glob_entries(producer[:watch])
+          globs: (watch_glob_entries(producer[:watch]) + boundary.globs).uniq
         )
       end