rigortype 0.4.1 → 0.4.3

data/plugins/rigor-ac-library-rb/sig/ac_library_rb/segtree.rbs

@@ -0,0 +1,83 @@
+module AcLibraryRb
+  # A segment tree over the monoid `(S, op, e)`.
+  class Segtree[S]
+    attr_reader d: Array[S]
+    attr_reader op: _Call2[S, S, S]
+    attr_reader n: Integer
+    attr_reader leaf_size: Integer
+    attr_reader log: Integer
+
+    def initialize: (Array[S] | Integer v, S e) { (S, S) -> S } -> void
+                  | (Array[S] | Integer v, _Call2[S, S, S] op, S e) -> void
+
+    def set: (Integer pos, S x) -> void
+    alias []= set
+
+    def get: (Integer pos) -> S
+    alias [] get
+
+    def prod: (Integer l, Integer r) -> S
+            | (Range[Integer] range) -> S
+
+    def all_prod: () -> S
+
+    def max_right: (Integer l) { (S) -> boolish } -> Integer
+
+    def min_left: (Integer r) { (S) -> boolish } -> Integer
+
+    def update: (Integer k) -> S
+  end
+
+  class SegTree = Segtree
+
+  # A lazy segment tree over the monoid `(S, op, e)` acted on by the maps `(F, composition, id)`, where
+  # `mapping.call(f, x)` applies `f` to `x` and `composition.call(f, g)` is `f` after `g`.
+  class LazySegtree[S, F]
+    attr_reader d: Array[S]
+    attr_reader lz: Array[F]
+    attr_reader e: S
+    attr_reader id: F
+    attr_accessor op: _Call2[S, S, S]
+    attr_accessor mapping: _Call2[F, S, S]?
+    attr_accessor composition: _Call2[F, F, F]?
+
+    # The first form is chosen when the second argument is a `Proc`.
+    def initialize: (Array[S] | Integer v, ^(S, S) -> S op, S e, _Call2[F, S, S] mapping,
+                     _Call2[F, F, F] composition, F id) -> void
+                  | (Array[S] | Integer v, S e, F id, ?_Call2[S, S, S]? op, ?_Call2[F, S, S]? mapping,
+                     ?_Call2[F, F, F]? composition) ?{ (S, S) -> S } -> void
+
+    def set_mapping: () { (F, S) -> S } -> Proc
+
+    def set_composition: () { (F, F) -> F } -> Proc
+
+    def set: (Integer pos, S x) -> void
+    alias []= set
+
+    def get: (Integer pos) -> S
+    alias [] get
+
+    def prod: (Integer l, Integer r) -> S
+            | (Range[Integer] range) -> S
+
+    def all_prod: () -> S
+
+    def apply: (Integer pos, F f) -> void
+             | (Integer l, Integer r, F f) -> void
+             | (Range[Integer] range, F f) -> void
+
+    def range_apply: (Integer l, Integer r, F f) -> void
+
+    def max_right: (Integer l) { (S) -> boolish } -> Integer
+
+    def min_left: (Integer r) { (S) -> boolish } -> Integer
+
+    def update: (Integer k) -> S
+
+    def all_apply: (Integer k, F f) -> void
+
+    def push: (Integer k) -> void
+  end
+
+  class LazySegTree = LazySegtree
+end

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

@@ -309,8 +309,9 @@ module Rigor
           args
         end
 
+        # The name is interned later (`filter_name.to_sym`), so a name no Symbol can hold reads as nil.
         def literal_symbol_or_string(node)
-          Rigor::Source::Literals.symbol_or_string_name(node)
+          Rigor::Source::Literals.symbol_or_string(node)&.to_s
         end
 
         def filter_lookup_violation(call_node, arg_node, filter_name, methods, spell_checker, ambiguous_filters:)

data/plugins/rigor-active-model-serializers/lib/rigor/plugin/active_model_serializers/serializer_discoverer.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "rigor/source/node_children"
+require "rigor/source/symbol_name"
 
 require "prism"
 
@@ -81,11 +82,16 @@ module Rigor
         # fixed point rather than recursing keeps a cyclic `class A < B; class B < A` source — which Ruby
         # rejects but a static parse can still be handed — from recursing forever.
         def close_over_roots(candidates)
