rigortype 0.3.6 → 0.3.7

data/data/gem_overlay/activesupport/core_ext.rbs

@@ -78,6 +78,8 @@ class NilClass
   def presence: () -> nil
   def try: (*untyped) -> nil
   def try!: (*untyped) -> nil
+  def duplicable?: () -> true
+  def instance_values: () -> Hash[String, untyped]
 end
 
 class TrueClass
@@ -244,6 +246,77 @@ class Float
   def gigabytes: () -> Float
 end
 
+# ---------------------------------------------------------------
+# ActiveSupport::Duration — issue #632
+# ---------------------------------------------------------------
+
+# Declaring this class at all is normally the wrong move: `Duration` forwards any method its own class
+# doesn't define to the wrapped numeric via `method_missing` (audited against ActiveSupport 8.1.3.1's
+# `lib/active_support/duration.rb`), so an incomplete declaration would turn every omitted member into a
+# false `call.undefined-method` for every project that locks activesupport. It is safe here only because
+# `ActiveSupport::Duration` is listed in `Rigor::Analysis::CheckRules::GEM_OVERLAY_OPEN_RECEIVERS`
+# (`lib/rigor/analysis/check_rules.rb`) — an open-receiver membership for exactly this bundle, gated on this
+# overlay directory actually having been loaded, since this overlay has no plugin manifest of its own for
+# an ADR-26 `open_receivers:` entry to live on (issue #660 tracks whether that gap gets a first-class
+# mechanism instead of this constant). What follows is the reader surface, mirroring
+# `rigor-activesupport-core-ext/sig/active_support/core_ext.rbs` (parity enforced by
+# `spec/rigor/environment/activesupport_overlay_parity_spec.rb`); every method not listed here stays
+# undeclared and silently `Dynamic` rather than guessed.
+module ActiveSupport
+  class Duration
+    # The `ago` family (issue #659). `since(time = ::Time.current)` and `ago(time = ::Time.current)` are
+    # the only two real methods; `from_now` / `after` alias the first and `until` / `before` the second,
+    # so all six share one signature. They were declared once before and removed, because typing them
+    # `Time` while the Rails `Time` INSTANCE surface was undeclared made `1.hour.ago.to_fs(:db)` —
+    # ordinary Rails — a false `call.undefined-method` on the returned `Time`, which
+    # `GEM_OVERLAY_OPEN_RECEIVERS` cannot suppress since it protects a Duration receiver, not a `Time`
+    # one. #658 declared that surface and #670 the `Date` / `DateTime` twins, so the chains resolve now.
+    #
+    # `Time` is the right class rather than a compromise: under a zone these answer an
+    # `ActiveSupport::TimeWithZone`, and Rails overrides `TimeWithZone#is_a?` to answer true for
+    # `::Time`. A `Time | ActiveSupport::TimeWithZone` union was measured and rejected — it types every
+    # downstream call `Dynamic[top]`. The with-an-argument form stays `untyped` because the runtime
+    # return depends on the argument's class AND on whether the duration carries a date-scale part
+    # (`(1.month).ago(Date.today)` answers a `Date`; `(30.minutes).ago(Date.today)` a `TimeWithZone`).
+    def ago: () -> Time
+           | (untyped time) -> untyped
+    def until: () -> Time
+             | (untyped time) -> untyped
+    def before: () -> Time
+              | (untyped time) -> untyped
+    def since: () -> Time
+             | (untyped time) -> untyped
+    def from_now: () -> Time
+                | (untyped time) -> untyped
+    def after: () -> Time
+             | (untyped time) -> untyped
+
+    # `to_i` / its `in_seconds` alias return `@value.to_i` — always Integer.
+    def to_i: () -> Integer
+    def in_seconds: () -> Integer
+
+    # `to_f` — always Float.
+    def to_f: () -> Float
+
+    # `in_minutes` / `in_hours` / `in_days` / `in_weeks` / `in_months` / `in_years` — each
+    # `in_seconds / SECONDS_PER_*.to_f`, always Float.
+    def in_minutes: () -> Float
+    def in_hours: () -> Float
+    def in_days: () -> Float
+    def in_weeks: () -> Float
+    def in_months: () -> Float
+    def in_years: () -> Float
+
+    # Always a String.
+    def iso8601: (?precision: Integer?) -> String
+
+    # A `dup` of the internal parts hash — Integer-valued for a duration built from Integer multipliers,
+    # but real runtime Float for a fractional one (`1.5.seconds.parts == {seconds: 1.5}`); `Integer |
+    # Float` is what stays honest without costing the common `parts[:days] * 2` chain anything.
+    def parts: () -> Hash[Symbol, Integer | Float]
+  end
+end
+
 # ---------------------------------------------------------------
 # Time — singleton + instance extensions
 # ---------------------------------------------------------------
