rigortype 0.3.9 → 0.4.0

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

@@ -31,7 +31,7 @@
 #
 # Every method carries an effect annotation, and the split down
 # the middle of this file is the whole point of the Rails effect
-# layer: a **builder** is `%a{pure}` because it issues nothing —
+# layer: a **query builder** is `%a{pure}` because it issues nothing —
 # `where` composes an Arel tree and returns a relation — while a
 # **materializer** is `%a{rigor:v1:effect io.db.read}` because it
 # is the call that finally runs the query. A presenter that builds
@@ -46,6 +46,136 @@
 # `Enumerable` surface, which materialise by delegating to `each`
 # — are covered by the plugin's `effect_attributions:` instead,
 # because declaring them here would change how they TYPE.
+#
+# ## Every bound here also bounds the association's relations
+#
+# A `has_many` reader returns an
+# `ActiveRecord::Associations::CollectionProxy`, and a query
+# builder called on the proxy (`user.posts.where(…)`) returns an
+# `ActiveRecord::AssociationRelation`. Both are Relation subclasses
+# that still hold the association, and the plugin types both as
+# `Relation[Model]`. A call on either imports this file's bound, so
+# each annotation has to hold for all three classes. The facts below
+# are checked against activerecord 8.1.3.1.
+#
+# Where one of them adds records to the association's in-memory
+# target or discards them from it, the bound carries `mutate.self`:
+#
+# - `build` / `new`, `create` / `create!` and the `find_or_*`,
+#   `create_or_find_by` and `first_or_*` builders reach
+#   `@association.build` / `create`, which call `add_to_target`. On
+#   the proxy they are overrides. On an AssociationRelation they are
+#   its private `_new` / `_create`.
+# - `reset`, `reload`, `delete_all` and `destroy_all` on the proxy
+#   reset the association, which drops every record built there and
+#   not yet saved. So do `update_all` and `touch_all`: the proxy does
+#   not override them, and Relation's version ends with
+#   `.tap { reset }`, which reaches the proxy's `reset`.
+# - `insert`, `insert!` and `upsert`, and their `_all` forms, on the
+#   proxy reset the target only when it holds no unsaved record.
+#   Rails 8.1 deprecates the other branch and says those records will
+#   be lost in 8.2. The bound is written for 8.2, and it over-states
+#   8.1.
+#
+# So `user.posts.build` changes an object the caller can still reach
+# through `user`: `user.posts.size` counts the new record, and
+# `user.save` saves it. On a plain Relation, `new` and `build` change
+# nothing, so `mutate.self` over-states them there. The type cannot
+# tell the receivers apart, and an upper bound may be too wide but
+# never too narrow.
+#
+# Loading is not counted as a change. `to_a` and `load` fill the
+# target with what the database holds, which is the `io.db.read` they
+# already carry.
+#
+# `mutate.self` is written from the callee's side, as any envelope
+# is: the receiver changes itself. A caller imports the label
+# unchanged, so in the caller's row it names the proxy it called,
+# not the caller's own `self`.
+#
+# `insert`, `insert!` and `upsert` are declared here, beside their
+# `_all` forms, because a plain Relation defines them too. The
+# declaration changes no result type: an undeclared method on this
+# open receiver already types as `untyped`. It adds the checks any
+# declared method gets, `call.wrong-arity` and
+# `call.possible-nil-receiver`, and its parameter list admits every
+# call Rails accepts.
+#
+# The writers a plain Relation does not define (`<<`, `push`,
+# `append`, `concat`, `replace`, `clear`) are rows in the plugin's
+# `effect_attributions:` rather than declarations here. The same rows
+# cover `delete` / `destroy`, which a Relation does define, as
+# `delete(id_or_array)` and `destroy(id)`, but the proxy overrides as
+# `delete(*records)` and `destroy(*records)`. A declaration here
+# would need a parameter list and a return wide enough for both, and
+# it would give the two methods a second effect channel next to
+# their rows.
+#
+# ## Every parameter list here also admits the overrides
+#
+# The rule above holds for parameter lists as well as effect bounds.
+# A call on the proxy or on an AssociationRelation is checked against
+# the parameter list declared here, so a declaration must accept
+# every argument an override accepts, or valid Rails draws
+# `call.wrong-arity`. Of the overrides this file declares, only the
+# proxy's `delete_all(dependent = nil)` accepts more than the
+# Relation's `delete_all`. It takes `:nullify` or `:delete_all`, so
+# `delete_all` declares an optional argument. The price is that
+# `delete_all(:nullify)` on a plain Relation or on an
+# AssociationRelation (`user.posts.where(…)`), neither of which
+# overrides it, raises `ArgumentError` and goes unreported.
+#
+# Of the rest, the `(...)` methods of the `insert` and `insert_all`
+# families and the proxy's `delegate … to: :scope` block (the query
+# builders and `scoping`) forward their arguments unchanged to the
+# Relation's own methods, and the proxy's other overrides (`find`,
+# `last`, `take`, `build`, `create`, `calculate`, `pluck`, …) take no
+# more than the declarations here. `delete` and `destroy`, whose
+# overrides take more arguments than the Relation's, stay undeclared
+# for the reasons above.
+#
+# ## A writer that also queries carries the read too
+#
+# `io.db.write` does not include `io.db.read`: they are sibling
+# leaves. So a writer that queries before its write, or after a failed
+# one, names both. In activerecord 8.1.3.1:
+#
+# - `find_or_create_by(!)` is `find_by || create_or_find_by`, and
+#   `first_or_create(!)` is `first || create`.
+# - `create_or_find_by(!)` rescues `RecordNotUnique` with `find_by!`.
+# - `destroy_all` is `records.each(&:destroy)`, which loads first, and
+#   `destroy_by` is `where(…).destroy_all`. `update(!)` walks `each`,
+#   or passes an id to the model's `update`, which calls `find`.
+# - `update_all` and `delete_all`, and so `touch_all` and `delete_by`,
+#   first `SELECT` the distinct primary keys when the relation
+#   eager-loads, has a limit or offset and no `group`, and eager-loads
+#   or joins a collection association (`apply_join_dependency`). The
+#   proxy's `delete_all` on a `has_many :through` loads the target
+#   before it deletes.
+# - `create(!)` on the proxy of a `has_many :through` a `has_one`
+#   builds the join record through the `has_one`, which loads the
+#   record it replaces.
+#
+# The `insert` and `insert_all` families stay `io.db.write` alone.
+# Each compiles one `INSERT` statement and queries nothing else: the
+# proxy's override reads only the target it already holds in memory.
+#
+# Two kinds of query are not counted. Schema reflection is one: the
+# column and index lookups the schema cache serves would otherwise
+# make `where` a read. The model's callbacks and validators are the
+# other, including those an association option such as `dependent:`
+# or `touch:` registers. They are not part of any bound here. The
+# plugin's callback edge carries only symbol-argument callback macros
+# and a uniqueness validator, and only on the model's own `save` /
+# `destroy`. Nothing carries the reads a required `belongs_to`,
+# `touch:` or `dependent:` registers.
+#
+# One case is not covered. On that same `has_many :through` a
+# `has_one`, `new` / `build` also build the join record when the
+# source reflection has an inverse, and so do `find_or_initialize_by`
+# and `first_or_initialize`, which reach `new`. The `has_one` then
+# replaces its record: it loads the old one, and even without a
+# save it can delete, destroy or save it.
 
 module ActiveRecord
   class Relation[Elem]