-          by_name = candidates.to_h { |entry| [entry.class_name, entry] }
+          groups = candidates.group_by(&:class_name)
+          # Files that name different superclasses for one class are a TypeError in Ruby, so no ancestry
+          # reading of that class is correct. It is declined outright, and so is everything beneath it.
+          conflicted = groups.filter_map { |name, group| name if group.map(&:superclass_name).uniq.size > 1 }.to_set
+          by_name = groups.except(*conflicted).transform_values { |group| merge_reopened(group) }
           reached = @base_classes.to_set
           loop do
             grown = candidates.select do |entry|
-              !reached.include?(entry.class_name) && reached.include?(entry.superclass_name)
+              !conflicted.include?(entry.class_name) && !reached.include?(entry.class_name) &&
+                reached.include?(entry.superclass_name)
             end
             break if grown.empty?
 
@@ -94,6 +100,21 @@ module Rigor
           reached.filter_map { |name| by_name[name] }
         end
 
+        # A class declared in several files that each name its superclass is one class to Ruby, so its names
+        # are the union of every file's. Keeping only the last file's entry let a sibling that declared nothing
+        # usable shadow the valid one. The `own_method_names` union assumes every reopening file is loaded; a
+        # file Zeitwerk shadows is not modelled. A superclass-less reopening is not a candidate (see visit_class).
+        def merge_reopened(entries)
+          return entries.first if entries.size == 1
+
+          first = entries.first
+          first.with(
+            declared_names: entries.flat_map(&:declared_names).uniq.sort.freeze,
+            object_reads: entries.flat_map(&:object_reads).uniq.sort.freeze,
+            own_method_names: entries.flat_map(&:own_method_names).uniq.sort.freeze
+          )
+        end
+
         def read_safely(path)
           @io_boundary.read_file(path)
         rescue Plugin::AccessDeniedError, Errno::ENOENT
@@ -180,9 +201,14 @@ module Rigor
             receiver.arguments.nil?
         end
 
+        # A name whose bytes no Symbol can hold (`attributes :"\xff"` in a file that does not parse cleanly)
+        # is dropped here, so it never reaches the index or the `project_defines?` lookup that would raise.
+        # The file's other names are kept: a recoverable syntax error elsewhere in it does not void them.
         def symbol_arguments(node)
           (node.arguments&.arguments || []).filter_map do |argument|
-            argument.unescaped if argument.is_a?(Prism::SymbolNode)
+            next unless argument.is_a?(Prism::SymbolNode)
+
+            Rigor::Source::SymbolName.of(argument.unescaped)&.to_s
           end
         end
 

data/plugins/rigor-active-model-serializers/lib/rigor/plugin/active_model_serializers.rb

@@ -239,7 +239,11 @@ module Rigor
       def project_defines?(class_name, method_name, scope)
         return false unless scope.respond_to?(:user_def_through_ancestors)
 