@@ -253,6 +326,26 @@ class Time
   def self.zone: () -> untyped # ActiveSupport::TimeZone | nil
   def self.zone=: (String | Symbol | untyped) -> untyped
 
+  # Issue #658, `core_ext/time/zones` + `core_ext/time/calculations` — the rest of the singleton
+  # surface those two files add, none of it typed by rbs. `zone_default` is the `attr_accessor`
+  # behind `Time.zone`'s fallback; `find_zone!` raises on a bad zone and `find_zone` rescues to
+  # `nil`; `use_zone` swaps the zone around a block and answers the block's value. All four hand
+  # back or take an `ActiveSupport::TimeZone`, which this overlay does not declare, so they stay
+  # `untyped` rather than guessing a carrier.
+  def self.zone_default: () -> untyped
+  def self.zone_default=: (untyped) -> untyped
+  def self.use_zone: (untyped time_zone) { () -> untyped } -> untyped
+  def self.find_zone!: (untyped time_zone) -> untyped
+  def self.find_zone: (untyped time_zone) -> untyped
+  # `COMMON_YEAR_DAYS_IN_MONTH[month]` answers `nil` for a month outside 1..12, but the declared
+  # return stays `Integer`: `Integer?` would make `Time.days_in_month(2, 2024) - 1` — how every real
+  # call site uses it — a nil-arithmetic diagnostic, the more expensive of the two on correct code.
+  def self.days_in_month: (Integer month, ?Integer year) -> Integer
+  def self.days_in_year: (?Integer year) -> Integer
+  # `Time.rfc3339(str)` builds a `Time` from the parsed parts. Distinct from the `rfc3339` INSTANCE
+  # alias below.
+  def self.rfc3339: (String str) -> Time
+
   # `core_ext/time/conversions` — nothing to declare. `Time.parse`, `Time.httpdate` and `Time.iso8601`
   # all come from stdlib `time`, which rbs types; ActiveSupport only re-opens them. Declaring them
   # here raised `RBS::DuplicatedMethodDefinitionError` and collapsed the whole `Time` definition to
@@ -279,8 +372,11 @@ class Time
   def change: (**untyped) -> Time
   def at_beginning_of_day: () -> Time
   def at_end_of_day: () -> Time
-  def at_beginning_of_week: () -> Time
-  def at_end_of_week: () -> Time
+  # `at_beginning_of_week` / `at_end_of_week` are `alias`es of `beginning_of_week` / `end_of_week`
+  # in `DateAndTime::Calculations` and take the same optional `start_day` — declared zero-arity,
+  # `time.at_beginning_of_week(:sunday)` drew an arity diagnostic on correct Rails code.
+  def at_beginning_of_week: (?Symbol start_day) -> Time
+  def at_end_of_week: (?Symbol start_day) -> Time
   def at_midnight: () -> Time
   def at_noon: () -> Time
   def midday: () -> Time
@@ -293,6 +389,131 @@ class Time
   def advance: (untyped options) -> Time
   def all_day: () -> Range[Time]
   def acts_like_time?: () -> true