@@ -101,6 +231,10 @@ module ActiveRecord
     def left_outer_joins: (*untyped) -> self
     %a{pure}
     def references: (*untyped) -> self
+    # With a block, `select` is Enumerable's and returns an Array. It
+    # stays `self`: on this open receiver a method the file does not
+    # declare is not reported, while on `Array[Elem]` any ActiveSupport
+    # method the bundled overlay leaves out would be.
     %a{pure}
     def select: (*untyped) -> self
     %a{pure}
@@ -145,9 +279,33 @@ module ActiveRecord
     def with: (*untyped) -> self
     def scoping: () { () -> untyped } -> untyped
 
-    # --- finders (return an element) ---
-    %a{rigor:v1:effect io.db.read}
-    def find: (*untyped) -> Elem
+    # --- finders (return an element, or an Array of them; `find`
+    # with a block, the element or nil) ---
+    # Two or more ids return an Array, unless dropping `nil`s and
+    # duplicates leaves one. One argument returns an Array when it is an
+    # Array of ids, but one record when it is a composite key's tuple
+    # (`[shop_id, id]`), and nothing here can tell those apart. An
+    # overload keyed on an `Array` argument would be selected for every
+    # untyped id too (`find(params[:id])`). Its return would be joined
+    # with this one's into `Dynamic[Array[Elem] | Elem]`, on which a
+    # following `update` or `save` no longer resolves on the model and
+    # 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.
+    #
+    # With a block `find` is `Enumerable#find` (`return super if
+    # block_given?`), so the id overloads do not apply: no argument
+    # returns the element or `nil`, and one argument is the `ifnone`
+    # callable, whose result joins the union. That form is rare, so
+    # it stays `untyped` rather than typing the callable. The
+    # class-side `Model.find { … }` reaches this same method through
+    # `all`.
+    %a{rigor:v1:effect io.db.read}
+    def find: () { (Elem) -> boolish } -> Elem?
+            | (untyped ifnone) { (Elem) -> boolish } -> untyped
+            | (untyped, untyped, *untyped) -> Array[Elem]
+            | (?untyped id) -> Elem
     %a{rigor:v1:effect io.db.read}
     def find_by: (*untyped) -> Elem?
     %a{rigor:v1:effect io.db.read}