-        !scope.user_def_through_ancestors(class_name, method_name.to_sym).first.nil?
+        # A name no Symbol can hold cannot be a method the project defines (#1831): decline, do not raise.
+        method = Rigor::Source::SymbolName.of(method_name.to_s)
+        return false if method.nil?
+
+        !scope.user_def_through_ancestors(class_name, method).first.nil?
       end
 
       # `REST::AccountSerializer` offers two readings — the namespaced `REST::Account` and the

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

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module Rigor
+  module Plugin
+    class Activerecord < Rigor::Plugin::Base
+      # The model classes ActiveRecord loads BY NAME from an association (`belongs_to :user` → `User`), for
+      # `rigor unused` (ADR-102 WD3). The name is derived at runtime and never written in source, so a
+      # reference index sees a model reached only this way as unreferenced.
+      #
+      # The rows come from the {ModelIndex}'s association list, which {ModelDiscoverer} already extracts
+      # (class-body declarations and `with_options` groups only — not `class << self`, a `def` or another
+      # block). This module only resolves them, mirroring ActiveRecord:
+      #
+      # - `class_name:` (String or Symbol) wins; `"::Foo"` is rooted.
+      # - otherwise `has_many` / `has_and_belongs_to_many` → `name.singularize.camelize`, and
+      #   `belongs_to` / `has_one` → `name.camelize` (`Reflection#derive_class_name`).
+      # - the name is tried as nested in the owner itself, then in each enclosing namespace innermost first,
+      #   then at top level (`ActiveRecord::Inheritance#compute_type`).
+      # - a root is published only when the project declares a model of that name.
+      #
+      # Declined — no root, never a guess: a polymorphic association (no single target), a non-literal
+      # `class_name:` / `**opts`, `anonymous_class:`, a `with_options` group with non-literal options, and a
+      # `through:` association without a literal `class_name:` / `source_type:`. Without them a `through:` target is the SOURCE association's class on the through model, and
+      # that association (declared there, hence in this same index) roots it itself.
+      #
+      # A computed name equal to the owner's own demodulized name declines too (Rails 7.2+ tries `::Name`
+      # first; the target is then the owner itself or a top-level class).
+      #
+      # ActiveRecord takes the first candidate that is a defined constant. The index knows only models, so the
+      # walk stops (declines) at a candidate that is not a model but is a namespace of one: Rails would pick
+      # that module and fail, never the next candidate. A non-model class at an earlier candidate is invisible
+      # here.
+      #
+      # The roots are flat: an association on a model `rigor unused` itself reports as dead still roots its
+      # target, exactly as the other plugins' roots do.
+      module AssociationRoots
+        COLLECTION_MACROS = %i[has_many has_and_belongs_to_many].freeze
+        ROOTED_MACROS = (COLLECTION_MACROS + %i[belongs_to has_one]).freeze
+        VALID_NAME = /\A(?:::)?[A-Z][A-Za-z0-9_]*(?:::[A-Z][A-Za-z0-9_]*)*\z/
+        private_constant :VALID_NAME
+
+        module_function
+
+        # Sorted, unique model class names. Raises {Rigor::Plugin::Inflector::Unavailable} when a name had to
+        # be inflected and could not be.
+        def call(model_index)
+          namespaces = model_index.class_names.flat_map { |name| prefixes(name) }.to_set
+          roots = model_index.entries.each_value.flat_map do |entry|
+            entry.associations.filter_map { |row| resolve(entry.class_name, row, model_index, namespaces) }
+          end
+          roots.uniq.sort
+        end
+
+        def prefixes(name)
+          segments = name.split("::")
+          (1...segments.length).map { |n| segments.first(n).join("::") }
+        end
+
+        def resolve(owner, row, model_index, namespaces)
+          return nil unless ROOTED_MACROS.include?(row[:macro])
+          return nil if row[:polymorphic] || row[:roots_declined]
+
+          type_name = type_name(row)
+          return nil if type_name.nil? || !VALID_NAME.match?(type_name)
+          # Rails 7.2+ (`MacroReflection#_klass`) tries `::Name` first when the computed name is the owner's
+          # own demodulized name, so the target may be the owner or a top-level class: decline.
+          return nil if type_name == owner.split("::").last
+
+          candidates(owner, type_name).each do |candidate|
+            return candidate if model_index.model?(candidate)
+            return nil if namespaces.include?(candidate)
+          end
+          nil
+        end
+
+        def type_name(row)
+          option = row[:class_name_option]
+          option = row[:source_type_option] if option.nil? && row[:through]
+          return nil if option == :dynamic
+          return option unless option.nil?
+          return nil if row[:through]
+
+          name = row[:name].to_s
+          name = Rigor::Plugin::Inflector.singularize(name) if COLLECTION_MACROS.include?(row[:macro])
+          Rigor::Plugin::Inflector.camelize(name)
+        end
+
+        # `compute_type`: a rooted name is looked up as is; otherwise the owner ITSELF first (`Post has_many
+        # :comments` tries `Post::Comment`), then its enclosing namespaces innermost first, then top level.
+        def candidates(owner, type_name)
+          return [type_name.delete_prefix("::")] if type_name.start_with?("::")
+
+          segments = owner.split("::")
+          nested = segments.length.downto(1).map { |n| "#{segments.first(n).join('::')}::#{type_name}" }
+          nested + [type_name]
+        end
+      end
+    end
+  end
+end

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

@@ -940,7 +940,7 @@ module Rigor
                     node.name == :define_singleton_method
                 arg0 = node.arguments&.arguments&.first
                 name = Rigor::Source::Literals.symbol_name(arg0) || (arg0.is_a?(Prism::StringNode) ? arg0.unescaped : nil)
