rigortype 0.3.6 → 0.3.8

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/handbook/11-sig-gen.md

@@ -95,10 +95,13 @@ states:
 
 The `sig.skipped.*` reasons are:
 
-- `sig.skipped.complex-shape` — the method has optional, rest,
-  keyword, block, or forwarding parameters. The MVP's
-  body-typing path only handles required positional
-  parameters; complex shapes need a future slice.
+- `sig.skipped.complex-shape` — reserved for a parameter
+  shape the renderer cannot spell. Every shape a `def` can
+  declare renders today (optional, rest, trailing, keyword,
+  keyword-rest, `...` forwarding, `&block`), so the
+  generator does not produce this reason; it stayed
+  reserved when the gate that used to fire it for every
+  such method was retired (#778).
 - `sig.skipped.untyped-return` — the method body's last
   expression types as `Dynamic[top]`. Emitting `untyped` as
   a tightening would be noise rather than help.
@@ -119,16 +122,25 @@ The `sig.skipped.*` reasons are:
 The three `sig.generated.*` identifiers
 (`sig.generated.new-file` / `new-method` / `tighter-return`)
 are emitted as JSON fields under `--format=json` so CI
-gating consumers can route them.
+gating consumers can route them. Every `skipped` row is part
+of the same payload, carrying its `sig.skipped.*` identifier
+as `skip_reason`, so a method missing from your `sig/` has
+its reason next to the rows that did emit. In text mode a
+one-line stderr summary counts the skipped methods per
+reason instead; stdout stays paste-clean.
 
 ## What method shapes the generator covers
 
 Slice-by-slice (each shipped via a CHANGELOG entry — this
 list is the current state):
 
-- **Plain instance `def foo`** with required positional
-  parameters. Both new-method and tighter-return paths
-  apply.
+- **Plain instance `def foo`** of any parameter shape:
+  required, optional, rest, trailing, keyword, keyword-rest,
+  `...` forwarding and `&block`. The parameter list mirrors
+  the runtime shape with `untyped` in every position (the
+  observed union under `--params=observed`), and a block
+  renders as `?{ (*untyped) -> untyped }`. Both new-method
+  and tighter-return paths apply.
 - **Singleton-side `def self.foo`** and
   `class << self; def foo; end`. Rendered as
   `def self.foo: ...`; matched against
@@ -143,10 +155,8 @@ list is the current state):
   are recognised as user-authored and never produce a
   duplicate `def` insertion.
 
-Method shapes the generator does **not** cover yet (and
-silently skips):
+Method shapes the generator does **not** cover yet:
 
-- Optional / rest / keyword / block / forwarding parameters.
 - `define_method(:name) { ... }`.
 - Methods whose body types as `Dynamic[top]` (the body
   inference cannot prove a useful return type).
@@ -303,9 +313,9 @@ inference, not a separate analysis.
 
 ## Limits today
 