@@ -243,9 +401,9 @@ module ActiveRecord
     def entries: () -> Array[Elem]
     %a{rigor:v1:effect io.db.read}
     def load: (?untyped) -> self
-    %a{rigor:v1:effect io.db.read}
+    %a{rigor:v1:effect io.db.read, mutate.self}
     def reload: () -> self
-    %a{pure}
+    %a{rigor:v1:effect mutate.self}
     def reset: () -> self
     %a{pure}
     def loaded?: () -> bool
@@ -272,56 +430,73 @@ module ActiveRecord
     %a{pure}
     def table: () -> untyped
     %a{pure}
-    def arel: () -> untyped
+    def arel: (?untyped aliases) -> untyped
 
     # --- whole-relation persistence ---
-    %a{rigor:v1:effect io.db.write}
+    %a{rigor:v1:effect io.db.read, io.db.write, mutate.self}
     def update_all: (untyped) -> Integer
-    %a{rigor:v1:effect io.db.write}
-    def delete_all: () -> Integer
-    %a{rigor:v1:effect io.db.write}
+    # The optional argument is the association proxy's `dependent`
+    # (see the header). A plain Relation's and an AssociationRelation's
+    # `delete_all` take none.
+    %a{rigor:v1:effect io.db.read, io.db.write, mutate.self}
+    def delete_all: (?untyped dependent) -> Integer
+    # On a plain `has_many`, the proxy's `destroy_all` returns `nil`
+    # when a `before_remove` callback throws `:abort`. A `:through` one,
+    # which includes `has_and_belongs_to_many`, still returns the
+    # records. `Array[Elem]?` would report `call.possible-nil-receiver`
+    # on every `destroyed.each` for a case only such a callback reaches.
+    %a{rigor:v1:effect io.db.read, io.db.write, mutate.self}
     def destroy_all: () -> Array[Elem]
-    %a{rigor:v1:effect io.db.write}
+    %a{rigor:v1:effect io.db.read, io.db.write}
     def update: (*untyped) -> untyped
-    %a{rigor:v1:effect io.db.write}
+    %a{rigor:v1:effect io.db.read, io.db.write}
     def update!: (*untyped) -> untyped
-    %a{rigor:v1:effect io.db.write}
+    %a{rigor:v1:effect io.db.read, io.db.write}
     def delete_by: (*untyped) -> Integer
-    %a{rigor:v1:effect io.db.write}
+    %a{rigor:v1:effect io.db.read, io.db.write}
     def destroy_by: (*untyped) -> Array[Elem]
-    %a{rigor:v1:effect io.db.write}
+    %a{rigor:v1:effect io.db.read, io.db.write, mutate.self}
     def touch_all: (*untyped) -> Integer
-    %a{rigor:v1:effect io.db.write}
+    %a{rigor:v1:effect io.db.write, mutate.self}
+    def insert: (untyped, **untyped) -> untyped
+    %a{rigor:v1:effect io.db.write, mutate.self}
     def insert_all: (untyped, **untyped) -> untyped
-    %a{rigor:v1:effect io.db.write}
+    %a{rigor:v1:effect io.db.write, mutate.self}
+    def insert!: (untyped, **untyped) -> untyped
+    %a{rigor:v1:effect io.db.write, mutate.self}
     def insert_all!: (untyped, **untyped) -> untyped