-                key = TABLE_NAME_DECORATOR_METHODS[name.to_sym] if name
+                key = TABLE_NAME_DECORATOR_METHODS[Rigor::Source::SymbolName.of(name)] if name
                 if key
                   readers << key
                   decorators[key] = node.block.is_a?(Prism::BlockNode) ? literal_def_value(node.block.body) : { computed: true }
@@ -1263,9 +1263,10 @@ module Rigor
         # association / enum / validation declared inside is invisible to the discoverer, turning
         # `where(<assoc>: ...)` into a false `unknown-column`. Nested `with_options` blocks recurse.
         #
-        # The options the `with_options` call itself carries (e.g. `with_options class_name: 'Account'`)
-        # are NOT merged into the nested calls — discovering the declaration name is what clears the
-        # false positive; the merged-option target precision is a separate refinement.
+        # This method returns only the nodes and does NOT merge the group's own options (e.g.
+        # `with_options class_name: 'Account'`); {#association_calls} is the variant that does, and it is
+        # what the association rows use. The other lookups (enums, scopes, validations, callbacks) ignore
+        # group options.
         def declaration_calls(body)
           return [] if body.nil?
 
@@ -1291,20 +1292,42 @@ module Rigor
           return [] if body.nil?
 
           rows = []
-          declaration_calls(body).each do |node|
+          association_calls(body, [], false).each do |node, inherited, opaque|
             kind = ASSOCIATION_METHODS[node.name]
             next if kind.nil?
             next if node.receiver # skip `self.has_many` and similar
 
-            row = build_association_row(node, kind)
+            row = build_association_row(node, kind, inherited, opaque)
             rows << row unless row.nil?
           end
           rows
         end
 
-        def build_association_row(node, kind)
-          args = node.arguments&.arguments
-          return nil if args.nil? || args.empty?
+        # {#declaration_calls} that also carries the options of the enclosing `with_options(...)` groups, as
+        # `[node, option_args, opaque]`. `option_args` are the keyword-hash arguments of those groups, which
+        # ActiveRecord merges under the call's own options; `opaque` is true when a group passes anything
+        # else (`with_options opts do`), so its options are unknown.
+        def association_calls(body, inherited, opaque)
+          return [] if body.nil?
+
+          body.compact_child_nodes.flat_map do |node|
+            next [] unless node.is_a?(Prism::CallNode)
+
+            if node.name == :with_options && node.block.is_a?(Prism::BlockNode)
+              args = node.arguments&.arguments || []
+              hashes = args.grep(Prism::KeywordHashNode)
+              association_calls(node.block.body, hashes + inherited, opaque || hashes.size != args.size)
+            else
+              [[node, inherited, opaque]]
+            end
+          end
+        end
+
+        def build_association_row(node, kind, inherited, opaque)
+          own = node.arguments&.arguments
+          return nil if own.nil? || own.empty?
+
+          args = own + inherited
 
           name = Rigor::Source::Literals.symbol_name(args.first)
           return nil if name.nil?