+
+  # -------------------------------------------------------------
+  # Issue #658 — the rest of the Rails `Time` INSTANCE surface
+  # -------------------------------------------------------------
+  #
+  # `Time` is a CORE class, fully RBS-known and therefore CLOSED: a name this file does not declare
+  # is reported `call.undefined-method`. On a closed class an OMISSION is a false positive on
+  # correct Rails code exactly as much as a wrong return type is, and there is no gradual middle —
+  # making `Time` an open receiver would suppress the genuine diagnostic project-wide. So every row
+  # below was audited name by name against the vendored activesupport-8.1.3.1 sources:
+  # `core_ext/date_and_time/calculations.rb` (the module `Time`, `Date` and `DateTime` all include),
+  # `core_ext/time/calculations.rb`, `core_ext/time/conversions.rb`,
+  # `core_ext/date_and_time/zones.rb` and `core_ext/date_and_time/compatibility.rb`.
+  #
+  # Every row was also checked against the assembled environment for a name rbs already declares:
+  # a second full declaration raises `RBS::DuplicatedMethodDefinitionError` and collapses the WHOLE
+  # class (the `Time#utc?` note above). That is why `to_time`, `xmlschema`, `localtime`, `getlocal`,
+  # `utc`, `getutc`, `utc?`, `utc_offset`, `usec`, `nsec`, `subsec`, `to_f` and `to_i` are absent
+  # even though ActiveSupport re-opens some of them.
+
+  # `core_ext/date_and_time/calculations` — the shared module; each method is `advance` / `change`
+  # on the receiver, so on a `Time` receiver each answers `Time`.
+  def today?: () -> bool
+  def tomorrow?: () -> bool
+  def next_day?: () -> bool
+  def yesterday?: () -> bool
+  def prev_day?: () -> bool
+  def past?: () -> bool
+  def future?: () -> bool
+  def on_weekend?: () -> bool
+  def on_weekday?: () -> bool
+  # `untyped` parameters: `self < date_or_time` accepts `Time`, `Date`, `DateTime` and
+  # `ActiveSupport::TimeWithZone` alike through ActiveSupport's `<=>` override.
+  def before?: (untyped date_or_time) -> bool
+  def after?: (untyped date_or_time) -> bool
+  # `Numeric` and not `Integer`: `advance` divmods a fractional `days:` / `weeks:` on purpose.
+  def days_ago: (Numeric days) -> Time
+  def days_since: (Numeric days) -> Time
+  def weeks_ago: (Numeric weeks) -> Time
+  def weeks_since: (Numeric weeks) -> Time
+  def months_ago: (Numeric months) -> Time
+  def months_since: (Numeric months) -> Time
+  def years_ago: (Numeric years) -> Time
+  def years_since: (Numeric years) -> Time
+  def at_beginning_of_month: () -> Time
+  def at_beginning_of_year: () -> Time
+  def at_end_of_month: () -> Time
+  def at_end_of_year: () -> Time
+  def beginning_of_quarter: () -> Time
+  def at_beginning_of_quarter: () -> Time
+  def end_of_quarter: () -> Time
+  def at_end_of_quarter: () -> Time
+  # `(month / 3.0).ceil` — `Float#ceil` with no argument is Integer.
+  def quarter: () -> Integer
+  def next_week: (?Symbol given_day_in_next_week, ?same_time: bool) -> Time
+  def prev_week: (?Symbol start_day, ?same_time: bool) -> Time
+  def last_week: (?Symbol start_day, ?same_time: bool) -> Time
+  def next_weekday: () -> Time
+  def prev_weekday: () -> Time
+  def last_weekday: () -> Time
+  def days_to_week_start: (?Symbol start_day) -> Integer
+  def all_week: (?Symbol start_day) -> Range[Time]
+  def monday: () -> Time
+  def sunday: () -> Time
+  def next_quarter: () -> Time
+  def prev_quarter: () -> Time
+  def last_quarter: () -> Time
+  def last_month: () -> Time
+  def last_year: () -> Time
+  def all_month: () -> Range[Time]
+  def all_quarter: () -> Range[Time]
+  def all_year: () -> Range[Time]
+  def next_occurring: (Symbol day_of_week) -> Time
+  def prev_occurring: (Symbol day_of_week) -> Time
+
+  # `core_ext/time/calculations` — the `Time`-only half. `seconds_since_midnight` ends in
+  # `+ (usec / 1.0e+6)`, so it is Float even at exactly midnight; `seconds_until_end_of_day` is
+  # `end_of_day.to_i - to_i`, Integer. `sec_fraction` is a plain alias of `subsec` and carries
+  # `subsec`'s own core type — CRuby answers the Integer `0` for a whole-second receiver.
+  def seconds_since_midnight: () -> Float
+  def seconds_until_end_of_day: () -> Integer
+  def sec_fraction: () -> (0 | Rational)
+  # `middle_of_day` is `change(hour: 12)`; `midday` / `noon` / `at_noon` above and `at_midday` /
+  # `at_middle_of_day` here are its aliases.
+  def middle_of_day: () -> Time
+  def at_midday: () -> Time
+  def at_middle_of_day: () -> Time
+  def at_beginning_of_hour: () -> Time
+  def at_end_of_hour: () -> Time
+  def at_beginning_of_minute: () -> Time
+  def at_end_of_minute: () -> Time
+  # `Time`'s OWN redefinitions (`advance(days: -days)` and friends), taking an optional count —
+  # not the zero-argument `Date` methods of the same name that rbs's `stdlib/date` types.
+  def prev_day: (?Numeric days) -> Time
+  def next_day: (?Numeric days) -> Time
+  def prev_month: (?Numeric months) -> Time
+  def next_month: (?Numeric months) -> Time
+  def prev_year: (?Numeric years) -> Time
+  def next_year: (?Numeric years) -> Time
+
+  # `core_ext/time/conversions`. `to_fs` / `to_formatted_s` always answer a String whatever the
+  # `Time::DATE_FORMATS` entry returns: the lambda branch ends in `.to_s` and the fallback is
+  # `to_s`. `formatted_offset` is String in both of its branches; its `colon` is `boolish` and not
+  # `bool` because the body is plain truthiness (`colon ? WITH_COLON : WITHOUT_COLON`), and
+  # `alternate_utc_string` is `untyped` because it is returned as-is and callers print whatever
+  # they like there. `rfc3339` is
+  # `alias_method :rfc3339, :xmlschema`, so it takes `xmlschema`'s optional `fraction_digits`; rbs
+  # types `Time#xmlschema` but not `Time#rfc3339`, so this is an addition and not a collision.
+  def to_fs: (?Symbol format) -> String
+  def to_formatted_s: (?Symbol format) -> String
+  def formatted_offset: (?boolish colon, ?untyped alternate_utc_string) -> String
+  def rfc3339: (?Integer fraction_digits) -> String
+
+  # `core_ext/date_and_time/zones`. Answers an `ActiveSupport::TimeWithZone`, which nothing in this
+  # overlay declares, so the return is `untyped` rather than a guess — the same answer
+  # `DateTime#in_time_zone` gives below. The parameter is `untyped` because `Time.find_zone!` also
+  # accepts an `ActiveSupport::TimeZone`, a `TZInfo::Timezone` and an offset `Duration`
+  # (`Time.find_zone! -5.hours` is the documented spelling).
+  def in_time_zone: (?untyped zone) -> untyped
+
+  # `core_ext/date_and_time/compatibility` — `mattr_accessor
+  # :utc_to_local_returns_utc_offset_times, instance_writer: false` defines an instance READER on
+  # every class including the module. Rarely called on an instance, but public, and `Time` is
+  # closed, so the omission would be the false positive.
+  def utc_to_local_returns_utc_offset_times: () -> bool
 end
 
 # ---------------------------------------------------------------