-    %a{rigor:v1:effect io.db.write}
+    %a{rigor:v1:effect io.db.write, mutate.self}
+    def upsert: (untyped, **untyped) -> untyped
+    %a{rigor:v1:effect io.db.write, mutate.self}
     def upsert_all: (untyped, **untyped) -> untyped
 
     # --- instantiating builders (return an element) ---
-    %a{pure}
+    # Given an Array of attribute hashes, `new`, `build`, `create` and
+    # `create!` return an Array of records. No overload says so, for
+    # the reason `find` gives: an untyped argument would select it too.
+    %a{rigor:v1:effect mutate.self}
     def new: (*untyped) ?{ (Elem) -> void } -> Elem
-    %a{pure}
+    %a{rigor:v1:effect mutate.self}
     def build: (*untyped) ?{ (Elem) -> void } -> Elem
-    %a{rigor:v1:effect io.db.write}
+    %a{rigor:v1:effect io.db.read, io.db.write, mutate.self}
     def create: (*untyped) ?{ (Elem) -> void } -> Elem
-    %a{rigor:v1:effect io.db.write}
+    %a{rigor:v1:effect io.db.read, io.db.write, mutate.self}
     def create!: (*untyped) ?{ (Elem) -> void } -> Elem
-    %a{rigor:v1:effect io.db.write}
+    %a{rigor:v1:effect io.db.read, io.db.write, mutate.self}
     def find_or_create_by: (untyped) ?{ (Elem) -> void } -> Elem
-    %a{rigor:v1:effect io.db.write}
+    %a{rigor:v1:effect io.db.read, io.db.write, mutate.self}
     def find_or_create_by!: (untyped) ?{ (Elem) -> void } -> Elem
-    %a{rigor:v1:effect io.db.read}
+    %a{rigor:v1:effect io.db.read, mutate.self}
     def find_or_initialize_by: (untyped) ?{ (Elem) -> void } -> Elem
-    %a{rigor:v1:effect io.db.write}
+    %a{rigor:v1:effect io.db.read, io.db.write, mutate.self}
     def create_or_find_by: (untyped) ?{ (Elem) -> void } -> Elem
-    %a{rigor:v1:effect io.db.write}
+    %a{rigor:v1:effect io.db.read, io.db.write, mutate.self}
     def create_or_find_by!: (untyped) ?{ (Elem) -> void } -> Elem
-    %a{rigor:v1:effect io.db.write}
+    %a{rigor:v1:effect io.db.read, io.db.write, mutate.self}
     def first_or_create: (?untyped) ?{ (Elem) -> void } -> Elem
-    %a{rigor:v1:effect io.db.write}
+    %a{rigor:v1:effect io.db.read, io.db.write, mutate.self}
     def first_or_create!: (?untyped) ?{ (Elem) -> void } -> Elem
-    %a{rigor:v1:effect io.db.read}
+    %a{rigor:v1:effect io.db.read, mutate.self}
     def first_or_initialize: (?untyped) ?{ (Elem) -> void } -> Elem
   end
 end

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

@@ -67,12 +67,15 @@ module Rigor
       def init(_services)
         @model_search_paths = Array(config.fetch("model_search_paths")).map(&:to_s)
         @attachment_index = nil
-        @load_errors = []
+        @load_errors = {}
       end
 
       def diagnostics_for_file(path:, scope:, root:) # rubocop:disable Lint/UnusedMethodArgument
         index = attachment_index
-        return load_error_diagnostics(path) if index.nil?
+        if index.nil?
+          disclose_load_errors
+          return []
+        end
         return [] if index.empty?
 
         Analyzer.new(path: path, attachment_index: index).analyze(root).diagnostics
@@ -126,24 +129,32 @@ module Rigor
         # covers model-file additions.
         @attachment_index = cache_for(:attachment_index, params: {}).call
       rescue Plugin::AccessDeniedError => e
-        @load_errors << "rigor-activestorage: #{e.message}"
+        @load_errors["1-read-refused"] ||= "rigor-activestorage: #{e.message}"
         nil
       rescue StandardError => e
-        @load_errors << "rigor-activestorage: discovery failed: #{e.class}: #{e.message}"
+        @load_errors["2-discovery-failed"] ||=
+          "rigor-activestorage: discovery failed: #{e.class}: #{e.message}"
         nil
       end
 