@@ -1322,7 +1345,65 @@ module Rigor
           end
 
           { name: name, kind: kind, target: target, polymorphic: polymorphic,
-            nullable: association_nullable?(node.name, args) }
+            nullable: association_nullable?(node.name, args),
+            macro: node.name, class_name_option: class_name_option(args),
+            through: association_key?(args, "through"),
+            source_type_option: literal_option(args, "source_type"),
+            roots_declined: opaque || association_key?(args, "anonymous_class") || own_options_unknown?(own) }
+        end
+
+        # The `class_name:` option as ActiveRecord's `compute_type` will read it: the literal String (a
+        # Symbol is `to_s`'d by Rails too), `nil` when the option is absent, and `:dynamic` when it is
+        # present but not a literal — the `:reachability_roots` consumer must decline then, where the
+        # `target` above falls back to the inferred name.
+        # A `**opts` splat may carry a `class_name:` too, so it reads as present-but-unknown.
+        def class_name_option(args)
+          literal_option(args, "class_name") ||
+            (args.any? { |a| a.is_a?(Prism::KeywordHashNode) && a.elements.any?(Prism::AssocSplatNode) } ? :dynamic : nil)
+        end
+
+        def literal_option(args, key)
+          args.each do |arg|
+            next unless arg.is_a?(Prism::KeywordHashNode)
+
+            arg.elements.each do |pair|
+              next unless pair.is_a?(Prism::AssocNode) && Source::Literals.symbol_named?(pair.key, key)
+
+              value = pair.value
+              return value.unescaped if value.is_a?(Prism::StringNode) || value.is_a?(Prism::SymbolNode)
+
+              return :dynamic
+            end
+          end
+          nil
+        end
+
+        ROOT_OPTION_KEYS = %w[class_name polymorphic through source_type anonymous_class].freeze
+        LITERAL_OPTION_VALUES = [Prism::StringNode, Prism::SymbolNode, Prism::TrueNode, Prism::FalseNode].freeze
+        private_constant :ROOT_OPTION_KEYS, :LITERAL_OPTION_VALUES
+
+        # Whether the association call's OWN arguments hide an option that decides its target class: a
+        # positional options hash or variable, a `**splat`, or a non-literal value for one of the keys. A
+        # `with_options` group's literal value must not stand in for it.
+        def own_options_unknown?(own)
+          own.drop(1).any? do |arg|
+            next false if arg.is_a?(Prism::LambdaNode) # the scope argument carries no class option
+            next true unless arg.is_a?(Prism::KeywordHashNode)
+
+            arg.elements.any? do |pair|
+              next true unless pair.is_a?(Prism::AssocNode)
+
+              ROOT_OPTION_KEYS.any? { |key| Source::Literals.symbol_named?(pair.key, key) } &&
+                LITERAL_OPTION_VALUES.none? { |klass| pair.value.is_a?(klass) }
+            end
+          end
+        end
+
+        def association_key?(args, key)
+          args.any? do |arg|
+            arg.is_a?(Prism::KeywordHashNode) &&
+              arg.elements.any? { |pair| pair.is_a?(Prism::AssocNode) && Source::Literals.symbol_named?(pair.key, key) }
+          end
         end
 
         # Whether a `:singular` association's accessor can return `nil`. `has_one` genuinely can (no
@@ -1356,6 +1437,9 @@ module Rigor
 
               return true if pair.value.is_a?(Prism::TrueNode)
               return false if pair.value.is_a?(Prism::FalseNode)
+
+              # The call's own non-literal value shadows a `with_options` group's literal one.
+              return nil
             end
           end
           nil

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

@@ -7,6 +7,7 @@ require_relative "activerecord/schema_parser"
 require_relative "activerecord/structure_sql_parser"
 require_relative "activerecord/model_index"
 require_relative "activerecord/model_discoverer"
+require_relative "activerecord/association_roots"
 require_relative "activerecord/analyzer"
 require_relative "activerecord/effects"
 
@@ -64,6 +65,11 @@ module Rigor
       manifest(
         id: "activerecord",
         target_gems: ["activerecord"],
+        # 0.14.0, 2026-10-10 (#1721) — the plugin publishes `:reachability_roots`: the models ActiveRecord loads
+        # by name from an association. The association rows gain `macro`, `class_name_option`, `through` and
+        # `source_type_option`, so a cached 0.13.0 payload lacks the fields the roots are derived from and
+        # would publish none; the bump (part of the producer cache KEY) is what stops a warm run serving it.
+        #
         # 0.13.0, 2026-09-24 (#1321) — the class-side `Model.find` with two or more arguments returns
         # `Array[Model]` instead of the model, and its `model-call` note says so. A model that defines its own
         # `self.find` keeps its own answer; the note reads syntax alone and does not see that override. No
@@ -118,7 +124,7 @@ module Rigor
         # a scope lambda body / class-method body now contributes `Relation[Model]` via `scope.self_type`
         # instead of falling through to `Kernel#select` (the IO multiplexer, `Array[String]` return). Plus
         # `:select` added to the relation-entry-point list.
-        version: "0.13.0",
+        version: "0.14.0",
         description: "Types ActiveRecord finders against the project's db/schema.rb and AR models.",
         config_schema: {
           "schema_file" => { kind: :string, default: "db/schema.rb" },
@@ -128,7 +134,7 @@ module Rigor
           "model_search_paths" => { kind: :array, default: ["app/models"] },
           "model_base_classes" => { kind: :array, default: %w[ApplicationRecord ActiveRecord::Base] }
         },
-        produces: [:model_index],
+        produces: %i[model_index reachability_roots],
         # ADR-25 — the bundled `ActiveRecord::Relation` RBS that relation-typed call sites (`has_many`
         # accessors, `Model.where`, scopes) dispatch against.
         signature_paths: ["sig"],
@@ -241,6 +247,9 @@ module Rigor
         # this, so the disclosure is in the coordinator's table before a single worker is forked.
         disclose_load_errors
         return if index.nil? || index.empty?
+
+        # Roots do not read columns, so reduced mode (Redmine) publishes them too.
+        publish_association_roots(services, index)
         # Reduced mode stays UNPUBLISHED. Every consumer reads `columns:` as authoritative and fires on a
         # key missing from it — rigor-actionpack's `permit(:title)` check and rigor-shoulda-matchers'
         # `have_db_column(:title)` / `validate_presence_of(:title)` matchers both do — so publishing the
@@ -256,6 +265,18 @@ module Rigor
         )
       end
 