@@ -300,15 +521,16 @@ end
 # ---------------------------------------------------------------
 
 class Date
+  # The whole date-constructing singleton surface `core_ext/date/calculations.rb`'s `class << self`
+  # adds. `self.end_of_week`, `self.beginning_of_month`, `self.end_of_month`,
+  # `self.beginning_of_year` and `self.end_of_year` were declared here until #762 and do not exist —
+  # `Date` only INCLUDES `DateAndTime::Calculations`, so those five are instance methods, below. The
+  # declarations made `Date.end_of_month`, a real `NoMethodError`, type-check as a `Date`, and
+  # `DateTime` inherited all five. `self.beginning_of_week` exists but is the week-start
+  # configuration reader, declared with that group at the bottom of this class.
   def self.current: () -> Date
   def self.yesterday: () -> Date
   def self.tomorrow: () -> Date
-  def self.beginning_of_week: () -> Date
-  def self.end_of_week: () -> Date
-  def self.beginning_of_month: () -> Date
-  def self.end_of_month: () -> Date
-  def self.beginning_of_year: () -> Date
-  def self.end_of_year: () -> Date
 
   def yesterday: () -> Date
   def tomorrow: () -> Date
@@ -344,6 +566,87 @@ class Date
   # without it `date.to_time(:utc)` — correct Rails code — draws an arity diagnostic (#449). `| ...`
   # appends this overload ahead of the stdlib one, so both arities resolve.
   def to_time: (?Symbol form) -> Time | ...