-      def load_error_diagnostics(path)
-        @load_errors.uniq.map do |message|
-          Rigor::Analysis::Diagnostic.new(
-            path: path,
-            line: 1,
-            column: 1,
-            message: message,
-            severity: :warning,
-            rule: "load-error"
-          )
+      # Issue #1056 — "the attachment index did not load" is a fact about the run's INPUTS, not about the
+      # file being analysed, so both outcomes are registered rather than returned: see
+      # {Plugin::Base#disclose_once} for the channel and the position. Returned from the per-file hook they
+      # carried no once-guard at all — the `.uniq` collapsed repeats within one instance's list, but the
+      # whole list was re-emitted on every analysed file.
+      #
+      # The `key`s carry an ordinal prefix because the engine emits a plugin's disclosures in KEY order
+      # (#1051), and a refused read must still precede a discovery failure the way `@load_errors` records
+      # them — `@load_errors` is now keyed by that same string, which also caps it: `#attachment_index`
+      # re-attempts the load per call site, and the old Array appended a fresh interpolated string every
+      # time (the unbounded-growth shape #569 measured at 4.2 M retained strings on Redmine). The key, not
+      # the message, is the identity: a second refusal naming a different path collapses into the first row
+      # rather than adding one — the notice is "the index did not load", said once.
+      def disclose_load_errors
+        @load_errors.each do |key, message|
+          disclose_once(key, message: message, severity: :warning, rule: "load-error")
         end
+        nil
       end
     end
 

data/plugins/rigor-activesupport-core-ext/lib/rigor/plugin/activesupport_core_ext/effects.rb

@@ -8,7 +8,7 @@ module Rigor
       # rigor-activesupport-core-ext's effect contract (ADR-103 WD10; design note § 11.2; issue #387).
       #
       # **Scope note.** This is the *impure* half of ActiveSupport only: the clock, the notification bus and
-      # `CurrentAttributes`. The `%a{pure}` sweep over `blank?` / `present?` / `deep_dup` and the rest of
+      # `CurrentAttributes`. The `%a{pure}` sweep over `blank?` / `present?` / `presence` and the rest of
       # the core_ext predicate surface — the single cheapest purity win in a Rails app, per WD10 — is issue
       # #388 and lands in this plugin's shipped RBS, not here (`try` was audited and skipped: it dispatches
       # to whatever method the caller names, so its purity is a fact about the call site, not about `try`).
@@ -115,11 +115,18 @@ module Rigor
         # which is what earns `Date` its row here — the label is a fact about the module, not about the
         # receiver, and the three only ever differed in which spellings the bundle had got round to
         # declaring.
+        #
+        # `String#in_time_zone` is the exception: it has no instant to convert. It parses through
+        # `TimeZone#parse(str, now = now())`, whose default argument reads the clock on every call, or through
+        # `to_time` when no zone is set — so it takes `CLOCK`, not `ZONE_READ`.
         def in_time_zone_rows
           [TIME, DATE, DATETIME].map do |receiver|
             row(receiver, :in_time_zone, ZONE_READ,
                 why: "the default argument reads `Time.zone` when the caller doesn't name one explicitly")
-          end
+          end + [
+            row("String", :in_time_zone, CLOCK,
+                why: "parses in `Time.zone` (the default argument) and fills the parts from the zone's `now`")
+          ]
         end
 
         def current_rows

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

@@ -163,6 +163,10 @@ class Object
   # exception to the try-shaped-dispatch rule above (design note § 11.2).
   %a{pure}
   def in?: (untyped) -> bool
+  # `in?(another_object) ? self : nil` — `params[:kind].presence_in(%w[a b])`.
+  # The same `#include?` dispatch as `in?`, and the same exception.
+  %a{pure}
+  def presence_in: (untyped) -> self?
 
   # Issue #673 — `core_ext/object/to_query`, `core_ext/object/duplicable` and
   # `core_ext/object/instance_variables` all hang off `Object`, so every
@@ -191,6 +195,63 @@ class Object
   # `instance_variable_names`.
   def instance_values: () -> Hash[String, untyped]
   def instance_variable_names: () -> Array[String]
