rigortype 0.3.5 → 0.3.7

data/data/gem_overlay/activesupport/core_ext.rbs

@@ -65,6 +65,9 @@ class Object
   # `acts_like?(:string)` / `acts_like?(:date)` / `acts_like?(:time)`
   # is ActiveSupport's "duck-typing helper" predicate.
   def acts_like?: (Symbol | String) -> bool
+
+  # `core_ext/object/inclusion` — `x.in?([a, b])` / `x.in?(1..10)`.
+  def in?: (untyped) -> bool
 end
 
 # `nil.blank?` / `nil.present?` / `nil.try` are the most frequent
@@ -75,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
@@ -108,6 +113,9 @@ class String
   def pluralize: (?Integer count, ?Symbol locale) -> String
   def singularize: (?Symbol locale) -> String
   def humanize: (?capitalize: bool, ?keep_id_suffix: bool) -> String
+  def titlecase: () -> String
+  def dasherize: () -> String
+  def upcase_first: () -> String
 
   # `core_ext/string/filters`
   def squish: () -> String
@@ -115,6 +123,8 @@ class String
   def truncate: (Integer truncate_at, ?omission: String, ?separator: String | Regexp | nil) -> String
   def truncate_bytes: (Integer truncate_at, ?omission: String) -> String
   def truncate_words: (Integer words_count, ?omission: String, ?separator: String | Regexp | nil) -> String
+  def remove: (*Regexp | String patterns) -> String
+  def remove!: (*Regexp | String patterns) -> String
 
   # `core_ext/string/output_safety` — `html_safe` returns an
   # `ActiveSupport::SafeBuffer` (a String subclass). The closest
@@ -236,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
 # ---------------------------------------------------------------
@@ -245,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
@@ -271,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
@@ -282,7 +386,134 @@ class Time
   # Re-declaring it raised `RBS::DuplicatedMethodDefinitionError` and took the WHOLE `Time` definition
   # down with it (every `Time` call degraded to `Dynamic[top]`). This overlay only ADDS what
   # ActiveSupport adds.
+  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
 
 # ---------------------------------------------------------------
@@ -290,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
@@ -323,6 +555,98 @@ class Date
   def at_beginning_of_day: () -> Time
   def end_of_day: () -> Time
   def at_end_of_day: () -> Time
+  def advance: (untyped options) -> Date
+  def all_day: () -> Range[Time]
+
+  # `Date#to_time` is an OVERLOAD CONTINUATION (`| ...`), not a plain declaration: stdlib `date`
+  # already types `to_time: () -> Time`, and re-declaring it raises
+  # `RBS::DuplicatedMethodDefinitionError`, which collapses `Date` to `Dynamic[top]` for every project
+  # this overlay reaches — the failure the `Time#utc?` note above records, and the one #437 hit on the
+  # plugin. The row cannot simply be omitted either: ActiveSupport genuinely widens the arity, so
+  # 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
 
 # ---------------------------------------------------------------
@@ -459,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
@@ -474,4 +817,92 @@ 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
+
+# ---------------------------------------------------------------
+# ERB::Util — ActionView extends it with `html_escape_once`
+# ---------------------------------------------------------------
+
+# `ERB` is a CLASS in Ruby / RBS (not a module), so reopen it as a class — a `module ERB` wrapper
+# collides with upstream `class ERB` once the `erb` stdlib is in scope. `ERB::Util` itself is a module.
+class ERB
+  module Util
+    def self.html_escape_once: (untyped) -> String
+  end
 end

data/docs/handbook/02-everyday-types.md

@@ -113,7 +113,7 @@ String, Symbol, Array, and Hash. The list is not in this
 handbook (it would fill several pages); see
 [`docs/types.md`](../types.md) and the per-class catalogues
 under