+
+  # Issue #670 — the rest of the Rails `Date` instance surface, plus the week-start configuration
+  # singletons. `Date` is CLOSED (rbs's `stdlib/date` types it fully), so an OMISSION here is a false
+  # positive on correct Rails code exactly as much as a wrong return type is. Audited against the
+  # vendored activesupport-8.1.3.1 sources and every return confirmed by calling it on a real `Date`
+  # receiver; the plugin twin carries the per-method reasoning and the purity verdicts, which the
+  # overlay deliberately does not (see the header). The six `:nodoc:` operator-alias artefacts
+  # (`plus_with{,out}_duration`, `minus_with{,out}_duration`, `compare_with{,out}_coercion`) are left
+  # out on purpose, as are the `Object`- / `Module`-level core_ext methods that reach `Date` because
+  # they reach every class (#673).
+  def today?: () -> bool
+  def tomorrow?: () -> bool
+  def next_day?: () -> bool
+  def yesterday?: () -> bool
+  def prev_day?: () -> bool
+  def past?: () -> bool
+  def future?: () -> bool
+  def on_weekend?: () -> bool
+  def on_weekday?: () -> bool
+  def before?: (untyped date_or_time) -> bool
+  def after?: (untyped date_or_time) -> bool
+  def days_ago: (Numeric days) -> Date
+  def days_since: (Numeric days) -> Date
+  def weeks_ago: (Numeric weeks) -> Date
+  def weeks_since: (Numeric weeks) -> Date
+  def months_ago: (Numeric months) -> Date
+  def months_since: (Numeric months) -> Date
+  def years_ago: (Numeric years) -> Date
+  def years_since: (Numeric years) -> Date
+  def at_beginning_of_month: () -> Date
+  def at_end_of_month: () -> Date
+  def at_beginning_of_year: () -> Date
+  def at_end_of_year: () -> Date
+  def beginning_of_quarter: () -> Date
+  def at_beginning_of_quarter: () -> Date
+  def end_of_quarter: () -> Date
+  def at_end_of_quarter: () -> Date
+  def quarter: () -> Integer
+  def next_week: (?Symbol given_day_in_next_week, ?same_time: bool) -> Date
+  def prev_week: (?Symbol start_day, ?same_time: bool) -> Date
+  def last_week: (?Symbol start_day, ?same_time: bool) -> Date
+  def next_weekday: () -> Date
+  def days_to_week_start: (?Symbol start_day) -> Integer
+  def all_week: (?Symbol start_day) -> Range[Date]
+  def at_beginning_of_week: (?Symbol start_day) -> Date
+  def at_end_of_week: (?Symbol start_day) -> Date
+  def prev_weekday: () -> Date
+  def last_weekday: () -> Date
+  def monday: () -> Date
+  def sunday: () -> Date
+  def next_quarter: () -> Date
+  def prev_quarter: () -> Date
+  def last_quarter: () -> Date
+  def last_month: () -> Date
+  def last_year: () -> Date
+  def all_month: () -> Range[Date]
+  def all_quarter: () -> Range[Date]
+  def all_year: () -> Range[Date]
+  def next_occurring: (Symbol day_of_week) -> Date
+  def prev_occurring: (Symbol day_of_week) -> Date
+  def change: (untyped options) -> Date
+  def in: (Numeric seconds) -> Time
+  def middle_of_day: () -> Time
+  def midday: () -> Time
+  def noon: () -> Time
+  def at_midday: () -> Time
+  def at_noon: () -> Time
+  def at_middle_of_day: () -> Time
+  def to_fs: (?Symbol format) -> String
+  def to_formatted_s: (?Symbol format) -> String
+  def readable_inspect: () -> String
+  def default_inspect: () -> String
+  def in_time_zone: (?untyped zone) -> untyped
+  # The week-start configuration group. `self.beginning_of_week` is its READER and answers the week
+  # start (`:monday` by default), not a date — it was `() -> Date` until #762, which made every
+  # correct Symbol use of the value look wrong and every incorrect `Date` use look right.
+  def self.beginning_of_week: () -> Symbol
+  def self.beginning_of_week=: (Symbol week_start) -> Symbol
+  def self.beginning_of_week_default: () -> Symbol?
+  def self.beginning_of_week_default=: (Symbol? week_start) -> Symbol?
+  def self.find_beginning_of_week!: (Symbol week_start) -> Symbol
 end
 
 # ---------------------------------------------------------------
@@ -480,10 +783,29 @@ end
 # ---------------------------------------------------------------
 
 class DateTime
+  # Issue #670. `DateTime < Date`, so every row the `Date` block above declares is INHERITED here —
+  # and for most of `DateAndTime::Calculations` the inherited return is WRONG, because the shared
+  # module's `first_hour` / `last_hour` helpers branch on `acts_like?(:time)` (false on `Date`, true
+  # on `DateTime`) and compose each class's own `advance` / `change`. `DateTime.now.beginning_of_month`
+  # answered `Date` on master while returning a `DateTime` at runtime. So most of this block is
+  # overrides, and declaring the missing surface on `Date` alone would have converted the
+  # undefined-method false positives into wrong-return ones instead of fixing them.
+  #
+  # Rows already correct through inheritance are deliberately absent: `today?` / `past?` / `before?` /
+  # `on_weekend?` (bool), `quarter` / `days_to_week_start` (Integer), `to_fs` / `to_formatted_s` /
+  # `readable_inspect` / `default_inspect` (String), `acts_like_date?` (true). The sharpest is at the
+  # singleton — `DateTime.yesterday` / `.tomorrow` really do answer a `Date` (their bodies are a
+  # hardcoded `::Date.current.…`), so the inherited rows are right and overriding them would have been
+  # the false positive. `DateTime.current` is the one that is wrong inherited, and it is overridden.
   def utc: () -> Time