+
+  # `core_ext/object/deep_dup` — `duplicable? ? dup : self`, plus `Array`
+  # (`map(&:deep_dup)`), `Hash` and `Module` overrides. `self` over-claims on
+  # an `Array` subclass, whose override answers a plain `Array`. Declared on
+  # `Object` and not only on `Hash`, where it sat alone: `[[1], [2]].deep_dup`
+  # is the common shape.
+  #
+  # NOT `%a{pure}`: on `Object` the `dup` runs the receiver class's own
+  # `initialize_copy`, an unknown-at-this-declaration dispatch like the one
+  # that keeps `as_json` bare. `Hash#deep_dup` below reaches the same `dup`
+  # through `value.deep_dup` on every value and is bare for the same reason.
+  def deep_dup: () -> self
+
+  # `core_ext/object/with` (ActiveSupport 7.1+) — sets each keyword through
+  # its public writer, yields `self`, and restores the old values in an
+  # `ensure`; the answer is the block's. There is no blockless form: `yield` without a block raises.
+  # ActiveSupport `undef_method`s it on `NilClass`, `TrueClass`, `FalseClass`,
+  # `Integer`, `Float` and `Symbol`, which RBS cannot express, so `1.with(a: 1)`
+  # resolves here where Ruby raises — a missed error, not a false one.
+  # `Data#with` (core) is a subclass override and keeps its own `-> self`.
+  #
+  # NOT `%a{pure}`: it writes the receiver's attributes through `public_send`.
+  def with: [T] (**untyped attributes) { (self) -> T } -> T
+
+  # `core_ext/object/with_options` — without a block, the
+  # `ActiveSupport::OptionMerger` proxy (not declared here); with one, the
+  # block's value. A zero-arity block is `instance_eval`ed on the proxy, the
+  # `with_options dependent: :destroy do has_many … end` model-body shape.
+  #
+  # NOT `%a{pure}`: the proxy forwards every call to the receiver through
+  # `method_missing`, a dispatch this audit cannot see.
+  def with_options: (untyped options) -> untyped
+                  | [T] (untyped options) { (?) -> T } -> T
+
+  # `core_ext/string/output_safety` — `false` on `Object`, `true` on
+  # `Numeric`, the buffer's own state on `ActiveSupport::SafeBuffer`. `bool`
+  # for the reason `duplicable?` is: `-> false` on the universal receiver makes
+  # every `if x.html_safe?` an always-falsy branch on the subclasses that answer
+  # true. All three bodies are a constant or an ivar read.
+  %a{pure}
+  def html_safe?: () -> bool
+end
+
+# ---------------------------------------------------------------
+# Kernel — `core_ext/kernel/singleton_class`
+# ---------------------------------------------------------------
+
+# `singleton_class.class_eval(*args, &block)` on any object. Declared on
+# `Kernel`, where ActiveSupport defines it; a `Module` receiver still answers
+# core `Module#class_eval`, which is its own alias of `module_eval`. The two
+# overloads mirror that `module_eval`: a string, or a block given the
+# singleton class.
+module Kernel
+  # NOT `%a{pure}`: it evaluates a string or a block in the singleton class,
+  # and a block that defines methods is the point.
+  def class_eval: (string code, ?string? filename, ?int lineno) -> untyped
+                | [U] () { (untyped singleton_class) -> U } -> U
 end
 
 # `nil.blank?` / `nil.present?` / `nil.try` are the most frequent
@@ -269,6 +330,8 @@ class String
   def dasherize: () -> String
   %a{pure}
   def upcase_first: () -> String
+  %a{pure}
+  def downcase_first: () -> String # ActiveSupport 7.1+
   # NOT %a{pure}: transliterates through `I18n.transliterate`, which reads
   # `I18n.locale` when `locale:` is left at its `nil` default — a request-
   # scoped global read the inflection-table assumption does not cover.
@@ -284,6 +347,11 @@ class String
   %a{pure}
   def humanize: (?capitalize: bool, ?keep_id_suffix: bool) -> String
 
+  # `core_ext/string/behavior` — the `acts_like?(:string)` duck-type hook, a
+  # hardcoded `true`.
+  %a{pure}
+  def acts_like_string?: () -> true
+
   # `core_ext/string/filters`
   %a{pure}
   def squish: () -> String
@@ -336,6 +404,15 @@ class String
   # follow-up to confirm and either implement or remove the declaration.
   def to_hours: () -> Float
 
+  # `core_ext/string/zones` — `Time.find_zone!(zone).parse(self)`, or
+  # `to_time` when no zone is set. `untyped` like the `Time` / `Date` rows:
+  # the parse answers an `ActiveSupport::TimeWithZone`, or `nil` on a string
+  # with no date parts. NOT `%a{pure}`: the default argument reads
+  # `Time.zone`, and `TimeZone#parse(str, now = now())` reads the clock on
+  # every call, whether or not the string names every part. The plugin's
+  # `effect_attributions:` carry both labels.
+  def in_time_zone: (?untyped zone) -> untyped
+
   # `core_ext/string/access`
   %a{pure}
   def at: (Integer | Range[Integer] | Regexp position) -> String?