-[`data/builtins/ruby_core/`](../../data/builtins/ruby_core/).
+[`data/builtins/ruby_core/`](../../data/builtins/ruby_core).
 
 When folding is **not** safe (because a method has side
 effects, depends on the environment, or is not in a

data/docs/handbook/04-tuples-and-shapes.md

@@ -275,7 +275,7 @@ the underlying RBS sig advertises.
 
 If you prefer the TS spellings (`Pick<T, K>` etc.) in
 directives, opt into the
-[`rigor-typescript-utility-types`](../../plugins/rigor-typescript-utility-types/)
+[`rigor-typescript-utility-types`](../../plugins/rigor-typescript-utility-types)
 plugin. The plugin registers a `Plugin::TypeNodeResolver` that
 translates each TS name onto the canonical projection:
 

data/docs/handbook/08-understanding-errors.md

@@ -236,6 +236,6 @@ deprecations, …). Most projects will never write one; the
 chapter exists so you know the option is there.
 [Chapter 10 — Coexisting with Sorbet](10-sorbet.md) is for
 projects arriving from a Sorbet codebase: the
-[`rigor-sorbet`](../../plugins/rigor-sorbet/) adapter reads
+[`rigor-sorbet`](../../plugins/rigor-sorbet) adapter reads
 `sig { ... }` blocks, RBI files, and `T.let` / `T.cast` /
 `T.must` / `T.unsafe` assertions as type sources.

data/docs/handbook/09-plugins.md

@@ -122,7 +122,7 @@ Reach for a plugin only when:
 
 If those are true, [`examples/README.md`](../../examples/README.md)
 is your starting point. The
-[`rigor-deprecations`](../../examples/rigor-deprecations/)
+[`rigor-deprecations`](../../examples/rigor-deprecations)
 example is the smallest fully-shaped plugin — manifest +
 single per-file walk + a couple of diagnostic emissions —
 and is the recommended template for "I want to author my
@@ -146,7 +146,7 @@ From here:
   to deeper material in
   [`docs/type-specification/`](../type-specification/README.md),
   [`docs/internal-spec/`](../internal-spec/README.md), and
-  [`docs/adr/`](../adr/).
+  [`docs/adr/`](../adr).
 - The [`CHANGELOG.md`](../../CHANGELOG.md) is the per-release
   truth for what shipped when.
 

data/docs/handbook/10-sorbet.md