-  # NOTE: `DateTime#to_time` is NOT declared here — stdlib `date` already types it, and re-declaring it
-  # collapsed the whole `DateTime` definition (see the `Time#utc?` note above).
-  def in_time_zone: (?String | Symbol zone) -> untyped
+  def getgm: () -> Time
+  def getutc: () -> Time
+  def gmtime: () -> Time
+  # NOTE: `DateTime#to_time` is NOT declared here — stdlib `date` already types it, and re-declaring
+  # it collapsed the whole `DateTime` definition (see the `Time#utc?` note above). The
+  # `in_time_zone` PARAMETER widened from `String | Symbol` to `untyped` in #670: `Time.find_zone!`
+  # also accepts a `TimeZone`, a `TZInfo::Timezone` and an offset `Duration`.
+  def in_time_zone: (?untyped zone) -> untyped
   def yesterday: () -> DateTime
   def tomorrow: () -> DateTime
   def ago: (Numeric seconds) -> DateTime
@@ -495,6 +817,82 @@ class DateTime
   def beginning_of_minute: () -> DateTime
   def end_of_minute: () -> DateTime
   def acts_like_time?: () -> true
+  def advance: (untyped options) -> DateTime
+  def change: (untyped options) -> DateTime
+  def in: (Numeric seconds) -> DateTime
+  def midnight: () -> DateTime
+  def at_midnight: () -> DateTime
+  def at_beginning_of_day: () -> DateTime
+  def at_end_of_day: () -> DateTime
+  def middle_of_day: () -> DateTime
+  def midday: () -> DateTime
+  def noon: () -> DateTime
+  def at_midday: () -> DateTime
+  def at_noon: () -> DateTime
+  def at_middle_of_day: () -> DateTime
+  def at_beginning_of_hour: () -> DateTime
+  def at_end_of_hour: () -> DateTime
+  def at_beginning_of_minute: () -> DateTime
+  def at_end_of_minute: () -> DateTime
+  def seconds_since_midnight: () -> Integer
+  def seconds_until_end_of_day: () -> Integer
+  def subsec: () -> Rational
+  def to_f: () -> Float
+  def to_i: () -> Integer
+  def usec: () -> Integer
+  def nsec: () -> Integer
+  def utc?: () -> bool
+  def utc_offset: () -> Integer
+  def localtime: (?untyped utc_offset) -> Time
+  def getlocal: (?untyped utc_offset) -> Time
+  def days_ago: (Numeric days) -> DateTime
+  def days_since: (Numeric days) -> DateTime
+  def weeks_ago: (Numeric weeks) -> DateTime
+  def weeks_since: (Numeric weeks) -> DateTime
+  def months_ago: (Numeric months) -> DateTime
+  def months_since: (Numeric months) -> DateTime
+  def years_ago: (Numeric years) -> DateTime
+  def years_since: (Numeric years) -> DateTime
+  def beginning_of_month: () -> DateTime
+  def at_beginning_of_month: () -> DateTime
+  def end_of_month: () -> DateTime
+  def at_end_of_month: () -> DateTime
+  def beginning_of_year: () -> DateTime
+  def at_beginning_of_year: () -> DateTime
+  def end_of_year: () -> DateTime
+  def at_end_of_year: () -> DateTime
+  def beginning_of_quarter: () -> DateTime
+  def at_beginning_of_quarter: () -> DateTime
+  def end_of_quarter: () -> DateTime
+  def at_end_of_quarter: () -> DateTime
+  def next_quarter: () -> DateTime
+  def prev_quarter: () -> DateTime
+  def last_quarter: () -> DateTime
+  def last_month: () -> DateTime
+  def last_year: () -> DateTime
+  def prev_weekday: () -> DateTime
+  def last_weekday: () -> DateTime
+  def monday: () -> DateTime
+  def sunday: () -> DateTime
+  def next_occurring: (Symbol day_of_week) -> DateTime
+  def prev_occurring: (Symbol day_of_week) -> DateTime
+  def all_day: () -> Range[DateTime]
+  def all_month: () -> Range[DateTime]
+  def all_quarter: () -> Range[DateTime]
+  def all_year: () -> Range[DateTime]
+  def beginning_of_week: (?Symbol start_day) -> DateTime
+  def end_of_week: (?Symbol start_day) -> DateTime
+  def at_beginning_of_week: (?Symbol start_day) -> DateTime
+  def at_end_of_week: (?Symbol start_day) -> DateTime
+  def next_week: (?Symbol given_day_in_next_week, ?same_time: bool) -> DateTime
+  def prev_week: (?Symbol start_day, ?same_time: bool) -> DateTime
+  def last_week: (?Symbol start_day, ?same_time: bool) -> DateTime
+  def next_weekday: () -> DateTime
+  def all_week: (?Symbol start_day) -> Range[DateTime]
+  def formatted_offset: (?boolish colon, ?untyped alternate_utc_string) -> String
+  def utc_to_local_returns_utc_offset_times: () -> bool
+  def self.current: () -> DateTime
+  def self.civil_from_format: (untyped utc_or_local, Integer year, ?Integer month, ?Integer day, ?Integer hour, ?Integer min, ?Integer sec) -> DateTime
 end
 
 # ---------------------------------------------------------------