@@ -355,12 +432,29 @@ class String
   # `core_ext/string/multibyte`
   %a{pure}
   def mb_chars: () -> untyped
+  # Reads `encoding` / `valid_encoding?`; the `ASCII-8BIT` branch
+  # `force_encoding`s a `dup`, never the receiver.
+  %a{pure}
+  def is_utf8?: () -> bool
 
   # `core_ext/string/inquiry`
   %a{pure}
   def inquiry: () -> untyped # ActiveSupport::StringInquirer
 end
 
+# ---------------------------------------------------------------
+# Symbol — `core_ext/symbol/starts_ends_with`
+# ---------------------------------------------------------------
+
+# `alias_method`s of core `start_with?` / `end_with?`, declared with the core
+# parameter lists.
+class Symbol
+  %a{pure}
+  def starts_with?: (*Regexp | string prefixes) -> bool
+  %a{pure}
+  def ends_with?: (*string suffixes) -> bool
+end
+
 # ---------------------------------------------------------------
 # Integer — `core_ext/integer/*`
 # ---------------------------------------------------------------
@@ -1369,6 +1463,10 @@ class Array[unchecked out Elem]
   def fifth: () -> Elem?
   %a{pure}
   def forty_two: () -> Elem?
+  %a{pure}
+  def second_to_last: () -> Elem?
+  %a{pure}
+  def third_to_last: () -> Elem?
 
   # `core_ext/array/grouping`
   %a{pure}
@@ -1400,6 +1498,9 @@ class Array[unchecked out Elem]
   # `core_ext/array/extract`
   def extract!: () { (Elem) -> bool } -> Array[Elem] # NOT %a{pure}: bang, mutates in place.
 
+  # `core_ext/array/extract_options`
+  def extract_options!: () -> Hash[untyped, untyped] # NOT %a{pure}: pops the trailing options Hash.
+
   # `core_ext/object/blank` / `core_ext/enumerable` — both
   # ActiveSupport additions, shipped on Array specifically.
   %a{pure}
@@ -1444,6 +1545,15 @@ module Enumerable[unchecked out Elem]
   def sole: () -> Elem
   %a{pure}
   def compact_blank: () -> Array[Elem]
+  %a{pure}
+  def many?: () -> bool
+           | () { (Elem) -> boolish } -> bool
+  # `key` and `series` are untyped on purpose: the default `filter: true`
+  # path is `group_by(&key).values_at(*series)`, so a Proc key or a Set /
+  # Range series is correct Rails code. `filter:` is ActiveSupport 8.x;
+  # passing it on 7.x raises, which this unversioned row does not catch.
+  %a{pure}
+  def in_order_of: (untyped key, untyped series, ?filter: boolish) -> Array[Elem]
 end
 
 # ---------------------------------------------------------------
@@ -1474,10 +1584,17 @@ class Hash[unchecked out K, unchecked out V]
   %a{pure}
   def deep_transform_values: () { (V) -> untyped } -> Hash[K, untyped]
   def deep_transform_values!: () { (V) -> untyped } -> self
+  # `alias_method`s of `symbolize_keys` / `symbolize_keys!`.
+  %a{pure}
+  def to_options: () -> Hash[Symbol, V]
+  def to_options!: () -> self
 
   # `core_ext/hash/deep_dup` — allocates a deep copy, never touches the
-  # receiver.
-  %a{pure}
+  # receiver. NOT `%a{pure}`: it calls `deep_dup` on every value, and on
+  # every key that is not a `String` or `Symbol` — an ELEMENT of unknown class
+  # whose `dup` runs that class's own `initialize_copy`. That is the dispatch
+  # the purity rule at the top of this file excludes, and the reason
+  # `Object#deep_dup` above is bare.
   def deep_dup: () -> Hash[K, V]
 
   # `core_ext/hash/deep_merge` — the block receives `(key, this_val,