+      # ADR-102 WD3 — the models an association loads by name; see {AssociationRoots}. An unavailable
+      # inflector (ADR-39: decline, never approximate) leaves the report as it was.
+      def publish_association_roots(services, index)
+        roots = AssociationRoots.call(index)
+        return if roots.empty?
+
+        services.fact_store.publish(plugin_id: manifest.id, name: :reachability_roots, value: roots)
+      rescue Rigor::Plugin::Inflector::Unavailable
+        nil
+      end
+      private :publish_association_roots
+
       def diagnostics_for_file(path:, scope:, root:)
         index = model_index
         # The schema-load disclosure is independent of whether an index was built: reduced mode still
@@ -401,6 +422,7 @@ module Rigor
 
         if call_node.receiver
           class_call_return_type(call_node, scope, index) ||
+            relation_splat_find_return_type(call_node, scope) ||
             relation_call_return_type(call_node, scope, index) ||
             instance_call_return_type(call_node, scope, index)
         else
@@ -670,6 +692,25 @@ module Rigor
         relation_of(model_name)
       end
 
+      # `relation.find(*ids)` answers by argument count as `Model.find` does (`finder_return_type`), counting a splat or
+      # a `**` hash as one argument, which is the policy the bundled `Relation#find` documents: `find(*ids)` is the
+      # element, and `find(id, *ids)` and `find(*args, **opts)` are Arrays. The engine lets a splat stand for any
+      # number of arguments (#1801), so through the RBS overloads `find(*ids)` would join `Dynamic[Array[Elem] |
+      # Elem]`, on which a following `update` or `save` no longer resolves on the model and loses its
+      # `io.db.write`. Only a block-less call with a splat is answered here; every other `find` stays with the RBS.
+      def relation_splat_find_return_type(call_node, scope)
+        return nil unless call_node.name == :find && call_node.block.nil?
+        return nil unless call_node.arguments&.arguments&.any?(Prism::SplatNode)
+
+        model_name = relation_element_class_name(scope.type_of(call_node.receiver))
+        return nil if model_name.nil?
+
+        model = Rigor::Type::Combinator.nominal_of(model_name)
+        return model if call_argument_count(call_node) < 2
+
+        Rigor::Type::Combinator.nominal_of("Array", type_args: [model])
+      end
+
       # Whether `name` is a declared `scope` on ANY model in the index. A run-lifetime memoised Set so the
       # per-call check in `relation_call_return_type` stays O(1).
       def scope_name?(name, index)

data/plugins/rigor-activerecord/sig/active_record/relation.rbs

@@ -292,7 +292,9 @@ module ActiveRecord
     # loses its `io.db.write`. So a single argument stays `Elem`. A
     # splat and a `**` hash each count as one argument, so `find(*ids)`
     # is `Elem`, while `find(id, *ids)` and `find(*args, **opts)` are
-    # Arrays even when the splat or the hash turns out empty.
+    # Arrays even when the splat or the hash turns out empty. The engine
+    # reads a splat as any number of arguments (#1801), so the plugin
+    # answers a splat call by this count (`relation_splat_find_return_type`).
     #
     # With a block `find` is `Enumerable#find` (`return super if
     # block_given?`), so the id overloads do not apply: no argument