data/docs/manual/02-cli-reference.md

@@ -114,16 +114,25 @@ missing file.
 
 ## `rigor type-of`
 
-Print the inferred type at one source position.
+Print inferred types at one or more source positions.
 
 ```sh
-rigor type-of FILE:LINE:COL
-rigor type-of FILE LINE COL
+rigor type-of [options] FILE:LINE[:COL] [FILE:LINE[:COL] ...]
+rigor type-of [options] FILE LINE COL
 ```
 
-Accepts the position as a single `file:line:col` triple or as
-three arguments. `--format=json` emits a machine-readable
-form; `--trace` records fail-soft fallbacks. The editor-mode
+The colon form is repeatable and keeps argument order while
+parsing and scope-indexing each file once. Omit `COL` to print a
+table of up to 40 expressions that start on that line, outermost
+first at each 1-based column; the table marks when further
+expressions were omitted. The legacy three-argument form accepts
+one exact position.
+
+`--format=json` keeps one result as the original flat object and
+wraps several results in a `results` array. Line queries add a
+`line_enumerations` array whose `shown` and `total` counts make
+truncation explicit. `--trace` records fail-soft fallbacks,
+after the rows of a line table in text output. The editor-mode
 `--tmp-file` / `--instead-of` pair is accepted as on `check`.
 
 ## `rigor trace`
@@ -1001,7 +1010,7 @@ Queued today:
 
 | Feature id | Kind | What it changes |
 | --- | --- | --- |
-| `reject-unparseable-signatures` | severity | An unparseable `.rbs` under `signature_paths:` **fails the run** (`rbs.coverage.quarantined-signature` → `error`) instead of being skipped with a warning. |
+| `reject-unparseable-signatures` | severity | A broken RBS set **fails the run** instead of degrading it silently: an unparseable `.rbs` under `signature_paths:` (`rbs.coverage.quarantined-signature` → `error`), a declaration that collides on resolve and collapses the whole environment (`rbs.coverage.environment-build-failed` → `error`), and a duplicate method definition that collapses one class's method surface (`rbs.coverage.definition-build-failed` → `error`). |
 | `use-of-void-value` | severity | Using a value recovered from an author-declared `-> void` return in value context is reported as `static.value-use.void` (`warning`). |
 | `discovery-seeded-mutation-sites` | behaviour | [`rigor coverage --protection --mutation`](15-type-protection-coverage.md) measures against the same cross-file project discovery Tier 1 already uses — both when picking the sites and when deciding whether a breakage was caught — so a call on a project class declared in a *sibling* file is measured instead of dropped, and a breakage there can actually be caught. **Adds sites to the denominator, so the reported effectiveness ratio moves** — check it against any `--threshold` you pin in CI before adopting. |
 | `dependent-closure-kill-oracle` | behaviour | [`rigor coverage --protection --mutation`](15-type-protection-coverage.md) counts a breakage as caught when the diagnostic appears anywhere in the mutated file **or the files that depend on it**, instead of in the mutated file alone — so changing what a method returns counts as caught when the error lands in its callers. Can only **add** kills, so the ratio moves up or not at all; it costs about a third more wall time per mutant, and a ratio measured under it is not comparable with one measured without it. |

data/docs/manual/05-inspecting-types.md

@@ -63,19 +63,31 @@ syntax-highlighted for a tty — through
 colorizer; `--no-color` (and the `NO_COLOR` environment
 variable) disable the colour.
 
-## `rigor type-of` — one position
+## `rigor type-of` — exact positions or a whole line
 
-When you only need one expression's type — typically while
-chasing down why a diagnostic did or did not fire — query a
-single position:
+When you need a few expression types — typically while chasing
+down why a diagnostic did or did not fire — query the exact
+positions together so Rigor loads the project and each source
+file once:
 
 ```sh
-rigor type-of lib/example.rb:12:8
+rigor type-of lib/example.rb:12:8 lib/example.rb:12:14
 ```
 
-`--format=json` emits a machine-readable result for tooling.
-This is the same query the editor integration answers on
-hover.
+Leave off the column to avoid counting it by hand. Rigor prints
+a table of the first 40 expressions starting on the line,
+outermost first at each 1-based column, and marks a truncated
+table:
+
+```sh
+rigor type-of lib/example.rb:12
+```
+
+`--format=json` emits a machine-readable result for tooling: one
+result stays a flat object, while several results use a `results`
+array. Line queries add `line_enumerations` metadata with the
+shown and total expression counts. An exact position is the same
+query the editor integration answers on hover.
 
 ## `rigor trace` — watch the inference happen
 