@@ -1488,6 +1605,10 @@ class Hash[unchecked out K, unchecked out 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
+  # `other.is_a?(Hash)` — the hook `ActiveSupport::DeepMergeable` asks before
+  # recursing into a value. `:nodoc:`, but public.
+  %a{pure}
+  def deep_merge?: (untyped other) -> bool
 
   # `core_ext/hash/except` — `Hash#except` is in core RBS as of
   # Ruby 3.0+; `except!` is ActiveSupport-only. ActiveSupport
@@ -1512,6 +1633,9 @@ class Hash[unchecked out K, unchecked out V]
   # `%a{pure}` explicitly.
   %a{pure}
   def with_indifferent_access: () -> untyped
+  # An `alias` of `with_indifferent_access`.
+  %a{pure}
+  def nested_under_indifferent_access: () -> untyped
 
   # `core_ext/hash/conversions`
   def self.from_xml: (String, ?Symbol disallowed_types) -> Hash[String, untyped]
@@ -1522,15 +1646,57 @@ class Hash[unchecked out K, unchecked out V]
   def compact_blank: () -> Hash[K, V]
   def compact_blank!: () -> self # NOT %a{pure}: bang (`delete_if`), mutates in place.
 
-  # `core_ext/hash/reverse_merge`
+  # `core_ext/array/extract_options`
   %a{pure}
-  def reverse_merge: (Hash[K, V]) -> Hash[K, V]
+  def extractable_options?: () -> bool
+
+  # `core_ext/hash/reverse_merge` — `other_hash.merge(self)`, so the result
+  # carries the argument's keys and values as well as the receiver's, the
+  # same shape as core `Hash#merge`. `-> Hash[K, V]` typed
+  # `opts.reverse_merge(size: 25, velocity: 10)` as `Hash[:size, 1]`.
+  %a{pure}
+  def reverse_merge: [A, B] (Hash[A, B] other_hash) -> Hash[A | K, B | V]
   def reverse_merge!: (Hash[K, V]) -> self # NOT %a{pure}: bang (`replace`), mutates in place.
+  # `alias_method`s: `with_defaults` of `reverse_merge`, `with_defaults!`
+  # and `reverse_update` of `reverse_merge!`.
+  %a{pure}
+  def with_defaults: [A, B] (Hash[A, B] other_hash) -> Hash[A | K, B | V]
+  def with_defaults!: (Hash[K, V]) -> self # NOT %a{pure}: bang (`replace`), mutates in place.
+  def reverse_update: (Hash[K, V]) -> self # NOT %a{pure}: `reverse_merge!` under another name.
 
   # `core_ext/hash/slice` — `Hash#except` is in core RBS (Ruby 3.0+);
   # `Hash#slice` is in core RBS (Ruby 2.5+); the bang variants are
-  # ActiveSupport-only.
+  # ActiveSupport-only. `extract!` deletes the named keys and answers them
+  # as a new hash; a key the receiver lacks is skipped, not `nil`-filled.
   def slice!: (*K) -> Hash[K, V] # NOT %a{pure}: bang (`replace`), mutates in place.
+  def extract!: (*K) -> Hash[K, V] # NOT %a{pure}: bang, mutates via `delete`.
+end
+
+# ---------------------------------------------------------------
+# Range — `core_ext/range/*`
+# ---------------------------------------------------------------
+
+# `[out E]` matches core `range.rbs`. A reopening whose parameters differ in
+# count or variance (`class Range`, `class Range[E]`) raises
+# `RBS::GenericParameterMismatchError` and collapses `Range`.
+class Range[out E]
+  # `core_ext/range/overlap` — an `alias` of `overlap?`, which rbs declares
+  # since Ruby 3.3 (ActiveSupport defines the method itself only on an older
+  # Ruby). `overlap?` is therefore NOT redeclared here: a second declaration
+  # is a `DuplicatedMethodDefinitionError` that collapses the whole class.
+  %a{pure}
+  def overlaps?: (Range[untyped]) -> bool
+
+  # `core_ext/range/conversions` — `ActiveSupport::RangeWithFormat`, prepended
+  # onto `Range`. An unknown format falls back to `to_s`; `:db` answers `nil`
+  # for a beginless-and-endless range, which the declared `String` does not
+  # model — `(nil..nil).to_fs(:db)` is not a shape correct code writes.
+  #
+  # NOT `%a{pure}`, for the `Array#to_fs` reasons: `RANGE_FORMATS` is a
+  # mutable constant an initializer extends, and `:db` calls `to_fs(:db)` on
+  # both endpoints.
+  def to_fs: (?Symbol format) -> String
+  def to_formatted_s: (?Symbol format) -> String
 end
 
 # ---------------------------------------------------------------