-- Methods with optional / rest / keyword / block /
-  forwarding parameters silently skip
-  (`sig.skipped.complex-shape`).
+- A block parameter always renders as the lenient
+  `?{ (*untyped) -> untyped }`; a typed block signature
+  waits on the engine tracking yield shapes end-to-end.
 - `define_method` and `Data.define`-specific emission are
   deferred follow-ups (`Data.define`-derived readers come
   through if a method body exists).

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`
@@ -466,6 +475,13 @@ exits `1`: you asked for a write and did not get one. Such a skip
 is a bug in Rigor's RBS rendering, not in your code — please
 report it.
 
+A method the generator declined for any other reason (a body
+that proves only `untyped`, a user-authored declaration it will
+not overwrite) is never a silent absence: under `--format=json`
+it is a `skipped` row of the `candidates` array with its
+`sig.skipped.*` identifier in `skip_reason`, and in text mode a
+one-line stderr summary counts the skipped methods per reason.
+
 ## `rigor lsp`
 
 Run the Language Server over stdio. See
@@ -1001,7 +1017,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/04-diagnostics.md

@@ -74,7 +74,7 @@ carries no `documentation_url`.
 | <a id="rule-effect-envelope-exceeded"></a>`effect.envelope-exceeded` | A method performs an effect its declared envelope does not admit — its proven effect labels (its own body plus everything it calls) are not covered by the `%a{pure}` or `%a{rigor:v1:effect …}` bound written on it or on its class. Opt-in twice over: it needs an `effects:` block in `.rigor.yml` and an envelope you wrote. Positioned at the Ruby `def`. Unproven ("and possibly more") effects never fire, and `mutate.local` is tolerated by every envelope. | high |
 | <a id="rule-effect-liskov-widened"></a>`effect.liskov-widened` | An override escapes the envelope written on the method it overrides. A `PgRepo` is usable wherever a `Repo` is, so a `%a{rigor:v1:effect io.db}` on `Repo#find` binds `PgRepo#find` too: an implementation may be purer than the bound it inherits, never less pure. Either what the override *does* exceeds the inherited bound, or the envelope the override *declares for itself* is wider than it. Both sides must be authored — nothing fires unless someone wrote an envelope on the ancestor — and only subclassing counts, not `include`. Positioned at the override's `def`. Needs an `effects:` block. | high |
 | <a id="rule-effect-unknown-label"></a>`effect.unknown-label` | An effect declaration names a label the registry does not know — a typo in an envelope (`%a{rigor:v1:effect io.bd}`), or a member of `effects.tolerated:`. The whole tag then reads as unbounded, so the declaration quietly stops doing anything; this says so. Positioned at the declaration: the `.rbs` line, the `.rb` line for an rbs-inline annotation, or `.rigor.yml` for a config value. `# rigor:disable` comments are not read out of `.rbs` or `.rigor.yml`, so use `disable:` or the baseline there. Only fires where the spelling is evidently meant to be a label (close to a known one, next to a known one, dotted, or retired) — a word nothing resembles stays silent, because you may be opening your own vocabulary. Needs an `effects:` block. | high |
-| <a id="rule-effect-annotations-unchecked"></a>`effect.annotations-unchecked` | Your signatures carry `%a{pure}` / `%a{rigor:v1:effect …}` but `.rigor.yml` has no `effects:` block, so nothing checks them. One `:info` per run, positioned at the first annotation. An annotation never turns effect collection on by itself — that would make one line in one file more expensive for every run — so this is how it tells you instead. Add `effects: {}` to opt in, or `disable:` it to keep the annotations documentary. Reads both annotation lanes — `sig/*.rbs` and rbs-inline comments — except on a run that analyses no file at all (a warm `--incremental` with nothing changed), where only the `.rbs` lane is visible. | — |
+| <a id="rule-effect-annotations-unchecked"></a>`effect.annotations-unchecked` | Your signatures carry `%a{pure}` / `%a{rigor:v1:effect …}` but `.rigor.yml` has no `effects:` block, so nothing checks them. One `:info` per run, positioned at the first annotation. An annotation never turns effect collection on by itself — that would make one line in one file more expensive for every run — so this is how it tells you instead. Add `effects: {}` to opt in, or `disable:` it to keep the annotations documentary. Reads both annotation lanes — `sig/*.rbs` and rbs-inline comments — on every run, a warm `--incremental` with nothing changed included. | — |
 | <a id="rule-suppression-unknown-rule"></a>`suppression.unknown-rule` | A `# rigor:disable[-file]` comment names a rule that does not exist (typically a typo), so the suppression silently does nothing. `plugin.`-prefixed tokens are never flagged. | high |
 | <a id="rule-suppression-empty"></a>`suppression.empty` | A `# rigor:disable[-file]` comment lists no rules, so it suppresses nothing. | high |
 | <a id="rule-suppression-unknown-marker"></a>`suppression.unknown-marker` | A comment uses a suppression marker Rigor does not recognise — typically the RuboCop reflex `# rigor:disable-next-line <rule>` or `# rigor:enable <rule>`. Rigor's only markers are `# rigor:disable <rules>` (suppresses on its own line) and `# rigor:disable-file <rules>`, so the comment suppresses nothing. | high |