data/docs/manual/07-plugins.md

@@ -49,6 +49,10 @@ each plugin's options — but the families today are:
   `rigor-factorybot`.
 - **dry-rb** — `rigor-dry-types`, `rigor-dry-schema`,
   `rigor-dry-struct`, `rigor-dry-validation`.
+- **FFI** — `rigor-ffi` and sub-plugins (`rigor-ffi-rzmq`,
+  `rigor-rbnacl`, `rigor-sassc`, `rigor-ethon`). For plugin authors,
+  `rigor-ffi` provides the `ffi_binding_recognizer` class DSL on
+  `Rigor::Plugin::Base` to recognize custom binding definitions.
 - **Other ecosystems** — `rigor-sinatra`, `rigor-hanami`,
   `rigor-devise`, `rigor-pundit`, `rigor-sidekiq`,
   `rigor-graphql`, `rigor-statesman`, `rigor-sorbet`,

data/docs/manual/plugins/rigor-actionpack.md

@@ -56,6 +56,43 @@ plugins:
       view_search_paths: ["app/views"]               # default
 ```
 
+## What it types
+
+Inside a controller, `params`, `request`, `session`, `flash` and
+`cookies` type as their Action Pack classes, and so do the chains
+built on them:
+
+```ruby
+request.post?          # bool — and so do get? / put? / patch? / delete? /
+                       # head? / options? / trace? / link? / unlink? /
+                       # xhr? / xml_http_request? / ssl? / local? / form_data?
+flash.now              # ActionDispatch::Flash::FlashNow
+flash.keep             # ActionDispatch::Flash::FlashHash
+flash[:notice] = "hi"  # "hi" — an assignment is its right-hand side
+```
+
+Rigor ships **no signature** for these Action Pack classes, on
+purpose: the receiver becomes concrete (so `rigor coverage
+--protection` counts the site) while the method surface stays
+lenient, so `request.headers`, `flash.now[:alert] = x` and anything
+else the framework adds resolve without a diagnostic. A partial
+signature would be worse than none — every member it omitted would
+become a false `call.undefined-method`.
+
+The predicates are typed `bool` — the union of `true` and `false` —
+which is both the real contract (every one of them is an `==`,
+`match?` or `include?` in Rails or Rack) and the reason they are safe
+to type at all: a condition that folds needs to prove *one* constant,
+and a union of both never does. `return unless request.post?` and
+`mode = request.get? ? :a : :b` read exactly as they did before.
+
+`request.format` is **not** typed. That inertness argument is
+narrower than it looks — it holds for a union of the two boolean
+constants, not for a union of ordinary classes, which is nil-free and
+so *can* fold a condition — and `Mime::NullType`, the value `format`
+returns when there is no format, answers `nil?` with `true` while
+being a real object. Typing it needs a nil-aware answer.
+
 ## Limitations
 
 - **Implicit-self helpers only.** `*_path` / `*_url` calls with an
@@ -69,6 +106,30 @@ plugins:
   knows what `rigor-rails-routes` published, and `permit`
   validation only what `rigor-activerecord` published — enabling
   those producers widens what this plugin can check.
+- **`params[:key]` stays untyped.** Inside a controller, `params`
+  types as `ActionController::Parameters`, and so does the result
+  of every builder method that always returns one — `require`,
+  `permit`, `permit!`, `expect`, `slice`, `slice!`, `except`,
+  `without`, `extract!`, `merge`, `merge!`, `reverse_merge`,
+  `reverse_merge!`, `with_defaults`, `with_defaults!`, `compact`,
+  `compact_blank`, `deep_dup` — so a chain built from them keeps a
+  concrete receiver throughout. A subscript read is deliberately
+  left untyped: `params[:missing]` is `nil` at runtime, and a type
+  that says otherwise would let the flow rules fold live
+  conditions (`if params[:q]`, `url.nil?`) to a constant and report
+  working code. Methods whose result depends on the call — `dig`,
+  `fetch`, `compact!`, and the block-less `select` / `reject` /
+  `transform_keys` / `transform_values` — are untyped for the same
+  reason.
+- **`flash[:key]` and `session[:key]` stay untyped too**, for that
+  same reason and measured the same way. Both are leaf reads that
+  return whatever was stored — or `nil` for a key that is not set.
+  A non-nil type folds `mode = flash[:notice] ? … : …` to one arm and
+  reports the live guard after it; a nullable one puts
+  `call.possible-nil-receiver` on `note = flash[:notice];
+  note.upcase`. Writing through them is unaffected: `flash[:k] = v`
+  is `v` because that is what an assignment expression means in Ruby,
+  with no rule needed.
 
 ## Plugin internals