@@ -1,7 +1,7 @@
 # Coexisting with Sorbet
 
 If your project already uses [Sorbet](https://sorbet.org/),
-the [`rigor-sorbet`](../../plugins/rigor-sorbet/) plugin
+the [`rigor-sorbet`](../../plugins/rigor-sorbet) plugin
 lets Rigor read your existing `sig` blocks, RBI files, and
 `T.let` / `T.cast` / `T.must` / `T.unsafe` assertions as type
 sources. You do not have to rewrite anything in RBS to start

data/docs/handbook/README.md

@@ -66,7 +66,7 @@ up the flag, key, or command that *acts* on it.
    landing page.
 10. [**Coexisting with Sorbet**](10-sorbet.md) — for users
     arriving from a Sorbet-using project: the
-    [`rigor-sorbet`](../../plugins/rigor-sorbet/) adapter
+    [`rigor-sorbet`](../../plugins/rigor-sorbet) adapter
     reads `sig { ... }` blocks, RBI files, and
     `T.let` / `T.cast` / `T.must` / `T.unsafe` assertions
     as type sources without rewriting in RBS.
@@ -255,7 +255,7 @@ ADRs:
 - [`docs/internal-spec/`](../internal-spec/README.md) —
   analyzer-internal contracts (engine surface, type-object
   public API).
-- [`docs/adr/`](../adr/) — architecture decision records.
+- [`docs/adr/`](../adr) — architecture decision records.
 
 ## Non-goals
 

data/docs/handbook/appendix-go.md

@@ -105,7 +105,7 @@ type switches. Rigor has direct analogues.
 | `if x != nil` | `if x` (strips `nil`), or `unless x.nil?` |
 | `v, ok := x.(string)` (comma-ok assertion) | `x.is_a?(String)` narrowing in an `if` |
 | `switch v := x.(type) { case string: … }` | `case x; in String => v` |
-| `x.(T)` (assertion, panics on fail) | (no panicking assertion) — `is_a?` guard, or `T.cast` via [`rigor-sorbet`](../../plugins/rigor-sorbet/) |
+| `x.(T)` (assertion, panics on fail) | (no panicking assertion) — `is_a?` guard, or `T.cast` via [`rigor-sorbet`](../../plugins/rigor-sorbet) |
 | user func returning `bool` | `%a{rigor:v1:predicate-if-true x is Foo}` directive |
 
 Go's type switch is *not* exhaustive — you can omit cases and

data/docs/handbook/appendix-java-csharp.md

@@ -58,7 +58,7 @@ advisor that only speaks when it is sure.
 | `Set<T>` | `HashSet<T>` / `ISet<T>` | `Set[T]` | |
 | `record Point(int x, int y)` | `record Point(int X, int Y)` | `Point = Data.define(:x, :y)` | See [Records ↔ Data.define](#records--datadefine). |
 | `Optional<T>` | `T?` (nullable reference type) | `T?` (i.e. `T \| nil`) | Java models it as a *container*; C# as a *type modifier*. See [Nullability](#nullability). |
-| `enum Color { RED, GREEN }` | `enum Color { Red, Green }` | `Constant<:red> \| Constant<:green>` (Symbol union) | Ruby has no native enum; the [`rigor-mangrove`](../../plugins/) plugin types richer enum DSLs. |
+| `enum Color { RED, GREEN }` | `enum Color { Red, Green }` | `Constant<:red> \| Constant<:green>` (Symbol union) | Ruby has no native enum; the [`rigor-mangrove`](../../plugins) plugin types richer enum DSLs. |
 | `sealed interface Shape permits …` | `abstract` base + sealed hierarchy | union of the subtypes | See [Sealed types & exhaustiveness](#sealed-types-and-exhaustiveness). |
 | `<T>` (generic) | `<T>` (generic) | RBS `[T]` type parameter | |
 | `? extends T` (use-site) | `out T` (declaration-site) | covariant type parameter | See [Generics & variance](#generics-and-variance). |
@@ -124,7 +124,7 @@ behaviour matches.
 | `x instanceof String` | `x is string` | `x.is_a?(String)` |
 | `x instanceof String s` (binding) | `x is string s` (binding) | `case x; in String => s` |
 | `switch (x) { case Foo f -> … }` | `switch (x) { case Foo f => … }` | `case x; in Foo => f` |
-| `(Foo) x` (cast) | `(Foo)x` (cast) | (no in-source cast) — `is_a?` guard, or `T.cast` via [`rigor-sorbet`](../../plugins/rigor-sorbet/) |
+| `(Foo) x` (cast) | `(Foo)x` (cast) | (no in-source cast) — `is_a?` guard, or `T.cast` via [`rigor-sorbet`](../../plugins/rigor-sorbet) |
 | `Objects.requireNonNull(x)` | `x!` (null-forgiving) | (no in-source assertion) — `unless x.nil?`, or `T.must` via `rigor-sorbet` |
 | user method returning `boolean` | user method returning `bool` | `%a{rigor:v1:predicate-if-true x is Foo}` directive on the predicate |
 

data/docs/handbook/appendix-mypy.md

@@ -296,7 +296,7 @@ draws the distinction in full.
   Pyright's "type alias narrowing" and mypy's overload stacks
   cover some cases; Rigor's plugin contract gives you full
   Ruby code at the dispatch point. The
-  [`rigor-lisp-eval`](../../examples/rigor-lisp-eval/) example
+  [`rigor-lisp-eval`](../../examples/rigor-lisp-eval) example
   is the canonical demo — `Lisp.eval([:+, 1, 2])` returns
   `Integer`, `Lisp.eval([:<, 1, 2])` returns `bool`.
 

data/docs/handbook/appendix-protocols-and-structural-typing.md

@@ -228,8 +228,8 @@ author):
 - The `missing-protocol-method` / `protocol-return-mismatch`
   diagnostics are **plugin diagnostics**, emitted under the
   plugin's `plugin.<id>.` provenance — not core Rigor rules. The
-  worked references are [`examples/rigor-web/`](../../examples/rigor-web/)
-  (the minimal tutorial) and [`plugins/rigor-hanami/`](../../plugins/rigor-hanami/)
+  worked references are [`examples/rigor-web/`](../../examples/rigor-web)
+  (the minimal tutorial) and [`plugins/rigor-hanami/`](../../plugins/rigor-hanami)
   (production Hanami 2 actions).
 
 ## Interface vs protocol contract