From e3dcbd3d017fc8af420cee8c1c04bde964fda767 Mon Sep 17 00:00:00 2001
From: Jacob Pratt <jacob@jhpratt.dev>
Date: Mon, 10 Mar 2025 04:58:58 -0400
Subject: [PATCH 01/10] Pull floored division algorithm from stdlib

---
 time/src/internal_macros.rs | 31 ++++++++++++++++++++-----------
 1 file changed, 20 insertions(+), 11 deletions(-)

diff --git a/time/src/internal_macros.rs b/time/src/internal_macros.rs
index dd5c96897..1d8495e62 100644
--- a/time/src/internal_macros.rs
+++ b/time/src/internal_macros.rs
@@ -51,18 +51,27 @@ macro_rules! impl_div_assign {
 
 /// Division of integers, rounding the resulting value towards negative infinity.
 macro_rules! div_floor {
-    ($a:expr, $b:expr) => {{
-        let _a = $a;
-        let _b = $b;
-
-        let (_quotient, _remainder) = (_a / _b, _a % _b);
-
-        if (_remainder > 0 && _b < 0) || (_remainder < 0 && _b > 0) {
-            _quotient - 1
-        } else {
-            _quotient
+    ($self:expr, $rhs:expr) => {
+        match ($self, $rhs) {
+            (this, rhs) => {
+                let d = this / rhs;
+                let r = this % rhs;
+
+                // If the remainder is non-zero, we need to subtract one if the
+                // signs of self and rhs differ, as this means we rounded upwards
+                // instead of downwards. We do this branchlessly by creating a mask
+                // which is all-ones iff the signs differ, and 0 otherwise. Then by
+                // adding this mask (which corresponds to the signed value -1), we
+                // get our correction.
+                let correction = (this ^ rhs) >> (::core::mem::size_of_val(&this) * 8 - 1);
+                if r != 0 {
+                    d + correction
+                } else {
+                    d
+                }
+            }
         }
-    }};
+    };
 }
 
 /// Cascade an out-of-bounds value.

From b2b602a9a5ba457748c9fce1b8394820ffb87459 Mon Sep 17 00:00:00 2001
From: Jacob Pratt <jacob@jhpratt.dev>
Date: Mon, 10 Mar 2025 06:13:39 -0400
Subject: [PATCH 02/10] Permit visibility in `serde::format_description!`

---
 tests/serde/macros.rs                       | 36 ++++----
 time-macros/src/lib.rs                      | 92 ++++++++++++---------
 time-macros/src/serde_format_description.rs | 10 ++-
 3 files changed, 83 insertions(+), 55 deletions(-)

diff --git a/tests/serde/macros.rs b/tests/serde/macros.rs
index 2bbea1698..b08229741 100644
--- a/tests/serde/macros.rs
+++ b/tests/serde/macros.rs
@@ -20,18 +20,24 @@ time::serde::format_description!(
     Iso8601::<{ iso8601::Config::DEFAULT.encode() }>
 );
 
-serde::format_description!(
-    offset_dt_format,
-    OffsetDateTime,
-    "custom format: [year]-[month]-[day] [hour]:[minute]:[second] [offset_hour \
-     sign:mandatory]:[offset_minute]"
-);
-serde::format_description!(
-    primitive_dt_format,
-    PrimitiveDateTime,
-    "custom format: [year]-[month]-[day] [hour]:[minute]:[second]"
-);
-serde::format_description!(time_format, Time, "custom format: [minute]:[second]");
+mod nested {
+    time::serde::format_description!(
+        pub(super) offset_dt_format,
+        OffsetDateTime,
+        "custom format: [year]-[month]-[day] [hour]:[minute]:[second] [offset_hour \
+         sign:mandatory]:[offset_minute]"
+    );
+    time::serde::format_description!(
+        pub primitive_dt_format,
+        PrimitiveDateTime,
+        "custom format: [year]-[month]-[day] [hour]:[minute]:[second]"
+    );
+    time::serde::format_description!(
+        pub(in crate::serde::macros) time_format,
+        Time,
+        "custom format: [minute]:[second]"
+    );
+}
 serde::format_description!(date_format, Date, "custom format: [year]-[month]-[day]");
 serde::format_description!(
     offset_format,
@@ -50,13 +56,13 @@ serde::format_description!(
 
 #[derive(Serialize, Deserialize, Debug, Eq, PartialEq)]
 struct TestCustomFormat {
-    #[serde(with = "offset_dt_format")]
+    #[serde(with = "nested::offset_dt_format")]
     offset_dt: OffsetDateTime,
-    #[serde(with = "primitive_dt_format::option")]
+    #[serde(with = "nested::primitive_dt_format::option")]
     primitive_dt: Option<PrimitiveDateTime>,
     #[serde(with = "date_format")]
     date: Date,
-    #[serde(with = "time_format::option")]
+    #[serde(with = "nested::time_format::option")]
     time: Option<Time>,
     #[serde(with = "offset_format")]
     offset: UtcOffset,
diff --git a/time-macros/src/lib.rs b/time-macros/src/lib.rs
index 3f0c78e84..a90beee6a 100644
--- a/time-macros/src/lib.rs
+++ b/time-macros/src/lib.rs
@@ -34,9 +34,11 @@ mod utc_datetime;
 #[cfg(any(feature = "formatting", feature = "parsing"))]
 use std::iter::Peekable;
 
+#[cfg(all(feature = "serde", any(feature = "formatting", feature = "parsing")))]
+use proc_macro::Delimiter;
 use proc_macro::TokenStream;
 #[cfg(any(feature = "formatting", feature = "parsing"))]
-use proc_macro::{Ident, TokenTree};
+use proc_macro::TokenTree;
 
 use self::error::Error;
 
@@ -60,34 +62,38 @@ macro_rules! impl_macros {
 
 impl_macros![date datetime utc_datetime offset time];
 
+#[cfg(any(feature = "formatting", feature = "parsing"))]
+type PeekableTokenStreamIter = Peekable<proc_macro::token_stream::IntoIter>;
+
 #[cfg(any(feature = "formatting", feature = "parsing"))]
 enum FormatDescriptionVersion {
     V1,
     V2,
 }
 
-#[cfg(any(feature = "formatting", feature = "parsing"))]
-enum VersionOrModuleName {
-    Version(FormatDescriptionVersion),
-    #[cfg_attr(not(feature = "serde"), allow(dead_code))]
-    ModuleName(Ident),
-}
-
 #[cfg(any(feature = "formatting", feature = "parsing"))]
 fn parse_format_description_version<const NO_EQUALS_IS_MOD_NAME: bool>(
-    iter: &mut Peekable<proc_macro::token_stream::IntoIter>,
-) -> Result<Option<VersionOrModuleName>, Error> {
-    let version_ident = match iter.peek() {
-        Some(TokenTree::Ident(ident)) if ident.to_string() == "version" => match iter.next() {
-            Some(TokenTree::Ident(ident)) => ident,
-            _ => unreachable!(),
-        },
+    iter: &mut PeekableTokenStreamIter,
+) -> Result<Option<FormatDescriptionVersion>, Error> {
+    let version_ident = match iter.peek().ok_or(Error::UnexpectedEndOfInput)? {
+        version @ TokenTree::Ident(ident) if ident.to_string() == "version" => {
+            let version_ident = version.clone();
+            iter.next(); // consume `version`
+            version_ident
+        }
         _ => return Ok(None),
     };
+
     match iter.peek() {
         Some(TokenTree::Punct(punct)) if punct.as_char() == '=' => iter.next(),
         _ if NO_EQUALS_IS_MOD_NAME => {
-            return Ok(Some(VersionOrModuleName::ModuleName(version_ident)));
+            // Push the `version` ident to the front of the iterator.
+            *iter = std::iter::once(version_ident)
+                .chain(iter.clone())
+                .collect::<TokenStream>()
+                .into_iter()
+                .peekable();
+            return Ok(None);
         }
         Some(token) => {
             return Err(Error::Custom {
@@ -134,7 +140,29 @@ fn parse_format_description_version<const NO_EQUALS_IS_MOD_NAME: bool>(
     };
     helpers::consume_punct(',', iter)?;
 
-    Ok(Some(VersionOrModuleName::Version(version)))
+    Ok(Some(version))
+}
+
+#[cfg(all(feature = "serde", any(feature = "formatting", feature = "parsing")))]
+fn parse_visibility(iter: &mut PeekableTokenStreamIter) -> Result<TokenStream, Error> {
+    let mut visibility = match iter.peek().ok_or(Error::UnexpectedEndOfInput)? {
+        pub_ident @ TokenTree::Ident(ident) if ident.to_string() == "pub" => {
+            let visibility = quote! { #(pub_ident.clone()) };
+            iter.next(); // consume `pub`
+            visibility
+        }
+        _ => return Ok(quote! {}),
+    };
+
+    match iter.peek().ok_or(Error::UnexpectedEndOfInput)? {
+        group @ TokenTree::Group(path) if path.delimiter() == Delimiter::Parenthesis => {
+            visibility.extend(std::iter::once(group.clone()));
+            iter.next(); // consume parentheses and path
+        }
+        _ => {}
+    }
+
+    Ok(visibility)
 }
 
 #[cfg(any(feature = "formatting", feature = "parsing"))]
@@ -142,12 +170,7 @@ fn parse_format_description_version<const NO_EQUALS_IS_MOD_NAME: bool>(
 pub fn format_description(input: TokenStream) -> TokenStream {
     (|| {
         let mut input = input.into_iter().peekable();
-        let version = match parse_format_description_version::<false>(&mut input)? {
-            Some(VersionOrModuleName::Version(version)) => Some(version),
-            None => None,
-            // This branch should never occur here, as `false` is the provided as a const parameter.
-            Some(VersionOrModuleName::ModuleName(_)) => bug!("branch should never occur"),
-        };
+        let version = parse_format_description_version::<false>(&mut input)?;
         let (span, string) = helpers::get_string_literal(input)?;
         let items = format_description::parse_with_version(version, &string, span)?;
 
@@ -172,22 +195,16 @@ pub fn serde_format_description(input: TokenStream) -> TokenStream {
 
         // First, the optional format description version.
         let version = parse_format_description_version::<true>(&mut tokens)?;
-        let (version, mod_name) = match version {
-            Some(VersionOrModuleName::ModuleName(module_name)) => (None, Some(module_name)),
-            Some(VersionOrModuleName::Version(version)) => (Some(version), None),
-            None => (None, None),
-        };
+
+        // Then, the visibility of the module.
+        let visibility = parse_visibility(&mut tokens)?;
 
         // Next, an identifier (the desired module name)
-        // Only parse this if it wasn't parsed when attempting to get the version.
-        let mod_name = match mod_name {
-            Some(mod_name) => mod_name,
-            None => match tokens.next() {
-                Some(TokenTree::Ident(ident)) => Ok(ident),
-                Some(tree) => Err(Error::UnexpectedToken { tree }),
-                None => Err(Error::UnexpectedEndOfInput),
-            }?,
-        };
+        let mod_name = match tokens.next() {
+            Some(TokenTree::Ident(ident)) => Ok(ident),
+            Some(tree) => Err(Error::UnexpectedToken { tree }),
+            None => Err(Error::UnexpectedEndOfInput),
+        }?;
 
         // Followed by a comma
         helpers::consume_punct(',', &mut tokens)?;
@@ -230,6 +247,7 @@ pub fn serde_format_description(input: TokenStream) -> TokenStream {
         };
 
         Ok(serde_format_description::build(
+            visibility,
             mod_name,
             formattable,
             format,
diff --git a/time-macros/src/serde_format_description.rs b/time-macros/src/serde_format_description.rs
index 66ccafe88..ff71ea4ee 100644
--- a/time-macros/src/serde_format_description.rs
+++ b/time-macros/src/serde_format_description.rs
@@ -1,6 +1,7 @@
 use proc_macro::{Ident, TokenStream, TokenTree};
 
 pub(crate) fn build(
+    visibility: TokenStream,
     mod_name: Ident,
     ty: TokenTree,
     format: TokenStream,
@@ -150,9 +151,10 @@ pub(crate) fn build(
     };
 
     quote! {
-        mod #(mod_name) {
+        #S(visibility) mod #(mod_name) {
             use super::*;
-            // TODO Remove the prefix, forcing the user to import the type themself.
+            // TODO Remove the prefix, forcing the user to import the type themself. This must be
+            // done in a breaking change.
             use ::time::#(ty) as __TimeSerdeType;
 
             const fn description() -> impl #S(fd_traits) {
@@ -163,7 +165,9 @@ pub(crate) fn build(
             #S(serialize_primary)
             #S(deserialize_primary)
 
-            pub(super) mod option {
+            // While technically public, this is effectively the same visibility as the enclosing
+            // module, which has its visibility controlled by the user.
+            pub mod option {
                 use super::{description, __TimeSerdeType};
                 #S(deserialize_option_imports)
 

From ad945a97b90e950855d41b32081e266a12210f4e Mon Sep 17 00:00:00 2001
From: Jacob Pratt <jacob@jhpratt.dev>
Date: Tue, 11 Mar 2025 02:33:39 -0400
Subject: [PATCH 03/10] Fix UI tests, build on MSRV

---
 time-macros/src/lib.rs      | 12 +++++++++++-
 time/src/internal_macros.rs |  2 +-
 time/src/lib.rs             |  9 +++++++++
 time/src/serde/mod.rs       |  4 +++-
 4 files changed, 24 insertions(+), 3 deletions(-)

diff --git a/time-macros/src/lib.rs b/time-macros/src/lib.rs
index a90beee6a..300d77b21 100644
--- a/time-macros/src/lib.rs
+++ b/time-macros/src/lib.rs
@@ -75,7 +75,17 @@ enum FormatDescriptionVersion {
 fn parse_format_description_version<const NO_EQUALS_IS_MOD_NAME: bool>(
     iter: &mut PeekableTokenStreamIter,
 ) -> Result<Option<FormatDescriptionVersion>, Error> {
-    let version_ident = match iter.peek().ok_or(Error::UnexpectedEndOfInput)? {
+    let end_of_input_err = || {
+        if NO_EQUALS_IS_MOD_NAME {
+            Error::UnexpectedEndOfInput
+        } else {
+            Error::ExpectedString {
+                span_start: None,
+                span_end: None,
+            }
+        }
+    };
+    let version_ident = match iter.peek().ok_or_else(end_of_input_err)? {
         version @ TokenTree::Ident(ident) if ident.to_string() == "version" => {
             let version_ident = version.clone();
             iter.next(); // consume `version`
diff --git a/time/src/internal_macros.rs b/time/src/internal_macros.rs
index 1d8495e62..34b3339ad 100644
--- a/time/src/internal_macros.rs
+++ b/time/src/internal_macros.rs
@@ -63,7 +63,7 @@ macro_rules! div_floor {
                 // which is all-ones iff the signs differ, and 0 otherwise. Then by
                 // adding this mask (which corresponds to the signed value -1), we
                 // get our correction.
-                let correction = (this ^ rhs) >> (::core::mem::size_of_val(&this) * 8 - 1);
+                let correction = (this ^ rhs) >> ($crate::size_of_val(&this) * 8 - 1);
                 if r != 0 {
                     d + correction
                 } else {
diff --git a/time/src/lib.rs b/time/src/lib.rs
index be8639359..2c217f7ec 100644
--- a/time/src/lib.rs
+++ b/time/src/lib.rs
@@ -141,3 +141,12 @@ pub type Result<T> = core::result::Result<T, Error>;
 const fn expect_failed(message: &str) -> ! {
     panic!("{}", message)
 }
+
+/// Returns the size of the pointed-to value in bytes.
+///
+/// This is a `const fn` in the standard library starting in Rust 1.85. When MSRV is at least that,
+/// this can be removed.
+#[allow(unused_qualifications)] // added to prelude after MSRV
+const fn size_of_val<T>(_: &T) -> usize {
+    core::mem::size_of::<T>()
+}
diff --git a/time/src/serde/mod.rs b/time/src/serde/mod.rs
index 81962f511..a75d8850e 100644
--- a/time/src/serde/mod.rs
+++ b/time/src/serde/mod.rs
@@ -53,7 +53,9 @@ use serde::{Deserialize, Deserializer, Serialize, Serializer};
 )]
 /// This puts a module named `mod_name` in the current scope that can be used to format `Date`
 /// structs. A submodule (`mod_name::option`) is also generated for `Option<Date>`. Both
-/// modules are only visible in the current scope.
+/// modules are only visible in the current scope by default. To increase visibility, you can
+/// specify `pub`, `pub(crate)`, or similar before the module name:
+/// `serde::format_description!(pub mod_name, Date, FORMAT)`.
 ///
 /// The returned `Option` will contain a deserialized value if present and `None` if the field
 /// is present but the value is `null` (or the equivalent in other formats). To return `None`

From 1bc4ce077768aade42fd2d15b2ffb02d1623066b Mon Sep 17 00:00:00 2001
From: Jacob Pratt <jacob@jhpratt.dev>
Date: Thu, 13 Mar 2025 06:14:32 -0400
Subject: [PATCH 04/10] Update to `deranged` 0.4

---
 Cargo.lock | 53 +++++++++++++++++++++++++++++++++++++++++++++--------
 Cargo.toml |  2 +-
 2 files changed, 46 insertions(+), 9 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 15ce0b34d..56668a15a 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -147,13 +147,14 @@ checksum = "7a81dae078cea95a014a339291cec439d2f232ebe854a9d672b796c6afafa9b7"
 
 [[package]]
 name = "deranged"
-version = "0.3.11"
+version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b42b6fa04a440b495c8b04d0e71b707c585f83cb9cb28cf8cd0d976c315e31b4"
+checksum = "9c9e6a11ca8224451684bc0d7d5a7adbf8f2fd6887261a1cfc3c0432f9d4068e"
 dependencies = [
  "powerfmt",
  "quickcheck",
- "rand",
+ "rand 0.8.5",
+ "rand 0.9.0",
  "serde",
 ]
 
@@ -350,7 +351,7 @@ version = "1.0.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "588f6378e4dd99458b60ec275b4477add41ce4fa9f64dcba6f15adccb19b50d6"
 dependencies = [
- "rand",
+ "rand 0.8.5",
 ]
 
 [[package]]
@@ -381,7 +382,17 @@ checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404"
 dependencies = [
  "libc",
  "rand_chacha",
- "rand_core",
+ "rand_core 0.6.4",
+]
+
+[[package]]
+name = "rand"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3779b94aeb87e8bd4e834cee3650289ee9e0d5677f976ecdb6d219e5f4f6cd94"
+dependencies = [
+ "rand_core 0.9.3",
+ "zerocopy",
 ]
 
 [[package]]
@@ -391,7 +402,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88"
 dependencies = [
  "ppv-lite86",
- "rand_core",
+ "rand_core 0.6.4",
 ]
 
 [[package]]
@@ -403,6 +414,12 @@ dependencies = [
  "getrandom",
 ]
 
+[[package]]
+name = "rand_core"
+version = "0.9.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "99d9a13982dcf210057a8a78572b2217b667c3beacbf3a0d8b454f6f82837d38"
+
 [[package]]
 name = "regex"
 version = "1.11.1"
@@ -472,7 +489,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b3a8fb4672e840a587a66fc577a5491375df51ddb88f2a2c2a792598c326fe14"
 dependencies = [
  "quote",
- "rand",
+ "rand 0.8.5",
  "syn 2.0.96",
 ]
 
@@ -620,7 +637,7 @@ dependencies = [
  "powerfmt",
  "quickcheck",
  "quickcheck_macros",
- "rand",
+ "rand 0.8.5",
  "rstest",
  "rstest_reuse",
  "serde",
@@ -883,3 +900,23 @@ checksum = "c8d71a593cc5c42ad7876e2c1fda56f314f3754c084128833e64f1345ff8a03a"
 dependencies = [
  "memchr",
 ]
+
+[[package]]
+name = "zerocopy"
+version = "0.8.23"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fd97444d05a4328b90e75e503a34bad781f14e28a823ad3557f0750df1ebcbc6"
+dependencies = [
+ "zerocopy-derive",
+]
+
+[[package]]
+name = "zerocopy-derive"
+version = "0.8.23"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6352c01d0edd5db859a63e2605f4ea3183ddbd15e2c4a9e7d32184df75e4f154"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.96",
+]
diff --git a/Cargo.toml b/Cargo.toml
index 1c5403775..2b7b9580a 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -8,7 +8,7 @@ time-core = { path = "time-core", version = "=0.1.3" }
 time-macros = { path = "time-macros", version = "=0.2.20" }
 
 criterion = { version = "0.5.1", default-features = false }
-deranged = { version = "0.3.9", default-features = false, features = [
+deranged = { version = "0.4.0", default-features = false, features = [
     "powerfmt",
 ] }
 itoa = "1.0.1"

From 56187f13138f2d7b76911b289407ef6c255c1c42 Mon Sep 17 00:00:00 2001
From: Jacob Pratt <jacob@jhpratt.dev>
Date: Sat, 15 Mar 2025 02:23:34 -0400
Subject: [PATCH 05/10] Remove region markers

While neat, they're rarely used in practice.
---
 benchmarks/date.rs                            |  8 --------
 benchmarks/duration.rs                        | 14 -------------
 benchmarks/instant.rs                         |  4 ----
 benchmarks/offset_date_time.rs                | 10 ----------
 benchmarks/primitive_date_time.rs             |  4 ----
 benchmarks/time.rs                            |  6 ------
 benchmarks/utc_offset.rs                      |  6 ------
 tests/parse_format_description.rs             |  2 --
 time/src/date.rs                              | 16 ---------------
 time/src/duration.rs                          | 16 ---------------
 time/src/format_description/modifier.rs       |  6 ------
 .../format_description/owned_format_item.rs   |  6 ------
 time/src/formatting/formattable.rs            |  4 ----
 time/src/formatting/mod.rs                    |  6 ------
 time/src/instant.rs                           |  6 ------
 time/src/offset_date_time.rs                  | 20 -------------------
 time/src/parsing/component.rs                 |  6 ------
 time/src/parsing/parsable.rs                  |  4 ----
 time/src/primitive_date_time.rs               | 18 -----------------
 time/src/serde/mod.rs                         | 18 -----------------
 time/src/time.rs                              | 12 -----------
 time/src/utc_date_time.rs                     | 20 -------------------
 time/src/utc_offset.rs                        | 10 ----------
 23 files changed, 222 deletions(-)

diff --git a/benchmarks/date.rs b/benchmarks/date.rs
index 82abf4490..a97ffb4e0 100644
--- a/benchmarks/date.rs
+++ b/benchmarks/date.rs
@@ -35,7 +35,6 @@ const DATES: [Date; 24] = [
 setup_benchmark! {
     "Date",
 
-    // region: constructors
     fn from_calendar_date(ben: &mut Bencher<'_>) {
         ben.iter(|| Date::from_calendar_date(2019, Month::January, 1));
         ben.iter(|| Date::from_calendar_date(2019, Month::December, 31));
@@ -66,9 +65,7 @@ setup_benchmark! {
             }
         });
     }
-    // endregion constructors
 
-    // region: getters
     fn year(ben: &mut Bencher<'_>) {
         let d = date!(2019-002);
         ben.iter(|| d.year());
@@ -177,9 +174,7 @@ setup_benchmark! {
             }
         });
     }
-    // endregion getters
 
-    // region: attach time
     fn midnight(ben: &mut Bencher<'_>) {
         ben.iter(|| date!(1970-01-01).midnight());
     }
@@ -203,9 +198,7 @@ setup_benchmark! {
     fn with_hms_nano(ben: &mut Bencher<'_>) {
         ben.iter(|| date!(1970-01-01).with_hms_nano(0, 0, 0, 0));
     }
-    // endregion attach time
 
-    // region: trait impls
     fn add(ben: &mut Bencher<'_>) {
         let dt = 5.days();
         ben.iter(|| date!(2019-01-01) + dt);
@@ -281,5 +274,4 @@ setup_benchmark! {
         ben.iter(|| first.cmp(&second));
         ben.iter(|| second.cmp(&first));
     }
-    // endregion trait impls
 }
diff --git a/benchmarks/duration.rs b/benchmarks/duration.rs
index 558eba782..ddc6bd2b6 100644
--- a/benchmarks/duration.rs
+++ b/benchmarks/duration.rs
@@ -7,7 +7,6 @@ use time::Duration;
 setup_benchmark! {
     "Duration",
 
-    // region: is_{sign}
     fn is_zero(ben: &mut Bencher<'_>) {
         let a = (-1).nanoseconds();
         let b = 0.seconds();
@@ -34,9 +33,7 @@ setup_benchmark! {
         ben.iter(|| b.is_positive());
         ben.iter(|| c.is_positive());
     }
-    // endregion is_{sign}
 
-    // region: abs
     fn abs(ben: &mut Bencher<'_>) {
         let a = 1.seconds();
         let b = 0.seconds();
@@ -54,9 +51,7 @@ setup_benchmark! {
         ben.iter(|| b.unsigned_abs());
         ben.iter(|| c.unsigned_abs());
     }
-    // endregion abs
 
-    // region: constructors
     fn new(ben: &mut Bencher<'_>) {
         ben.iter(|| Duration::new(1, 0));
         ben.iter(|| Duration::new(-1, 0));
@@ -172,9 +167,7 @@ setup_benchmark! {
         ben.iter(|| c.whole_weeks());
         ben.iter(|| d.whole_weeks());
     }
-    // endregion constructors
 
-    // region: getters
     fn whole_days(ben: &mut Bencher<'_>) {
         let a = Duration::days(1);
         let b = Duration::days(-1);
@@ -302,9 +295,7 @@ setup_benchmark! {
         ben.iter(|| a.subsec_nanoseconds());
         ben.iter(|| b.subsec_nanoseconds());
     }
-    // endregion getters
 
-    // region: checked arithmetic
     fn checked_add(ben: &mut Bencher<'_>) {
         let a = 5.seconds();
         let b = Duration::MAX;
@@ -345,9 +336,7 @@ setup_benchmark! {
         ben.iter(|| a.checked_div(2));
         ben.iter(|| a.checked_div(0));
     }
-    // endregion checked arithmetic
 
-    // region: saturating arithmetic
     fn saturating_add(ben: &mut Bencher<'_>) {
         let a = 5.seconds();
         let b = Duration::MAX;
@@ -399,9 +388,7 @@ setup_benchmark! {
         ben.iter(|| f.saturating_mul(-2));
         ben.iter(|| g.saturating_mul(-2));
     }
-    // endregion saturating arithmetic
 
-    // region: trait impls
     fn try_from_std_duration(ben: &mut Bencher<'_>) {
         let a = 0.std_seconds();
         let b = 1.std_seconds();
@@ -724,5 +711,4 @@ setup_benchmark! {
         ben.iter(|| d > a);
         ben.iter(|| e < c);
     }
-    // endregion trait impls
 }
diff --git a/benchmarks/instant.rs b/benchmarks/instant.rs
index f05af3487..2bb2d946d 100644
--- a/benchmarks/instant.rs
+++ b/benchmarks/instant.rs
@@ -9,7 +9,6 @@ use time::{Duration, Instant};
 setup_benchmark! {
     "Instant",
 
-    // region: checked arithmetic
     fn checked_add(ben: &mut Bencher<'_>) {
         let instant = Instant::now();
         let dt = 5.seconds();
@@ -21,9 +20,7 @@ setup_benchmark! {
         let dt = 5.seconds();
         ben.iter(|| instant.checked_sub(dt));
     }
-    // endregion checked arithmetic
 
-    // region: trait impls
     fn sub(ben: &mut Bencher<'_>) {
         let start: Instant = Instant::now();
         let end: Instant = start + 1.milliseconds();
@@ -89,5 +86,4 @@ setup_benchmark! {
             [|instant| *instant -= dt]
         );
     }
-    // endregion trait impls
 }
diff --git a/benchmarks/offset_date_time.rs b/benchmarks/offset_date_time.rs
index 92a9695eb..dbdd07a5d 100644
--- a/benchmarks/offset_date_time.rs
+++ b/benchmarks/offset_date_time.rs
@@ -8,7 +8,6 @@ use time::OffsetDateTime;
 setup_benchmark! {
     "OffsetDateTime",
 
-    // region: now
     fn now_utc(ben: &mut Bencher<'_>) {
         ben.iter(OffsetDateTime::now_utc);
     }
@@ -16,14 +15,12 @@ setup_benchmark! {
     fn now_local(ben: &mut Bencher<'_>) {
         ben.iter(OffsetDateTime::now_local);
     }
-    // endregion now
 
     fn to_offset(ben: &mut Bencher<'_>) {
         ben.iter(|| datetime!(2000-01-01 0:00 +11).to_offset(offset!(-5)));
         ben.iter(|| datetime!(2000-01-01 0:00 +11).to_offset(offset!(-8)));
     }
 
-    // region: constructors
     fn from_unix_timestamp(ben: &mut Bencher<'_>) {
         ben.iter(|| OffsetDateTime::from_unix_timestamp(0));
         ben.iter(|| OffsetDateTime::from_unix_timestamp(1_546_300_800));
@@ -33,9 +30,7 @@ setup_benchmark! {
         ben.iter(|| OffsetDateTime::from_unix_timestamp_nanos(0));
         ben.iter(|| OffsetDateTime::from_unix_timestamp_nanos(1_546_300_800_000_000_000));
     }
-    // endregion constructors
 
-    // region: getters
     fn offset(ben: &mut Bencher<'_>) {
         ben.iter(|| datetime!(2019-01-01 0:00 UTC).offset());
         ben.iter(|| datetime!(2019-01-01 0:00 +1).offset());
@@ -88,9 +83,7 @@ setup_benchmark! {
         ben.iter(|| datetime!(2019-01-01 0:00 UTC).second());
         ben.iter(|| datetime!(2018-12-31 23:00 -1).second());
     }
-    // endregion getters
 
-    // region: replacement
     fn replace_time(ben: &mut Bencher<'_>) {
         ben.iter(|| datetime!(2020-01-01 5:00 UTC).replace_time(time!(12:00)));
         ben.iter(|| datetime!(2020-01-01 12:00 -5).replace_time(time!(7:00)));
@@ -110,9 +103,7 @@ setup_benchmark! {
     fn replace_offset(ben: &mut Bencher<'_>) {
         ben.iter(|| datetime!(2020-01-01 0:00 UTC).replace_offset(offset!(-5)));
     }
-    // endregion replacement
 
-    // region: trait impls
     fn partial_eq(ben: &mut Bencher<'_>) {
         ben.iter(|| datetime!(1999-12-31 23:00 -1) == datetime!(2000-01-01 0:00 UTC));
     }
@@ -425,5 +416,4 @@ setup_benchmark! {
         ben.iter(|| SystemTime::from(b));
         ben.iter(|| SystemTime::from(c));
     }
-    // endregion trait impls
 }
diff --git a/benchmarks/primitive_date_time.rs b/benchmarks/primitive_date_time.rs
index a45130ee2..679846d64 100644
--- a/benchmarks/primitive_date_time.rs
+++ b/benchmarks/primitive_date_time.rs
@@ -8,7 +8,6 @@ setup_benchmark! {
     // All getters are trivially dispatched to the relevant field, and do not need to be benchmarked
     // a second time.
 
-    // region: attach offset
     fn assume_offset(ben: &mut Bencher<'_>) {
         ben.iter(|| datetime!(2019-01-01 0:00).assume_offset(offset!(UTC)));
         ben.iter(|| datetime!(2019-01-01 0:00).assume_offset(offset!(-1)));
@@ -17,9 +16,7 @@ setup_benchmark! {
     fn assume_utc(ben: &mut Bencher<'_>) {
         ben.iter(|| datetime!(2019-01-01 0:00).assume_utc());
     }
-    // endregion attach offset
 
-    // region: trait impls
     fn add_duration(ben: &mut Bencher<'_>) {
         let a = 5.days();
         let b = 1.days();
@@ -144,5 +141,4 @@ setup_benchmark! {
         ben.iter(|| datetime!(2019-01-01 0:00:01).partial_cmp(&datetime!(2019-01-01 0:00)));
         ben.iter(|| datetime!(2019-01-01 0:00:00.000_000_001).partial_cmp(&datetime!(2019-01-01 0:00)));
     }
-    // endregion trait impls
 }
diff --git a/benchmarks/time.rs b/benchmarks/time.rs
index 884e173e8..4fec5f107 100644
--- a/benchmarks/time.rs
+++ b/benchmarks/time.rs
@@ -8,7 +8,6 @@ use time::Time;
 setup_benchmark! {
     "Time",
 
-    // region: constructors
     fn from_hms(ben: &mut Bencher<'_>) {
         ben.iter(|| Time::from_hms(1, 2, 3));
     }
@@ -24,9 +23,7 @@ setup_benchmark! {
     fn from_hms_nano(ben: &mut Bencher<'_>) {
         ben.iter(|| Time::from_hms_nano(1, 2, 3, 4));
     }
-    // endregion constructors
 
-    // region: getters
     fn as_hms(ben: &mut Bencher<'_>) {
         ben.iter(|| Time::MIDNIGHT.as_hms());
     }
@@ -66,9 +63,7 @@ setup_benchmark! {
     fn nanosecond(ben: &mut Bencher<'_>) {
         ben.iter(|| Time::MIDNIGHT.nanosecond());
     }
-    // endregion getters
 
-    // region: trait impls
     fn add_duration(ben: &mut Bencher<'_>) {
         let a = 1.milliseconds();
         let b = 1.seconds();
@@ -267,5 +262,4 @@ setup_benchmark! {
             criterion::BatchSize::SmallInput
         )
     }
-    // endregion trait impls
 }
diff --git a/benchmarks/utc_offset.rs b/benchmarks/utc_offset.rs
index e96f7175d..2e456d02f 100644
--- a/benchmarks/utc_offset.rs
+++ b/benchmarks/utc_offset.rs
@@ -4,7 +4,6 @@ use time::{OffsetDateTime, UtcOffset};
 setup_benchmark! {
     "UtcOffset",
 
-    // region: constructors
     fn from_hms(ben: &mut Bencher<'_>) {
         ben.iter(|| UtcOffset::from_hms(0, 0, 0));
     }
@@ -12,9 +11,7 @@ setup_benchmark! {
     fn from_whole_seconds(ben: &mut Bencher<'_>) {
         ben.iter(|| UtcOffset::from_whole_seconds(0));
     }
-    // endregion constructors
 
-    // region: getters
     fn as_hms(ben: &mut Bencher<'_>) {
         ben.iter(|| UtcOffset::UTC.as_hms());
     }
@@ -38,9 +35,7 @@ setup_benchmark! {
     fn seconds_past_minute(ben: &mut Bencher<'_>) {
         ben.iter(|| UtcOffset::UTC.seconds_past_minute());
     }
-    // endregion getters
 
-    // region: is_{sign}
     fn is_utc(ben: &mut Bencher<'_>) {
         ben.iter(|| UtcOffset::UTC.is_utc());
     }
@@ -52,7 +47,6 @@ setup_benchmark! {
     fn is_negative(ben: &mut Bencher<'_>) {
         ben.iter(|| UtcOffset::UTC.is_negative());
     }
-    // endregion is_{sign}
 
     fn local_offset_at(ben: &mut Bencher<'_>) {
         ben.iter(|| UtcOffset::local_offset_at(OffsetDateTime::UNIX_EPOCH));
diff --git a/tests/parse_format_description.rs b/tests/parse_format_description.rs
index 11ae2c02f..a879d204b 100644
--- a/tests/parse_format_description.rs
+++ b/tests/parse_format_description.rs
@@ -209,7 +209,6 @@ fn errors() {
     }
 }
 
-// region: individual components
 macro_rules! placeholder {
     ($($x:tt)*) => {
         " {}"
@@ -451,7 +450,6 @@ fn ignore_component(ignore_count: M<NonZeroU16>) {
         ))])
     );
 }
-// endregion individual components
 
 #[rstest]
 fn optional() {
diff --git a/time/src/date.rs b/time/src/date.rs
index 0bf34088d..48e940574 100644
--- a/time/src/date.rs
+++ b/time/src/date.rs
@@ -73,7 +73,6 @@ impl Date {
     pub const MAX: Self =
         unsafe { Self::__from_ordinal_date_unchecked(MAX_YEAR, days_in_year(MAX_YEAR)) };
 
-    // region: constructors
     /// Construct a `Date` from its internal representation, the validity of which must be
     /// guaranteed by the caller.
     ///
@@ -319,9 +318,7 @@ impl Date {
         // number is in range.
         unsafe { Self::from_parts(y_g, is_leap_year, ordinal as _) }
     }
-    // endregion constructors
 
-    // region: getters
     /// Whether `is_leap_year(self.year())` is `true`.
     ///
     /// This method is optimized to take advantage of the fact that the value is pre-computed upon
@@ -744,9 +741,7 @@ impl Date {
         let days_before_year = (1461 * adj_year as i64 / 4) as i32 - century + century / 4;
         days_before_year + ordinal as i32 - 363_521_075
     }
-    // endregion getters
 
-    // region: checked arithmetic
     /// Computes `self + duration`, returning `None` if an overflow occurred.
     ///
     /// ```rust
@@ -982,9 +977,7 @@ impl Date {
         const_try_opt!(self.checked_prev_occurrence(weekday))
             .checked_sub(Duration::weeks(n as i64 - 1))
     }
-    // endregion: checked arithmetic
 
-    // region: saturating arithmetic
     /// Computes `self + duration`, saturating value on overflow.
     ///
     /// ```rust
@@ -1064,9 +1057,7 @@ impl Date {
             Self::MIN
         }
     }
-    // endregion saturating arithmetic
 
-    // region: replacement
     /// Replace the year. The month and day will be unchanged.
     ///
     /// ```rust
@@ -1193,10 +1184,8 @@ impl Date {
         // Safety: `ordinal` is in range.
         Ok(unsafe { Self::__from_ordinal_date_unchecked(self.year(), ordinal) })
     }
-    // endregion replacement
 }
 
-// region: attach time
 /// Methods to add a [`Time`] component, resulting in a [`PrimitiveDateTime`].
 impl Date {
     /// Create a [`PrimitiveDateTime`] using the existing date. The [`Time`] component will be set
@@ -1302,9 +1291,7 @@ impl Date {
         ))
     }
 }
-// endregion attach time
 
-// region: formatting & parsing
 #[cfg(feature = "formatting")]
 impl Date {
     /// Format the `Date` using the provided [format description](crate::format_description).
@@ -1441,9 +1428,7 @@ impl fmt::Debug for Date {
         fmt::Display::fmt(self, f)
     }
 }
-// endregion formatting & parsing
 
-// region: trait impls
 impl Add<Duration> for Date {
     type Output = Self;
 
@@ -1503,4 +1488,3 @@ impl Sub for Date {
         Duration::days((self.to_julian_day() - other.to_julian_day()).extend())
     }
 }
-// endregion trait impls
diff --git a/time/src/duration.rs b/time/src/duration.rs
index f3aa01903..8b4dc9582 100644
--- a/time/src/duration.rs
+++ b/time/src/duration.rs
@@ -188,7 +188,6 @@ macro_rules! try_from_secs {
 }
 
 impl Duration {
-    // region: constants
     /// Equivalent to `0.seconds()`.
     ///
     /// ```rust
@@ -266,9 +265,7 @@ impl Duration {
 
     /// The maximum possible duration. Adding any positive duration to this will cause an overflow.
     pub const MAX: Self = Self::new_ranged(i64::MAX, Nanoseconds::MAX);
-    // endregion constants
 
-    // region: is_{sign}
     /// Check if a duration is exactly zero.
     ///
     /// ```rust
@@ -303,9 +300,7 @@ impl Duration {
     pub const fn is_positive(self) -> bool {
         self.seconds > 0 || self.nanoseconds.get() > 0
     }
-    // endregion is_{sign}
 
-    // region: abs
     /// Get the absolute value of the duration.
     ///
     /// This method saturates the returned value if it would otherwise overflow.
@@ -338,9 +333,7 @@ impl Duration {
             self.nanoseconds.get().unsigned_abs(),
         )
     }
-    // endregion abs
 
-    // region: constructors
     /// Create a new `Duration` without checking the validity of the components.
     ///
     /// # Safety
@@ -751,9 +744,7 @@ impl Duration {
         // Safety: `nanoseconds` is guaranteed to be in range because of the modulus above.
         unsafe { Self::new_unchecked(seconds as _, nanoseconds as _) }
     }
-    // endregion constructors
 
-    // region: getters
     /// Get the number of whole weeks in the duration.
     ///
     /// ```rust
@@ -927,9 +918,7 @@ impl Duration {
     pub(crate) const fn subsec_nanoseconds_ranged(self) -> Nanoseconds {
         self.nanoseconds
     }
-    // endregion getters
 
-    // region: checked arithmetic
     /// Computes `self + rhs`, returning `None` if an overflow occurred.
     ///
     /// ```rust
@@ -1042,9 +1031,7 @@ impl Duration {
             ))
         }
     }
-    // endregion checked arithmetic
 
-    // region: saturating arithmetic
     /// Computes `self + rhs`, saturating if an overflow occurred.
     ///
     /// ```rust
@@ -1162,7 +1149,6 @@ impl Duration {
         // Safety: `nanoseconds` is guaranteed to be in range because of to the modulus above.
         unsafe { Self::new_unchecked(seconds, nanoseconds) }
     }
-    // endregion saturating arithmetic
 
     /// Runs a closure, returning the duration of time it took to run. The return value of the
     /// closure is provided in the second part of the tuple.
@@ -1182,7 +1168,6 @@ impl Duration {
     }
 }
 
-// region: trait impls
 /// The format returned by this implementation is not stable and must not be relied upon.
 ///
 /// By default this produces an exact, full-precision printout of the duration.
@@ -1573,4 +1558,3 @@ impl<'a> Sum<&'a Self> for Duration {
         iter.copied().sum()
     }
 }
-// endregion trait impls
diff --git a/time/src/format_description/modifier.rs b/time/src/format_description/modifier.rs
index f946a9030..82fca8057 100644
--- a/time/src/format_description/modifier.rs
+++ b/time/src/format_description/modifier.rs
@@ -2,7 +2,6 @@
 
 use core::num::NonZeroU16;
 
-// region: date modifiers
 /// Day of the month.
 #[non_exhaustive]
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
@@ -137,9 +136,7 @@ pub struct Year {
     /// Whether the `+` sign is present when a positive year contains fewer than five digits.
     pub sign_is_mandatory: bool,
 }
-// endregion date modifiers
 
-// region: time modifiers
 /// Hour of the day.
 #[non_exhaustive]
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
@@ -212,9 +209,7 @@ pub struct Subsecond {
     /// How many digits are present in the component?
     pub digits: SubsecondDigits,
 }
-// endregion time modifiers
 
-// region: offset modifiers
 /// Hour of the UTC offset.
 #[non_exhaustive]
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
@@ -240,7 +235,6 @@ pub struct OffsetSecond {
     /// The padding to obtain the minimum width.
     pub padding: Padding,
 }
-// endregion offset modifiers
 
 /// Type of padding to ensure a minimum width.
 #[non_exhaustive]
diff --git a/time/src/format_description/owned_format_item.rs b/time/src/format_description/owned_format_item.rs
index 31ea9f90b..391e76f09 100644
--- a/time/src/format_description/owned_format_item.rs
+++ b/time/src/format_description/owned_format_item.rs
@@ -45,7 +45,6 @@ impl fmt::Debug for OwnedFormatItem {
     }
 }
 
-// region: conversions from FormatItem
 impl From<BorrowedFormatItem<'_>> for OwnedFormatItem {
     fn from(item: BorrowedFormatItem<'_>) -> Self {
         (&item).into()
@@ -99,9 +98,7 @@ impl<'a, T: AsRef<[BorrowedFormatItem<'a>]> + ?Sized> From<&T> for OwnedFormatIt
         )
     }
 }
-// endregion conversions from FormatItem
 
-// region: from variants
 impl From<Component> for OwnedFormatItem {
     fn from(component: Component) -> Self {
         Self::Component(component)
@@ -135,9 +132,7 @@ impl TryFrom<OwnedFormatItem> for Vec<OwnedFormatItem> {
         }
     }
 }
-// endregion from variants
 
-// region: equality
 impl PartialEq<Component> for OwnedFormatItem {
     fn eq(&self, rhs: &Component) -> bool {
         matches!(self, Self::Component(component) if component == rhs)
@@ -161,4 +156,3 @@ impl PartialEq<OwnedFormatItem> for &[OwnedFormatItem] {
         rhs == self
     }
 }
-// endregion equality
diff --git a/time/src/formatting/formattable.rs b/time/src/formatting/formattable.rs
index e06f78dac..7d1ce031f 100644
--- a/time/src/formatting/formattable.rs
+++ b/time/src/formatting/formattable.rs
@@ -62,7 +62,6 @@ mod sealed {
     }
 }
 
-// region: custom formats
 impl sealed::Sealed for BorrowedFormatItem<'_> {
     fn format_into(
         &self,
@@ -151,9 +150,7 @@ where
         self.deref().format_into(output, date, time, offset)
     }
 }
-// endregion custom formats
 
-// region: well-known formats
 impl sealed::Sealed for Rfc2822 {
     fn format_into(
         &self,
@@ -313,4 +310,3 @@ impl<const CONFIG: EncodedConfig> sealed::Sealed for Iso8601<CONFIG> {
         Ok(bytes)
     }
 }
-// endregion well-known formats
diff --git a/time/src/formatting/mod.rs b/time/src/formatting/mod.rs
index 049505634..c38371073 100644
--- a/time/src/formatting/mod.rs
+++ b/time/src/formatting/mod.rs
@@ -199,7 +199,6 @@ pub(crate) fn format_component(
     })
 }
 
-// region: date formatters
 /// Format the day into the designated output.
 fn fmt_day(
     output: &mut (impl io::Write + ?Sized),
@@ -355,9 +354,7 @@ fn fmt_year(
     bytes += format_number(output, value.unsigned_abs(), padding)?;
     Ok(bytes)
 }
-// endregion date formatters
 
-// region: time formatters
 /// Format the hour into the designated output.
 fn fmt_hour(
     output: &mut (impl io::Write + ?Sized),
@@ -440,9 +437,7 @@ fn fmt_subsecond(
         format_number_pad_zero::<1>(output, nanos / 100_000_000)
     }
 }
-// endregion time formatters
 
-// region: offset formatters
 /// Format the offset hour into the designated output.
 fn fmt_offset_hour(
     output: &mut (impl io::Write + ?Sized),
@@ -479,7 +474,6 @@ fn fmt_offset_second(
 ) -> Result<usize, io::Error> {
     format_number::<2>(output, offset.seconds_past_minute().unsigned_abs(), padding)
 }
-// endregion offset formatters
 
 /// Format the Unix timestamp into the designated output.
 fn fmt_unix_timestamp(
diff --git a/time/src/instant.rs b/time/src/instant.rs
index bdce82678..662640079 100644
--- a/time/src/instant.rs
+++ b/time/src/instant.rs
@@ -38,7 +38,6 @@ use crate::Duration;
 pub struct Instant(pub StdInstant);
 
 impl Instant {
-    // region: delegation
     /// Returns an `Instant` corresponding to "now".
     ///
     /// ```rust
@@ -64,9 +63,7 @@ impl Instant {
     pub fn elapsed(self) -> Duration {
         Self::now() - self
     }
-    // endregion delegation
 
-    // region: checked arithmetic
     /// Returns `Some(t)` where `t` is the time `self + duration` if `t` can be represented as
     /// `Instant` (which means it's inside the bounds of the underlying data structure), `None`
     /// otherwise.
@@ -110,7 +107,6 @@ impl Instant {
             self.0.checked_add(duration.unsigned_abs()).map(Self)
         }
     }
-    // endregion checked arithmetic
 
     /// Obtain the inner [`std::time::Instant`].
     ///
@@ -125,7 +121,6 @@ impl Instant {
     }
 }
 
-// region: trait impls
 impl From<StdInstant> for Instant {
     fn from(instant: StdInstant) -> Self {
         Self(instant)
@@ -290,4 +285,3 @@ impl Borrow<StdInstant> for Instant {
         &self.0
     }
 }
-// endregion trait impls
diff --git a/time/src/offset_date_time.rs b/time/src/offset_date_time.rs
index 90eee3b56..c245a1cab 100644
--- a/time/src/offset_date_time.rs
+++ b/time/src/offset_date_time.rs
@@ -82,7 +82,6 @@ impl OffsetDateTime {
         UtcOffset::UTC,
     );
 
-    // region: now
     /// Create a new `OffsetDateTime` with the current date and time in UTC.
     ///
     /// ```rust
@@ -124,7 +123,6 @@ impl OffsetDateTime {
         let t = Self::now_utc();
         Ok(t.to_offset(UtcOffset::local_offset_at(t)?))
     }
-    // endregion now
 
     /// Create a new `OffsetDateTime` with the given [`Date`], [`Time`], and [`UtcOffset`].
     ///
@@ -337,7 +335,6 @@ impl OffsetDateTime {
         )
     }
 
-    // region: constructors
     /// Create an `OffsetDateTime` from the provided Unix timestamp. Calling `.offset()` on the
     /// resulting value is guaranteed to return UTC.
     ///
@@ -435,9 +432,7 @@ impl OffsetDateTime {
             UtcOffset::UTC,
         ))
     }
-    // endregion constructors
 
-    // region: getters
     /// Get the [`UtcOffset`].
     ///
     /// ```rust
@@ -517,7 +512,6 @@ impl OffsetDateTime {
         self.date_time().time()
     }
 
-    // region: date getters
     /// Get the year of the date in the stored offset.
     ///
     /// ```rust
@@ -718,9 +712,7 @@ impl OffsetDateTime {
     pub const fn to_julian_day(self) -> i32 {
         self.date().to_julian_day()
     }
-    // endregion date getters
 
-    // region: time getters
     /// Get the clock hour, minute, and second.
     ///
     /// ```rust
@@ -884,10 +876,7 @@ impl OffsetDateTime {
     pub const fn nanosecond(self) -> u32 {
         self.time().nanosecond()
     }
-    // endregion time getters
-    // endregion getters
 
-    // region: checked arithmetic
     /// Computes `self + duration`, returning `None` if an overflow occurred.
     ///
     /// ```
@@ -927,9 +916,7 @@ impl OffsetDateTime {
     pub const fn checked_sub(self, duration: Duration) -> Option<Self> {
         Some(const_try_opt!(self.date_time().checked_sub(duration)).assume_offset(self.offset()))
     }
-    // endregion: checked arithmetic
 
-    // region: saturating arithmetic
     /// Computes `self + duration`, saturating value on overflow.
     ///
     /// ```
@@ -1039,10 +1026,8 @@ impl OffsetDateTime {
             PrimitiveDateTime::MIN.assume_offset(self.offset())
         }
     }
-    // endregion: saturating arithmetic
 }
 
-// region: replacement
 /// Methods that replace part of the `OffsetDateTime`.
 impl OffsetDateTime {
     /// Replace the time, which is assumed to be in the stored offset. The date and offset
@@ -1286,9 +1271,7 @@ impl OffsetDateTime {
         )
     }
 }
-// endregion replacement
 
-// region: formatting & parsing
 #[cfg(feature = "formatting")]
 impl OffsetDateTime {
     /// Format the `OffsetDateTime` using the provided [format
@@ -1407,9 +1390,7 @@ impl fmt::Debug for OffsetDateTime {
         fmt::Display::fmt(self, f)
     }
 }
-// endregion formatting & parsing
 
-// region: trait impls
 impl Add<Duration> for OffsetDateTime {
     type Output = Self;
 
@@ -1670,4 +1651,3 @@ impl From<OffsetDateTime> for js_sys::Date {
         Self::new(&timestamp.into())
     }
 }
-// endregion trait impls
diff --git a/time/src/parsing/component.rs b/time/src/parsing/component.rs
index 8149f968b..796457046 100644
--- a/time/src/parsing/component.rs
+++ b/time/src/parsing/component.rs
@@ -13,7 +13,6 @@ use crate::parsing::combinator::{
 use crate::parsing::ParsedItem;
 use crate::{Month, Weekday};
 
-// region: date components
 /// Parse the "year" component of a `Date`.
 pub(crate) fn parse_year(
     input: &[u8],
@@ -212,9 +211,7 @@ pub(crate) fn parse_day(
 ) -> Option<ParsedItem<'_, NonZeroU8>> {
     exactly_n_digits_padded::<2, _>(modifiers.padding)(input)
 }
-// endregion date components
 
-// region: time components
 /// Indicate whether the hour is "am" or "pm".
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub(crate) enum Period {
@@ -297,9 +294,7 @@ pub(crate) fn parse_subsecond(
         }
     })
 }
-// endregion time components
 
-// region: offset components
 /// Parse the "hour" component of a `UtcOffset`.
 ///
 /// Returns the value and whether the value is negative. This is used for when "-0" is parsed.
@@ -337,7 +332,6 @@ pub(crate) fn parse_offset_second(
             .map(|offset_second| offset_second.cast_signed()),
     )
 }
-// endregion offset components
 
 /// Ignore the given number of bytes.
 pub(crate) fn parse_ignore(
diff --git a/time/src/parsing/parsable.rs b/time/src/parsing/parsable.rs
index a34322f4d..c631c5fe0 100644
--- a/time/src/parsing/parsable.rs
+++ b/time/src/parsing/parsable.rs
@@ -97,7 +97,6 @@ mod sealed {
     }
 }
 
-// region: custom formats
 impl sealed::Sealed for BorrowedFormatItem<'_> {
     fn parse_into<'a>(
         &self,
@@ -152,9 +151,7 @@ where
         self.deref().parse_into(input, parsed)
     }
 }
-// endregion custom formats
 
-// region: well-known formats
 impl sealed::Sealed for Rfc2822 {
     fn parse_into<'a>(
         &self,
@@ -801,4 +798,3 @@ impl<const CONFIG: EncodedConfig> sealed::Sealed for Iso8601<CONFIG> {
         Ok(input)
     }
 }
-// endregion well-known formats
diff --git a/time/src/primitive_date_time.rs b/time/src/primitive_date_time.rs
index 1e805d7ad..07c11cba3 100644
--- a/time/src/primitive_date_time.rs
+++ b/time/src/primitive_date_time.rs
@@ -106,7 +106,6 @@ impl PrimitiveDateTime {
         Self { date, time }
     }
 
-    // region: component getters
     /// Get the [`Date`] component of the `PrimitiveDateTime`.
     ///
     /// ```rust
@@ -126,9 +125,7 @@ impl PrimitiveDateTime {
     pub const fn time(self) -> Time {
         self.time
     }
-    // endregion component getters
 
-    // region: date getters
     /// Get the year of the date.
     ///
     /// ```rust
@@ -316,9 +313,7 @@ impl PrimitiveDateTime {
     pub const fn to_julian_day(self) -> i32 {
         self.date().to_julian_day()
     }
-    // endregion date getters
 
-    // region: time getters
     /// Get the clock hour, minute, and second.
     ///
     /// ```rust
@@ -455,9 +450,7 @@ impl PrimitiveDateTime {
     pub const fn nanosecond(self) -> u32 {
         self.time().nanosecond()
     }
-    // endregion time getters
 
-    // region: attach offset
     /// Assuming that the existing `PrimitiveDateTime` represents a moment in the provided
     /// [`UtcOffset`], return an [`OffsetDateTime`].
     ///
@@ -510,9 +503,7 @@ impl PrimitiveDateTime {
     pub const fn as_utc(self) -> UtcDateTime {
         UtcDateTime::from_primitive(self)
     }
-    // endregion attach offset
 
-    // region: checked arithmetic
     /// Computes `self + duration`, returning `None` if an overflow occurred.
     ///
     /// ```
@@ -572,9 +563,7 @@ impl PrimitiveDateTime {
             time,
         })
     }
-    // endregion: checked arithmetic
 
-    // region: saturating arithmetic
     /// Computes `self + duration`, saturating value on overflow.
     ///
     /// ```
@@ -634,10 +623,8 @@ impl PrimitiveDateTime {
             Self::MIN
         }
     }
-    // endregion: saturating arithmetic
 }
 
-// region: replacement
 /// Methods that replace part of the `PrimitiveDateTime`.
 impl PrimitiveDateTime {
     /// Replace the time, preserving the date.
@@ -861,9 +848,7 @@ impl PrimitiveDateTime {
         })
     }
 }
-// endregion replacement
 
-// region: formatting & parsing
 #[cfg(feature = "formatting")]
 impl PrimitiveDateTime {
     /// Format the `PrimitiveDateTime` using the provided [format
@@ -948,9 +933,7 @@ impl fmt::Debug for PrimitiveDateTime {
         fmt::Display::fmt(self, f)
     }
 }
-// endregion formatting & parsing
 
-// region: trait impls
 impl Add<Duration> for PrimitiveDateTime {
     type Output = Self;
 
@@ -1065,4 +1048,3 @@ impl Sub for PrimitiveDateTime {
         (self.date - rhs.date) + (self.time - rhs.time)
     }
 }
-// endregion trait impls
diff --git a/time/src/serde/mod.rs b/time/src/serde/mod.rs
index a75d8850e..72b437212 100644
--- a/time/src/serde/mod.rs
+++ b/time/src/serde/mod.rs
@@ -217,7 +217,6 @@ use crate::{
     Date, Duration, Month, OffsetDateTime, PrimitiveDateTime, Time, UtcDateTime, UtcOffset, Weekday,
 };
 
-// region: Date
 /// The format used when serializing and deserializing a human-readable `Date`.
 #[cfg(feature = "parsing")]
 const DATE_FORMAT: &[BorrowedFormatItem<'_>] = &[
@@ -251,9 +250,7 @@ impl<'a> Deserialize<'a> for Date {
         }
     }
 }
-// endregion date
 
-// region: Duration
 impl Serialize for Duration {
     fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
         #[cfg(feature = "serde-human-readable")]
@@ -279,9 +276,7 @@ impl<'a> Deserialize<'a> for Duration {
         }
     }
 }
-// endregion Duration
 
-// region: OffsetDateTime
 /// The format used when serializing and deserializing a human-readable `OffsetDateTime`.
 #[cfg(feature = "parsing")]
 const OFFSET_DATE_TIME_FORMAT: &[BorrowedFormatItem<'_>] = &[
@@ -326,9 +321,7 @@ impl<'a> Deserialize<'a> for OffsetDateTime {
         }
     }
 }
-// endregion OffsetDateTime
 
-// region: PrimitiveDateTime
 /// The format used when serializing and deserializing a human-readable `PrimitiveDateTime`.
 #[cfg(feature = "parsing")]
 const PRIMITIVE_DATE_TIME_FORMAT: &[BorrowedFormatItem<'_>] = &[
@@ -368,9 +361,7 @@ impl<'a> Deserialize<'a> for PrimitiveDateTime {
         }
     }
 }
-// endregion PrimitiveDateTime
 
-// region: UtcDateTime
 /// The format used when serializing and deserializing a human-readable `UtcDateTime`.
 #[cfg(feature = "parsing")]
 const UTC_DATE_TIME_FORMAT: &[BorrowedFormatItem<'_>] = PRIMITIVE_DATE_TIME_FORMAT;
@@ -406,9 +397,7 @@ impl<'a> Deserialize<'a> for UtcDateTime {
         }
     }
 }
-// endregion UtcDateTime
 
-// region: Time
 /// The format used when serializing and deserializing a human-readable `Time`.
 #[cfg(feature = "parsing")]
 const TIME_FORMAT: &[BorrowedFormatItem<'_>] = &[
@@ -444,9 +433,7 @@ impl<'a> Deserialize<'a> for Time {
         }
     }
 }
-// endregion Time
 
-// region: UtcOffset
 // FIXME: turn these constants into `const { ... }` blocks once we can depend on Rust 1.79.
 #[cfg(feature = "parsing")]
 const UTC_OFFSET_HOUR: modifier::OffsetHour = {
@@ -500,9 +487,7 @@ impl<'a> Deserialize<'a> for UtcOffset {
         }
     }
 }
-// endregion UtcOffset
 
-// region: Weekday
 impl Serialize for Weekday {
     fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
         #[cfg(feature = "serde-human-readable")]
@@ -525,9 +510,7 @@ impl<'a> Deserialize<'a> for Weekday {
         }
     }
 }
-// endregion Weekday
 
-// region: Month
 impl Serialize for Month {
     fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
         #[cfg(feature = "serde-human-readable")]
@@ -550,4 +533,3 @@ impl<'a> Deserialize<'a> for Month {
         }
     }
 }
-// endregion Month
diff --git a/time/src/time.rs b/time/src/time.rs
index e0756fe04..8283b504b 100644
--- a/time/src/time.rs
+++ b/time/src/time.rs
@@ -155,7 +155,6 @@ impl Time {
     pub const MAX: Self =
         Self::from_hms_nanos_ranged(Hours::MAX, Minutes::MAX, Seconds::MAX, Nanoseconds::MAX);
 
-    // region: constructors
     /// Create a `Time` from its components.
     ///
     /// # Safety
@@ -303,9 +302,7 @@ impl Time {
             ensure_ranged!(Nanoseconds: nanosecond),
         ))
     }
-    // endregion constructors
 
-    // region: getters
     /// Get the clock hour, minute, and second.
     ///
     /// ```rust
@@ -454,9 +451,7 @@ impl Time {
     pub const fn nanosecond(self) -> u32 {
         self.nanosecond.get()
     }
-    // endregion getters
 
-    // region: arithmetic helpers
     /// Add the sub-day time of the [`Duration`] to the `Time`. Wraps on overflow, returning whether
     /// the date is different.
     pub(crate) const fn adjusting_add(self, duration: Duration) -> (DateAdjustment, Self) {
@@ -591,9 +586,7 @@ impl Time {
             },
         )
     }
-    // endregion arithmetic helpers
 
-    // region: replacement
     /// Replace the clock hour.
     ///
     /// ```rust
@@ -706,10 +699,8 @@ impl Time {
         self.nanosecond = ensure_ranged!(Nanoseconds: nanosecond);
         Ok(self)
     }
-    // endregion replacement
 }
 
-// region: formatting & parsing
 #[cfg(feature = "formatting")]
 impl Time {
     /// Format the `Time` using the provided [format description](crate::format_description).
@@ -832,9 +823,7 @@ impl fmt::Debug for Time {
         fmt::Display::fmt(self, f)
     }
 }
-// endregion formatting & parsing
 
-// region: trait impls
 impl Add<Duration> for Time {
     type Output = Self;
 
@@ -946,4 +935,3 @@ impl Sub for Time {
         unsafe { Duration::new_unchecked(seconds, nanoseconds) }
     }
 }
-// endregion trait impls
diff --git a/time/src/utc_date_time.rs b/time/src/utc_date_time.rs
index 09ee5c2ca..061ebb8aa 100644
--- a/time/src/utc_date_time.rs
+++ b/time/src/utc_date_time.rs
@@ -113,7 +113,6 @@ impl UtcDateTime {
     /// ```
     pub const MAX: Self = Self::new(Date::MAX, Time::MAX);
 
-    // region: constructors
     /// Create a new `UtcDateTime` with the current date and time.
     ///
     /// ```rust
@@ -247,9 +246,7 @@ impl UtcDateTime {
             },
         ))
     }
-    // endregion constructors
 
-    // region: to_offset
     /// Convert the `UtcDateTime` from UTC to the provided [`UtcOffset`], returning an
     /// [`OffsetDateTime`].
     ///
@@ -351,9 +348,7 @@ impl UtcDateTime {
             },
         )
     }
-    // endregion to_offset
 
-    // region: getters
     /// Get the [Unix timestamp](https://en.wikipedia.org/wiki/Unix_time).
     ///
     /// ```rust
@@ -404,7 +399,6 @@ impl UtcDateTime {
         self.inner.time()
     }
 
-    // region: date getters
     /// Get the year of the date.
     ///
     /// ```rust
@@ -592,9 +586,7 @@ impl UtcDateTime {
     pub const fn to_julian_day(self) -> i32 {
         self.date().to_julian_day()
     }
-    // endregion date getters
 
-    // region: time getters
     /// Get the clock hour, minute, and second.
     ///
     /// ```rust
@@ -731,10 +723,7 @@ impl UtcDateTime {
     pub const fn nanosecond(self) -> u32 {
         self.time().nanosecond()
     }
-    // endregion time getters
-    // endregion getters
 
-    // region: checked arithmetic
     /// Computes `self + duration`, returning `None` if an overflow occurred.
     ///
     /// ```rust
@@ -770,9 +759,7 @@ impl UtcDateTime {
             .inner
             .checked_sub(duration))))
     }
-    // endregion checked arithmetic
 
-    // region: saturating arithmetic
     /// Computes `self + duration`, saturating value on overflow.
     ///
     /// ```rust
@@ -816,10 +803,8 @@ impl UtcDateTime {
     pub const fn saturating_sub(self, duration: Duration) -> Self {
         Self::from_primitive(self.inner.saturating_sub(duration))
     }
-    // endregion saturating arithmetic
 }
 
-// region: replacement
 /// Methods that replace part of the `UtcDateTime`.
 impl UtcDateTime {
     /// Replace the time, preserving the date.
@@ -1033,9 +1018,7 @@ impl UtcDateTime {
             .replace_nanosecond(nanosecond))))
     }
 }
-// endregion replacement
 
-// region: formatting & parsing
 #[cfg(feature = "formatting")]
 impl UtcDateTime {
     /// Format the `UtcDateTime` using the provided [format
@@ -1143,9 +1126,7 @@ impl fmt::Debug for UtcDateTime {
         fmt::Display::fmt(self, f)
     }
 }
-// endregion formatting & parsing
 
-// region: trait impls
 impl Add<Duration> for UtcDateTime {
     type Output = Self;
 
@@ -1413,4 +1394,3 @@ impl From<UtcDateTime> for js_sys::Date {
         Self::new(&timestamp.into())
     }
 }
-// endregion trait impls
diff --git a/time/src/utc_offset.rs b/time/src/utc_offset.rs
index d58ab3737..38eb18ec4 100644
--- a/time/src/utc_offset.rs
+++ b/time/src/utc_offset.rs
@@ -65,7 +65,6 @@ impl UtcOffset {
     /// ```
     pub const UTC: Self = Self::from_whole_seconds_ranged(WholeSeconds::new_static::<0>());
 
-    // region: constructors
     /// Create a `UtcOffset` representing an offset of the hours, minutes, and seconds provided, the
     /// validity of which must be guaranteed by the caller. All three parameters must have the same
     /// sign.
@@ -205,9 +204,7 @@ impl UtcOffset {
             )
         }
     }
-    // endregion constructors
 
-    // region: getters
     /// Obtain the UTC offset as its hours, minutes, and seconds. The sign of all three components
     /// will always match. A positive value indicates an offset to the east; a negative to the west.
     ///
@@ -290,9 +287,7 @@ impl UtcOffset {
     pub const fn seconds_past_minute(self) -> i8 {
         self.seconds.get()
     }
-    // endregion getters
 
-    // region: is_{sign}
     /// Check if the offset is exactly UTC.
     ///
     ///
@@ -329,9 +324,7 @@ impl UtcOffset {
     pub const fn is_negative(self) -> bool {
         self.hours.get() < 0 || self.minutes.get() < 0 || self.seconds.get() < 0
     }
-    // endregion is_{sign}
 
-    // region: local offset
     /// Attempt to obtain the system's UTC offset at a known moment in time. If the offset cannot be
     /// determined, an error is returned.
     ///
@@ -362,10 +355,8 @@ impl UtcOffset {
         let now = OffsetDateTime::now_utc();
         local_offset_at(now).ok_or(error::IndeterminateOffset)
     }
-    // endregion: local offset
 }
 
-// region: formatting & parsing
 #[cfg(feature = "formatting")]
 impl UtcOffset {
     /// Format the `UtcOffset` using the provided [format description](crate::format_description).
@@ -463,7 +454,6 @@ impl fmt::Debug for UtcOffset {
         fmt::Display::fmt(self, f)
     }
 }
-// endregion formatting & parsing
 
 impl Neg for UtcOffset {
     type Output = Self;

From 79a4b625c7640f13b839635f721f928f8d80e6f7 Mon Sep 17 00:00:00 2001
From: Jacob Pratt <jacob@jhpratt.dev>
Date: Sat, 15 Mar 2025 04:25:36 -0400
Subject: [PATCH 06/10] Move interop between datetime types to single mod

---
 time/src/duration.rs                          |  33 ++++
 .../src/interop/js_sys_date_offsetdatetime.rs |  27 +++
 time/src/interop/js_sys_date_utcdatetime.rs   |  26 +++
 time/src/interop/mod.rs                       |  28 +++
 time/src/interop/offsetdatetime_systemtime.rs |  75 +++++++
 .../src/interop/offsetdatetime_utcdatetime.rs |  68 +++++++
 time/src/interop/utcdatetime_systemtime.rs    |  75 +++++++
 time/src/lib.rs                               |   1 +
 time/src/offset_date_time.rs                  | 144 +-------------
 time/src/utc_date_time.rs                     | 187 +-----------------
 10 files changed, 341 insertions(+), 323 deletions(-)
 create mode 100644 time/src/interop/js_sys_date_offsetdatetime.rs
 create mode 100644 time/src/interop/js_sys_date_utcdatetime.rs
 create mode 100644 time/src/interop/mod.rs
 create mode 100644 time/src/interop/offsetdatetime_systemtime.rs
 create mode 100644 time/src/interop/offsetdatetime_utcdatetime.rs
 create mode 100644 time/src/interop/utcdatetime_systemtime.rs

diff --git a/time/src/duration.rs b/time/src/duration.rs
index 8b4dc9582..a7bccab65 100644
--- a/time/src/duration.rs
+++ b/time/src/duration.rs
@@ -5,6 +5,8 @@ use core::fmt;
 use core::iter::Sum;
 use core::ops::{Add, AddAssign, Div, Mul, Neg, Sub, SubAssign};
 use core::time::Duration as StdDuration;
+#[cfg(feature = "std")]
+use std::time::SystemTime;
 
 use deranged::RangedI32;
 use num_conv::prelude::*;
@@ -17,6 +19,8 @@ use crate::internal_macros::{
 #[cfg(feature = "std")]
 #[allow(deprecated)]
 use crate::Instant;
+#[cfg(feature = "std")]
+use crate::OffsetDateTime;
 
 /// By explicitly inserting this enum where padding is expected, the compiler is able to better
 /// perform niche value optimization.
@@ -1558,3 +1562,32 @@ impl<'a> Sum<&'a Self> for Duration {
         iter.copied().sum()
     }
 }
+
+#[cfg(feature = "std")]
+impl Add<Duration> for SystemTime {
+    type Output = Self;
+
+    fn add(self, duration: Duration) -> Self::Output {
+        if duration.is_zero() {
+            self
+        } else if duration.is_positive() {
+            self + duration.unsigned_abs()
+        } else {
+            debug_assert!(duration.is_negative());
+            self - duration.unsigned_abs()
+        }
+    }
+}
+
+impl_add_assign!(SystemTime: #[cfg(feature = "std")] Duration);
+
+#[cfg(feature = "std")]
+impl Sub<Duration> for SystemTime {
+    type Output = Self;
+
+    fn sub(self, duration: Duration) -> Self::Output {
+        (OffsetDateTime::from(self) - duration).into()
+    }
+}
+
+impl_sub_assign!(SystemTime: #[cfg(feature = "std")] Duration);
diff --git a/time/src/interop/js_sys_date_offsetdatetime.rs b/time/src/interop/js_sys_date_offsetdatetime.rs
new file mode 100644
index 000000000..ecbd601eb
--- /dev/null
+++ b/time/src/interop/js_sys_date_offsetdatetime.rs
@@ -0,0 +1,27 @@
+use num_conv::prelude::*;
+
+use crate::convert::*;
+use crate::OffsetDateTime;
+
+impl From<js_sys::Date> for OffsetDateTime {
+    /// # Panics
+    ///
+    /// This may panic if the timestamp can not be represented.
+    fn from(js_date: js_sys::Date) -> Self {
+        // get_time() returns milliseconds
+        let timestamp_nanos = js_date.get_time() as i128
+            * Nanosecond::per(Millisecond).cast_signed().extend::<i128>();
+        Self::from_unix_timestamp_nanos(timestamp_nanos)
+            .expect("invalid timestamp: Timestamp cannot fit in range")
+    }
+}
+
+impl From<OffsetDateTime> for js_sys::Date {
+    fn from(datetime: OffsetDateTime) -> Self {
+        // new Date() takes milliseconds
+        let timestamp = (datetime.unix_timestamp_nanos()
+            / Nanosecond::per(Millisecond).cast_signed().extend::<i128>())
+            as f64;
+        Self::new(&timestamp.into())
+    }
+}
diff --git a/time/src/interop/js_sys_date_utcdatetime.rs b/time/src/interop/js_sys_date_utcdatetime.rs
new file mode 100644
index 000000000..e387c6843
--- /dev/null
+++ b/time/src/interop/js_sys_date_utcdatetime.rs
@@ -0,0 +1,26 @@
+use num_conv::prelude::*;
+
+use crate::convert::*;
+use crate::UtcDateTime;
+
+impl From<js_sys::Date> for UtcDateTime {
+    /// # Panics
+    ///
+    /// This may panic if the timestamp can not be represented.
+    fn from(js_date: js_sys::Date) -> Self {
+        // get_time() returns milliseconds
+        let timestamp_nanos = (js_date.get_time() * Nanosecond::per(Millisecond) as f64) as i128;
+        Self::from_unix_timestamp_nanos(timestamp_nanos)
+            .expect("invalid timestamp: Timestamp cannot fit in range")
+    }
+}
+
+impl From<UtcDateTime> for js_sys::Date {
+    fn from(datetime: UtcDateTime) -> Self {
+        // new Date() takes milliseconds
+        let timestamp = (datetime.unix_timestamp_nanos()
+            / Nanosecond::per(Millisecond).cast_signed().extend::<i128>())
+            as f64;
+        Self::new(&timestamp.into())
+    }
+}
diff --git a/time/src/interop/mod.rs b/time/src/interop/mod.rs
new file mode 100644
index 000000000..d562663cc
--- /dev/null
+++ b/time/src/interop/mod.rs
@@ -0,0 +1,28 @@
+//! Comparison, arithmetic, and conversion between various types in `time` and the standard library.
+//!
+//! Currently, full interoperability is present between [`OffsetDateTime`](crate::OffsetDateTime),
+//! [`UtcDateTime`](crate::UtcDateTime), and [`SystemTime`](std::time::SystemTime). Partial
+//! interoperability is present with [`js_sys::Date`]. Note that
+//! [`PrimitiveDateTime`](crate::PrimitiveDateTime) is not interoperable with any of these types due
+//! to the lack of an associated UTC offset.
+
+// Module names should have the two types sorted in alphabetical order. This avoids any question
+// of which type should be the "primary" type in the module name.
+
+#[cfg(all(
+    target_family = "wasm",
+    not(any(target_os = "emscripten", target_os = "wasi")),
+    feature = "wasm-bindgen"
+))]
+mod js_sys_date_offsetdatetime;
+#[cfg(all(
+    target_family = "wasm",
+    not(any(target_os = "emscripten", target_os = "wasi")),
+    feature = "wasm-bindgen"
+))]
+mod js_sys_date_utcdatetime;
+#[cfg(feature = "std")]
+mod offsetdatetime_systemtime;
+mod offsetdatetime_utcdatetime;
+#[cfg(feature = "std")]
+mod utcdatetime_systemtime;
diff --git a/time/src/interop/offsetdatetime_systemtime.rs b/time/src/interop/offsetdatetime_systemtime.rs
new file mode 100644
index 000000000..21a5d7f16
--- /dev/null
+++ b/time/src/interop/offsetdatetime_systemtime.rs
@@ -0,0 +1,75 @@
+use core::cmp::Ordering;
+use core::ops::Sub;
+use std::time::SystemTime;
+
+use crate::{Duration, OffsetDateTime};
+
+impl Sub<SystemTime> for OffsetDateTime {
+    type Output = Duration;
+
+    /// # Panics
+    ///
+    /// This may panic if an overflow occurs.
+    fn sub(self, rhs: SystemTime) -> Self::Output {
+        self - Self::from(rhs)
+    }
+}
+
+impl Sub<OffsetDateTime> for SystemTime {
+    type Output = Duration;
+
+    /// # Panics
+    ///
+    /// This may panic if an overflow occurs.
+    fn sub(self, rhs: OffsetDateTime) -> Self::Output {
+        OffsetDateTime::from(self) - rhs
+    }
+}
+
+impl PartialEq<SystemTime> for OffsetDateTime {
+    fn eq(&self, rhs: &SystemTime) -> bool {
+        self == &Self::from(*rhs)
+    }
+}
+
+impl PartialEq<OffsetDateTime> for SystemTime {
+    fn eq(&self, rhs: &OffsetDateTime) -> bool {
+        &OffsetDateTime::from(*self) == rhs
+    }
+}
+
+impl PartialOrd<SystemTime> for OffsetDateTime {
+    fn partial_cmp(&self, other: &SystemTime) -> Option<Ordering> {
+        self.partial_cmp(&Self::from(*other))
+    }
+}
+
+impl PartialOrd<OffsetDateTime> for SystemTime {
+    fn partial_cmp(&self, other: &OffsetDateTime) -> Option<Ordering> {
+        OffsetDateTime::from(*self).partial_cmp(other)
+    }
+}
+
+impl From<SystemTime> for OffsetDateTime {
+    fn from(system_time: SystemTime) -> Self {
+        match system_time.duration_since(SystemTime::UNIX_EPOCH) {
+            Ok(duration) => Self::UNIX_EPOCH + duration,
+            Err(err) => Self::UNIX_EPOCH - err.duration(),
+        }
+    }
+}
+
+impl From<OffsetDateTime> for SystemTime {
+    fn from(datetime: OffsetDateTime) -> Self {
+        let duration = datetime - OffsetDateTime::UNIX_EPOCH;
+
+        if duration.is_zero() {
+            Self::UNIX_EPOCH
+        } else if duration.is_positive() {
+            Self::UNIX_EPOCH + duration.unsigned_abs()
+        } else {
+            debug_assert!(duration.is_negative());
+            Self::UNIX_EPOCH - duration.unsigned_abs()
+        }
+    }
+}
diff --git a/time/src/interop/offsetdatetime_utcdatetime.rs b/time/src/interop/offsetdatetime_utcdatetime.rs
new file mode 100644
index 000000000..34a4887d8
--- /dev/null
+++ b/time/src/interop/offsetdatetime_utcdatetime.rs
@@ -0,0 +1,68 @@
+use core::cmp::Ordering;
+use core::ops::Sub;
+
+use crate::{Duration, OffsetDateTime, UtcDateTime};
+
+impl Sub<OffsetDateTime> for UtcDateTime {
+    type Output = Duration;
+
+    /// # Panics
+    ///
+    /// This may panic if an overflow occurs.
+    fn sub(self, rhs: OffsetDateTime) -> Self::Output {
+        OffsetDateTime::from(self) - rhs
+    }
+}
+
+impl Sub<UtcDateTime> for OffsetDateTime {
+    type Output = Duration;
+
+    /// # Panics
+    ///
+    /// This may panic if an overflow occurs.
+    fn sub(self, rhs: UtcDateTime) -> Self::Output {
+        self - Self::from(rhs)
+    }
+}
+
+impl PartialEq<OffsetDateTime> for UtcDateTime {
+    fn eq(&self, other: &OffsetDateTime) -> bool {
+        OffsetDateTime::from(*self) == *other
+    }
+}
+
+impl PartialEq<UtcDateTime> for OffsetDateTime {
+    fn eq(&self, other: &UtcDateTime) -> bool {
+        *self == Self::from(*other)
+    }
+}
+
+impl PartialOrd<OffsetDateTime> for UtcDateTime {
+    fn partial_cmp(&self, other: &OffsetDateTime) -> Option<Ordering> {
+        OffsetDateTime::from(*self).partial_cmp(other)
+    }
+}
+
+impl PartialOrd<UtcDateTime> for OffsetDateTime {
+    fn partial_cmp(&self, other: &UtcDateTime) -> Option<Ordering> {
+        self.partial_cmp(&Self::from(*other))
+    }
+}
+
+impl From<OffsetDateTime> for UtcDateTime {
+    /// # Panics
+    ///
+    /// This may panic if an overflow occurs.
+    fn from(datetime: OffsetDateTime) -> Self {
+        datetime.to_utc()
+    }
+}
+
+impl From<UtcDateTime> for OffsetDateTime {
+    /// # Panics
+    ///
+    /// This may panic if an overflow occurs.
+    fn from(datetime: UtcDateTime) -> Self {
+        datetime.as_primitive().assume_utc()
+    }
+}
diff --git a/time/src/interop/utcdatetime_systemtime.rs b/time/src/interop/utcdatetime_systemtime.rs
new file mode 100644
index 000000000..7cfb44e10
--- /dev/null
+++ b/time/src/interop/utcdatetime_systemtime.rs
@@ -0,0 +1,75 @@
+use core::cmp::Ordering;
+use core::ops::Sub;
+use std::time::SystemTime;
+
+use crate::{Duration, UtcDateTime};
+
+impl Sub<SystemTime> for UtcDateTime {
+    type Output = Duration;
+
+    /// # Panics
+    ///
+    /// This may panic if an overflow occurs.
+    fn sub(self, rhs: SystemTime) -> Self::Output {
+        self - Self::from(rhs)
+    }
+}
+
+impl Sub<UtcDateTime> for SystemTime {
+    type Output = Duration;
+
+    /// # Panics
+    ///
+    /// This may panic if an overflow occurs.
+    fn sub(self, rhs: UtcDateTime) -> Self::Output {
+        UtcDateTime::from(self) - rhs
+    }
+}
+
+impl PartialEq<SystemTime> for UtcDateTime {
+    fn eq(&self, rhs: &SystemTime) -> bool {
+        self == &Self::from(*rhs)
+    }
+}
+
+impl PartialEq<UtcDateTime> for SystemTime {
+    fn eq(&self, rhs: &UtcDateTime) -> bool {
+        &UtcDateTime::from(*self) == rhs
+    }
+}
+
+impl PartialOrd<SystemTime> for UtcDateTime {
+    fn partial_cmp(&self, other: &SystemTime) -> Option<Ordering> {
+        self.partial_cmp(&Self::from(*other))
+    }
+}
+
+impl PartialOrd<UtcDateTime> for SystemTime {
+    fn partial_cmp(&self, other: &UtcDateTime) -> Option<Ordering> {
+        UtcDateTime::from(*self).partial_cmp(other)
+    }
+}
+
+impl From<SystemTime> for UtcDateTime {
+    fn from(system_time: SystemTime) -> Self {
+        match system_time.duration_since(SystemTime::UNIX_EPOCH) {
+            Ok(duration) => Self::UNIX_EPOCH + duration,
+            Err(err) => Self::UNIX_EPOCH - err.duration(),
+        }
+    }
+}
+
+impl From<UtcDateTime> for SystemTime {
+    fn from(datetime: UtcDateTime) -> Self {
+        let duration = datetime - UtcDateTime::UNIX_EPOCH;
+
+        if duration.is_zero() {
+            Self::UNIX_EPOCH
+        } else if duration.is_positive() {
+            Self::UNIX_EPOCH + duration.unsigned_abs()
+        } else {
+            debug_assert!(duration.is_negative());
+            Self::UNIX_EPOCH - duration.unsigned_abs()
+        }
+    }
+}
diff --git a/time/src/lib.rs b/time/src/lib.rs
index 2c217f7ec..d8765d177 100644
--- a/time/src/lib.rs
+++ b/time/src/lib.rs
@@ -92,6 +92,7 @@ mod hint;
 #[cfg(feature = "std")]
 mod instant;
 mod internal_macros;
+mod interop;
 #[cfg(feature = "macros")]
 pub mod macros;
 mod month;
diff --git a/time/src/offset_date_time.rs b/time/src/offset_date_time.rs
index c245a1cab..0e1ae081e 100644
--- a/time/src/offset_date_time.rs
+++ b/time/src/offset_date_time.rs
@@ -9,8 +9,6 @@ use core::ops::{Add, AddAssign, Sub, SubAssign};
 use core::time::Duration as StdDuration;
 #[cfg(feature = "formatting")]
 use std::io;
-#[cfg(feature = "std")]
-use std::time::SystemTime;
 
 use deranged::RangedI64;
 use num_conv::prelude::*;
@@ -106,7 +104,7 @@ impl OffsetDateTime {
             not(any(target_os = "emscripten", target_os = "wasi")),
             feature = "wasm-bindgen"
         )))]
-        SystemTime::now().into()
+        std::time::SystemTime::now().into()
     }
 
     /// Attempt to create a new `OffsetDateTime` with the current date and time in the local offset.
@@ -1511,143 +1509,3 @@ impl Sub for OffsetDateTime {
         base - adjustment
     }
 }
-
-#[cfg(feature = "std")]
-impl Sub<SystemTime> for OffsetDateTime {
-    type Output = Duration;
-
-    /// # Panics
-    ///
-    /// This may panic if an overflow occurs.
-    fn sub(self, rhs: SystemTime) -> Self::Output {
-        self - Self::from(rhs)
-    }
-}
-
-#[cfg(feature = "std")]
-impl Sub<OffsetDateTime> for SystemTime {
-    type Output = Duration;
-
-    /// # Panics
-    ///
-    /// This may panic if an overflow occurs.
-    fn sub(self, rhs: OffsetDateTime) -> Self::Output {
-        OffsetDateTime::from(self) - rhs
-    }
-}
-
-#[cfg(feature = "std")]
-impl Add<Duration> for SystemTime {
-    type Output = Self;
-
-    fn add(self, duration: Duration) -> Self::Output {
-        if duration.is_zero() {
-            self
-        } else if duration.is_positive() {
-            self + duration.unsigned_abs()
-        } else {
-            debug_assert!(duration.is_negative());
-            self - duration.unsigned_abs()
-        }
-    }
-}
-
-crate::internal_macros::impl_add_assign!(SystemTime: #[cfg(feature = "std")] Duration);
-
-#[cfg(feature = "std")]
-impl Sub<Duration> for SystemTime {
-    type Output = Self;
-
-    fn sub(self, duration: Duration) -> Self::Output {
-        (OffsetDateTime::from(self) - duration).into()
-    }
-}
-
-crate::internal_macros::impl_sub_assign!(SystemTime: #[cfg(feature = "std")] Duration);
-
-#[cfg(feature = "std")]
-impl PartialEq<SystemTime> for OffsetDateTime {
-    fn eq(&self, rhs: &SystemTime) -> bool {
-        self == &Self::from(*rhs)
-    }
-}
-
-#[cfg(feature = "std")]
-impl PartialEq<OffsetDateTime> for SystemTime {
-    fn eq(&self, rhs: &OffsetDateTime) -> bool {
-        &OffsetDateTime::from(*self) == rhs
-    }
-}
-
-#[cfg(feature = "std")]
-impl PartialOrd<SystemTime> for OffsetDateTime {
-    fn partial_cmp(&self, other: &SystemTime) -> Option<Ordering> {
-        self.partial_cmp(&Self::from(*other))
-    }
-}
-
-#[cfg(feature = "std")]
-impl PartialOrd<OffsetDateTime> for SystemTime {
-    fn partial_cmp(&self, other: &OffsetDateTime) -> Option<Ordering> {
-        OffsetDateTime::from(*self).partial_cmp(other)
-    }
-}
-
-#[cfg(feature = "std")]
-impl From<SystemTime> for OffsetDateTime {
-    fn from(system_time: SystemTime) -> Self {
-        match system_time.duration_since(SystemTime::UNIX_EPOCH) {
-            Ok(duration) => Self::UNIX_EPOCH + duration,
-            Err(err) => Self::UNIX_EPOCH - err.duration(),
-        }
-    }
-}
-
-#[cfg(feature = "std")]
-impl From<OffsetDateTime> for SystemTime {
-    fn from(datetime: OffsetDateTime) -> Self {
-        let duration = datetime - OffsetDateTime::UNIX_EPOCH;
-
-        if duration.is_zero() {
-            Self::UNIX_EPOCH
-        } else if duration.is_positive() {
-            Self::UNIX_EPOCH + duration.unsigned_abs()
-        } else {
-            debug_assert!(duration.is_negative());
-            Self::UNIX_EPOCH - duration.unsigned_abs()
-        }
-    }
-}
-
-#[cfg(all(
-    target_family = "wasm",
-    not(any(target_os = "emscripten", target_os = "wasi")),
-    feature = "wasm-bindgen"
-))]
-impl From<js_sys::Date> for OffsetDateTime {
-    /// # Panics
-    ///
-    /// This may panic if the timestamp can not be represented.
-    fn from(js_date: js_sys::Date) -> Self {
-        // get_time() returns milliseconds
-        let timestamp_nanos = js_date.get_time() as i128
-            * Nanosecond::per(Millisecond).cast_signed().extend::<i128>();
-        Self::from_unix_timestamp_nanos(timestamp_nanos)
-            .expect("invalid timestamp: Timestamp cannot fit in range")
-    }
-}
-
-#[cfg(all(
-    target_family = "wasm",
-    not(any(target_os = "emscripten", target_os = "wasi")),
-    feature = "wasm-bindgen"
-))]
-impl From<OffsetDateTime> for js_sys::Date {
-    fn from(datetime: OffsetDateTime) -> Self {
-        // new Date() takes milliseconds
-        let timestamp = (datetime.unix_timestamp_nanos()
-            / Nanosecond::per(Millisecond).cast_signed().extend::<i128>())
-            as f64;
-        Self::new(&timestamp.into())
-    }
-}
diff --git a/time/src/utc_date_time.rs b/time/src/utc_date_time.rs
index 061ebb8aa..e68574277 100644
--- a/time/src/utc_date_time.rs
+++ b/time/src/utc_date_time.rs
@@ -2,14 +2,11 @@
 
 #[cfg(feature = "formatting")]
 use alloc::string::String;
-use core::cmp::Ordering;
 use core::fmt;
 use core::ops::{Add, AddAssign, Sub, SubAssign};
 use core::time::Duration as StdDuration;
 #[cfg(feature = "formatting")]
 use std::io;
-#[cfg(feature = "std")]
-use std::time::SystemTime;
 
 use deranged::RangedI64;
 use powerfmt::ext::FormatterExt as _;
@@ -135,7 +132,7 @@ impl UtcDateTime {
             not(any(target_os = "emscripten", target_os = "wasi")),
             feature = "wasm-bindgen"
         )))]
-        SystemTime::now().into()
+        std::time::SystemTime::now().into()
     }
 
     /// Create a new `UtcDateTime` from the provided [`Date`] and [`Time`].
@@ -159,6 +156,12 @@ impl UtcDateTime {
         Self { inner: date_time }
     }
 
+    /// Obtain the [`PrimitiveDateTime`] that this `UtcDateTime` represents. The no-longer-attached
+    /// [`UtcOffset`] is assumed to be UTC.
+    pub(crate) const fn as_primitive(self) -> PrimitiveDateTime {
+        self.inner
+    }
+
     /// Create a `UtcDateTime` from the provided Unix timestamp.
     ///
     /// ```rust
@@ -1218,179 +1221,3 @@ impl Sub for UtcDateTime {
         self.inner.sub(rhs.inner)
     }
 }
-
-#[cfg(feature = "std")]
-impl Sub<SystemTime> for UtcDateTime {
-    type Output = Duration;
-
-    /// # Panics
-    ///
-    /// This may panic if an overflow occurs.
-    fn sub(self, rhs: SystemTime) -> Self::Output {
-        self - Self::from(rhs)
-    }
-}
-
-#[cfg(feature = "std")]
-impl Sub<UtcDateTime> for SystemTime {
-    type Output = Duration;
-
-    /// # Panics
-    ///
-    /// This may panic if an overflow occurs.
-    fn sub(self, rhs: UtcDateTime) -> Self::Output {
-        UtcDateTime::from(self) - rhs
-    }
-}
-
-impl Sub<OffsetDateTime> for UtcDateTime {
-    type Output = Duration;
-
-    /// # Panics
-    ///
-    /// This may panic if an overflow occurs.
-    fn sub(self, rhs: OffsetDateTime) -> Self::Output {
-        OffsetDateTime::from(self) - rhs
-    }
-}
-
-impl Sub<UtcDateTime> for OffsetDateTime {
-    type Output = Duration;
-
-    /// # Panics
-    ///
-    /// This may panic if an overflow occurs.
-    fn sub(self, rhs: UtcDateTime) -> Self::Output {
-        self - Self::from(rhs)
-    }
-}
-
-#[cfg(feature = "std")]
-impl PartialEq<SystemTime> for UtcDateTime {
-    fn eq(&self, rhs: &SystemTime) -> bool {
-        self == &Self::from(*rhs)
-    }
-}
-
-#[cfg(feature = "std")]
-impl PartialEq<UtcDateTime> for SystemTime {
-    fn eq(&self, rhs: &UtcDateTime) -> bool {
-        &UtcDateTime::from(*self) == rhs
-    }
-}
-
-impl PartialEq<OffsetDateTime> for UtcDateTime {
-    fn eq(&self, other: &OffsetDateTime) -> bool {
-        OffsetDateTime::from(*self) == *other
-    }
-}
-
-impl PartialEq<UtcDateTime> for OffsetDateTime {
-    fn eq(&self, other: &UtcDateTime) -> bool {
-        *self == Self::from(*other)
-    }
-}
-
-#[cfg(feature = "std")]
-impl PartialOrd<SystemTime> for UtcDateTime {
-    fn partial_cmp(&self, other: &SystemTime) -> Option<Ordering> {
-        self.partial_cmp(&Self::from(*other))
-    }
-}
-
-#[cfg(feature = "std")]
-impl PartialOrd<UtcDateTime> for SystemTime {
-    fn partial_cmp(&self, other: &UtcDateTime) -> Option<Ordering> {
-        UtcDateTime::from(*self).partial_cmp(other)
-    }
-}
-
-impl PartialOrd<OffsetDateTime> for UtcDateTime {
-    fn partial_cmp(&self, other: &OffsetDateTime) -> Option<Ordering> {
-        OffsetDateTime::from(*self).partial_cmp(other)
-    }
-}
-
-impl PartialOrd<UtcDateTime> for OffsetDateTime {
-    fn partial_cmp(&self, other: &UtcDateTime) -> Option<Ordering> {
-        self.partial_cmp(&Self::from(*other))
-    }
-}
-
-#[cfg(feature = "std")]
-impl From<SystemTime> for UtcDateTime {
-    fn from(system_time: SystemTime) -> Self {
-        match system_time.duration_since(SystemTime::UNIX_EPOCH) {
-            Ok(duration) => Self::UNIX_EPOCH + duration,
-            Err(err) => Self::UNIX_EPOCH - err.duration(),
-        }
-    }
-}
-
-#[cfg(feature = "std")]
-impl From<UtcDateTime> for SystemTime {
-    fn from(datetime: UtcDateTime) -> Self {
-        let duration = datetime - UtcDateTime::UNIX_EPOCH;
-
-        if duration.is_zero() {
-            Self::UNIX_EPOCH
-        } else if duration.is_positive() {
-            Self::UNIX_EPOCH + duration.unsigned_abs()
-        } else {
-            debug_assert!(duration.is_negative());
-            Self::UNIX_EPOCH - duration.unsigned_abs()
-        }
-    }
-}
-
-impl From<OffsetDateTime> for UtcDateTime {
-    /// # Panics
-    ///
-    /// This may panic if an overflow occurs.
-    fn from(datetime: OffsetDateTime) -> Self {
-        datetime.to_utc()
-    }
-}
-
-impl From<UtcDateTime> for OffsetDateTime {
-    /// # Panics
-    ///
-    /// This may panic if an overflow occurs.
-    fn from(datetime: UtcDateTime) -> Self {
-        datetime.inner.assume_utc()
-    }
-}
-
-#[cfg(all(
-    target_family = "wasm",
-    not(any(target_os = "emscripten", target_os = "wasi")),
-    feature = "wasm-bindgen"
-))]
-impl From<js_sys::Date> for UtcDateTime {
-    /// # Panics
-    ///
-    /// This may panic if the timestamp can not be represented.
-    fn from(js_date: js_sys::Date) -> Self {
-        // get_time() returns milliseconds
-        let timestamp_nanos = (js_date.get_time() * Nanosecond::per(Millisecond) as f64) as i128;
-        Self::from_unix_timestamp_nanos(timestamp_nanos)
-            .expect("invalid timestamp: Timestamp cannot fit in range")
-    }
-}
-
-#[cfg(all(
-    target_family = "wasm",
-    not(any(target_os = "emscripten", target_os = "wasi")),
-    feature = "wasm-bindgen"
-))]
-impl From<UtcDateTime> for js_sys::Date {
-    fn from(datetime: UtcDateTime) -> Self {
-        use num_conv::prelude::*;
-
-        // new Date() takes milliseconds
-        let timestamp = (datetime.unix_timestamp_nanos()
-            / Nanosecond::per(Millisecond).cast_signed().extend::<i128>())
-            as f64;
-        Self::new(&timestamp.into())
-    }
-}

From 84f3a75c447eb52e3f931ed202858975ea3252f6 Mon Sep 17 00:00:00 2001
From: Jacob Pratt <jacob@jhpratt.dev>
Date: Sat, 15 Mar 2025 04:35:58 -0400
Subject: [PATCH 07/10] Remove two-way conversion in arithmetic

---
 time/src/duration.rs | 11 ++++++++---
 1 file changed, 8 insertions(+), 3 deletions(-)

diff --git a/time/src/duration.rs b/time/src/duration.rs
index a7bccab65..3933afcba 100644
--- a/time/src/duration.rs
+++ b/time/src/duration.rs
@@ -19,8 +19,6 @@ use crate::internal_macros::{
 #[cfg(feature = "std")]
 #[allow(deprecated)]
 use crate::Instant;
-#[cfg(feature = "std")]
-use crate::OffsetDateTime;
 
 /// By explicitly inserting this enum where padding is expected, the compiler is able to better
 /// perform niche value optimization.
@@ -1586,7 +1584,14 @@ impl Sub<Duration> for SystemTime {
     type Output = Self;
 
     fn sub(self, duration: Duration) -> Self::Output {
-        (OffsetDateTime::from(self) - duration).into()
+        if duration.is_zero() {
+            self
+        } else if duration.is_positive() {
+            self - duration.unsigned_abs()
+        } else {
+            debug_assert!(duration.is_negative());
+            self + duration.unsigned_abs()
+        }
     }
 }
 

From c386cacfbbd98321f7d1571c7e68c8fb1b61a342 Mon Sep 17 00:00:00 2001
From: Jacob Pratt <jacob@jhpratt.dev>
Date: Tue, 18 Mar 2025 02:30:19 -0400
Subject: [PATCH 08/10] Move `days_in_month` to `time-core`

---
 time-core/src/hint.rs | 26 ++++++++++++++++++++++++++
 time-core/src/lib.rs  |  1 +
 time-core/src/util.rs | 25 +++++++++++++++++++++++++
 time/src/month.rs     | 13 ++-----------
 time/src/util.rs      |  4 ++--
 5 files changed, 56 insertions(+), 13 deletions(-)
 create mode 100644 time-core/src/hint.rs

diff --git a/time-core/src/hint.rs b/time-core/src/hint.rs
new file mode 100644
index 000000000..ded72d4c8
--- /dev/null
+++ b/time-core/src/hint.rs
@@ -0,0 +1,26 @@
+//! Hints to the compiler that affects how code should be emitted or optimized.
+
+#![allow(dead_code)] // may be used in the future and has minimal overhead
+
+/// Indicate that a given branch is **not** likely to be taken, relatively speaking.
+#[inline(always)]
+#[cold]
+pub(crate) const fn cold_path() {}
+
+/// Indicate that a given condition is likely to be true.
+#[inline(always)]
+pub(crate) const fn likely(b: bool) -> bool {
+    if !b {
+        cold_path();
+    }
+    b
+}
+
+/// Indicate that a given condition is likely to be false.
+#[inline(always)]
+pub(crate) const fn unlikely(b: bool) -> bool {
+    if b {
+        cold_path();
+    }
+    b
+}
diff --git a/time-core/src/lib.rs b/time-core/src/lib.rs
index 41c354786..3f4008420 100644
--- a/time-core/src/lib.rs
+++ b/time-core/src/lib.rs
@@ -8,4 +8,5 @@
 #![doc(test(attr(deny(warnings))))]
 
 pub mod convert;
+mod hint;
 pub mod util;
diff --git a/time-core/src/util.rs b/time-core/src/util.rs
index a1ebf94f8..4a002679b 100644
--- a/time-core/src/util.rs
+++ b/time-core/src/util.rs
@@ -1,5 +1,7 @@
 //! Utility functions.
 
+use crate::hint;
+
 /// Returns if the provided year is a leap year in the proleptic Gregorian calendar. Uses
 /// [astronomical year numbering](https://en.wikipedia.org/wiki/Astronomical_year_numbering).
 ///
@@ -61,3 +63,26 @@ pub const fn weeks_in_year(year: i32) -> u8 {
         _ => 52,
     }
 }
+
+/// Get the number of days in the month of a given year.
+///
+/// ```rust
+/// # use time_core::util::days_in_month;
+/// assert_eq!(days_in_month(2, 2020), 29);
+/// ```
+///
+/// Note: This function is not exposed by the `time` crate. It is an implementation detail.
+pub const fn days_in_month(month: u8, year: i32) -> u8 {
+    debug_assert!(month >= 1);
+    debug_assert!(month <= 12);
+
+    if hint::unlikely(month == 2) {
+        if is_leap_year(year) {
+            29
+        } else {
+            28
+        }
+    } else {
+        30 | month ^ (month >> 3)
+    }
+}
diff --git a/time/src/month.rs b/time/src/month.rs
index 978883e81..a621c9faa 100644
--- a/time/src/month.rs
+++ b/time/src/month.rs
@@ -7,7 +7,7 @@ use core::str::FromStr;
 use powerfmt::smart_display::{FormatterOptions, Metadata, SmartDisplay};
 
 use self::Month::*;
-use crate::{error, hint, util};
+use crate::{error, util};
 
 /// Months of the year.
 #[repr(u8)]
@@ -72,16 +72,7 @@ impl Month {
     /// assert_eq!(Month::February.length(2020), 29);
     /// ```
     pub const fn length(self, year: i32) -> u8 {
-        let val = self as u8;
-        if hint::unlikely(val == 2) {
-            if util::is_leap_year(year) {
-                29
-            } else {
-                28
-            }
-        } else {
-            30 | val ^ (val >> 3)
-        }
+        util::days_in_month(self, year)
     }
 
     /// Get the previous month.
diff --git a/time/src/util.rs b/time/src/util.rs
index 9093f3363..c5166a706 100644
--- a/time/src/util.rs
+++ b/time/src/util.rs
@@ -21,7 +21,7 @@ pub(crate) enum DateAdjustment {
 /// assert_eq!(util::days_in_month(Month::February, 2020), 29);
 /// ```
 pub const fn days_in_month(month: Month, year: i32) -> u8 {
-    month.length(year)
+    time_core::util::days_in_month(month as u8, year)
 }
 
 /// Get the number of days in the month of a given year.
@@ -36,7 +36,7 @@ pub const fn days_in_month(month: Month, year: i32) -> u8 {
     note = "use `days_in_month` or `Month::length` instead"
 )]
 pub const fn days_in_year_month(year: i32, month: Month) -> u8 {
-    month.length(year)
+    days_in_month(month, year)
 }
 
 /// Update time zone information from the system.

From 6de297be4a782e1a298e2b0fcd53c0ed0318b0b8 Mon Sep 17 00:00:00 2001
From: Jacob Pratt <jacob@jhpratt.dev>
Date: Tue, 18 Mar 2025 02:36:55 -0400
Subject: [PATCH 09/10] v0.3.40 release

---
 CHANGELOG.md           | 6 ++++++
 Cargo.lock             | 6 +++---
 Cargo.toml             | 4 ++--
 time-core/Cargo.toml   | 2 +-
 time-macros/Cargo.toml | 2 +-
 time/Cargo.toml        | 2 +-
 6 files changed, 14 insertions(+), 8 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 29ef2e87e..64eb3626b 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -6,6 +6,12 @@ The format is based on [Keep a Changelog]. This project adheres to [Semantic Ver
 
 ---
 
+## 0.3.40 [2025-03-18]
+
+### Added
+
+- Visibility modifiers may now be added to the `mod` generated by `time::sere::format_description!`.
+
 ## 0.3.39 [2025-03-06]
 
 ### Fixed
diff --git a/Cargo.lock b/Cargo.lock
index 56668a15a..dcf1d2358 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -625,7 +625,7 @@ dependencies = [
 
 [[package]]
 name = "time"
-version = "0.3.39"
+version = "0.3.40"
 dependencies = [
  "criterion",
  "deranged",
@@ -650,11 +650,11 @@ dependencies = [
 
 [[package]]
 name = "time-core"
-version = "0.1.3"
+version = "0.1.4"
 
 [[package]]
 name = "time-macros"
-version = "0.2.20"
+version = "0.2.21"
 dependencies = [
  "num-conv",
  "time-core",
diff --git a/Cargo.toml b/Cargo.toml
index 2b7b9580a..138086b10 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -4,8 +4,8 @@ members = ["time", "time-core", "time-macros"]
 resolver = "2"
 
 [workspace.dependencies]
-time-core = { path = "time-core", version = "=0.1.3" }
-time-macros = { path = "time-macros", version = "=0.2.20" }
+time-core = { path = "time-core", version = "=0.1.4" }
+time-macros = { path = "time-macros", version = "=0.2.21" }
 
 criterion = { version = "0.5.1", default-features = false }
 deranged = { version = "0.4.0", default-features = false, features = [
diff --git a/time-core/Cargo.toml b/time-core/Cargo.toml
index 37334a9de..5f13f4b9b 100644
--- a/time-core/Cargo.toml
+++ b/time-core/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "time-core"
-version = "0.1.3"
+version = "0.1.4"
 authors = ["Jacob Pratt <open-source@jhpratt.dev>", "Time contributors"]
 edition = "2021"
 rust-version = "1.67.1"
diff --git a/time-macros/Cargo.toml b/time-macros/Cargo.toml
index 88bc3f585..764510b09 100644
--- a/time-macros/Cargo.toml
+++ b/time-macros/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "time-macros"
-version = "0.2.20"
+version = "0.2.21"
 authors = ["Jacob Pratt <open-source@jhpratt.dev>", "Time contributors"]
 edition = "2021"
 rust-version = "1.67.1"
diff --git a/time/Cargo.toml b/time/Cargo.toml
index 628990a0b..e013a8937 100644
--- a/time/Cargo.toml
+++ b/time/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "time"
-version = "0.3.39"
+version = "0.3.40"
 authors = ["Jacob Pratt <open-source@jhpratt.dev>", "Time contributors"]
 edition = "2021"
 rust-version = "1.67.1"

From cc35dcfcde917bb833c114e2b4c00292a374c4ba Mon Sep 17 00:00:00 2001
From: Jacob Pratt <jacob@jhpratt.dev>
Date: Sun, 23 Mar 2025 17:24:11 -0400
Subject: [PATCH 10/10] v0.3.41 release

---
 CHANGELOG.md                                  |  7 +++
 Cargo.lock                                    |  8 ++--
 Cargo.toml                                    |  5 +-
 time-macros/Cargo.toml                        |  2 +-
 time-macros/src/format_description/ast.rs     |  6 +--
 time-macros/src/time.rs                       |  6 +--
 time/Cargo.toml                               |  2 +-
 time/src/date.rs                              | 46 +++++++++---------
 time/src/duration.rs                          | 34 ++++++-------
 time/src/ext/numerical_duration.rs            | 16 +++----
 time/src/ext/numerical_std_duration.rs        | 16 +++----
 time/src/format_description/parse/ast.rs      | 30 ++++++------
 .../format_description/parse/format_item.rs   | 14 +++---
 time/src/format_description/parse/lexer.rs    |  4 +-
 time/src/format_description/parse/strftime.rs |  8 ++--
 .../well_known/iso8601/adt_hack.rs            |  4 +-
 time/src/internal_macros.rs                   | 10 ++--
 time/src/month.rs                             |  4 +-
 time/src/offset_date_time.rs                  | 18 +++----
 time/src/parsing/iso8601.rs                   | 14 +++---
 time/src/parsing/parsed.rs                    |  8 ++--
 time/src/time.rs                              | 48 +++++++++----------
 time/src/utc_date_time.rs                     | 18 +++----
 time/src/utc_offset.rs                        |  6 +--
 time/src/weekday.rs                           |  2 +-
 25 files changed, 173 insertions(+), 163 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 64eb3626b..63a4f2b82 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -6,6 +6,13 @@ The format is based on [Keep a Changelog]. This project adheres to [Semantic Ver
 
 ---
 
+## 0.3.41 [2025-03-23]
+
+### Fixed
+
+- Compatibility with the latest release of `deranged`. This fix is permanent and covers future
+  similar changes upstream.
+
 ## 0.3.40 [2025-03-18]
 
 ### Added
diff --git a/Cargo.lock b/Cargo.lock
index dcf1d2358..36c62c71c 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -147,9 +147,9 @@ checksum = "7a81dae078cea95a014a339291cec439d2f232ebe854a9d672b796c6afafa9b7"
 
 [[package]]
 name = "deranged"
-version = "0.4.0"
+version = "0.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9c9e6a11ca8224451684bc0d7d5a7adbf8f2fd6887261a1cfc3c0432f9d4068e"
+checksum = "28cfac68e08048ae1883171632c2aef3ebc555621ae56fbccce1cbf22dd7f058"
 dependencies = [
  "powerfmt",
  "quickcheck",
@@ -625,7 +625,7 @@ dependencies = [
 
 [[package]]
 name = "time"
-version = "0.3.40"
+version = "0.3.41"
 dependencies = [
  "criterion",
  "deranged",
@@ -654,7 +654,7 @@ version = "0.1.4"
 
 [[package]]
 name = "time-macros"
-version = "0.2.21"
+version = "0.2.22"
 dependencies = [
  "num-conv",
  "time-core",
diff --git a/Cargo.toml b/Cargo.toml
index 138086b10..e65560c5f 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -5,7 +5,7 @@ resolver = "2"
 
 [workspace.dependencies]
 time-core = { path = "time-core", version = "=0.1.4" }
-time-macros = { path = "time-macros", version = "=0.2.21" }
+time-macros = { path = "time-macros", version = "=0.2.22" }
 
 criterion = { version = "0.5.1", default-features = false }
 deranged = { version = "0.4.0", default-features = false, features = [
@@ -102,13 +102,14 @@ alloc-instead-of-core = "deny"
 std-instead-of-core = "deny"
 undocumented-unsafe-blocks = "deny"
 
-missing-docs-in-private-items = "warn"
 all = { level = "warn", priority = -1 }
+as-underscore = "warn"
 dbg-macro = "warn"
 decimal-literal-representation = "warn"
 explicit-auto-deref = "warn"
 get-unwrap = "warn"
 manual-let-else = "warn"
+missing-docs-in-private-items = "warn"
 missing-enforced-import-renames = "warn"
 nursery = { level = "warn", priority = -1 }
 obfuscated-if-else = "warn"
diff --git a/time-macros/Cargo.toml b/time-macros/Cargo.toml
index 764510b09..de302c1ce 100644
--- a/time-macros/Cargo.toml
+++ b/time-macros/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "time-macros"
-version = "0.2.21"
+version = "0.2.22"
 authors = ["Jacob Pratt <open-source@jhpratt.dev>", "Time contributors"]
 edition = "2021"
 rust-version = "1.67.1"
diff --git a/time-macros/src/format_description/ast.rs b/time-macros/src/format_description/ast.rs
index 4c3a19e5a..d5d0e5b57 100644
--- a/time-macros/src/format_description/ast.rs
+++ b/time-macros/src/format_description/ast.rs
@@ -210,9 +210,9 @@ fn parse_component<'a, I: Iterator<Item = Result<lexer::Token<'a>, Error>>, cons
 
         modifiers.push(Modifier {
             _leading_whitespace: unused(whitespace),
-            key: key.spanned(span.shrink_to_before(colon_index as _)),
-            _colon: unused(span.start.offset(colon_index as _)),
-            value: value.spanned(span.shrink_to_after(colon_index as _)),
+            key: key.spanned(span.shrink_to_before(colon_index as u32)),
+            _colon: unused(span.start.offset(colon_index as u32)),
+            value: value.spanned(span.shrink_to_after(colon_index as u32)),
         });
     };
 
diff --git a/time-macros/src/time.rs b/time-macros/src/time.rs
index 4e565c1de..971dfa687 100644
--- a/time-macros/src/time.rs
+++ b/time-macros/src/time.rs
@@ -87,7 +87,7 @@ pub(crate) fn parse(chars: &mut Peekable<token_stream::IntoIter>) -> Result<Time
             span_start: Some(minute_span),
             span_end: Some(minute_span),
         })
-    } else if second >= Second::per(Minute) as _ {
+    } else if second >= Second::per(Minute) as f64 {
         Err(Error::InvalidComponent {
             name: "second",
             value: second.to_string(),
@@ -98,8 +98,8 @@ pub(crate) fn parse(chars: &mut Peekable<token_stream::IntoIter>) -> Result<Time
         Ok(Time {
             hour,
             minute,
-            second: second.trunc() as _,
-            nanosecond: (second.fract() * Nanosecond::per(Second) as f64).round() as _,
+            second: second.trunc() as u8,
+            nanosecond: (second.fract() * Nanosecond::per(Second) as f64).round() as u32,
         })
     }
 }
diff --git a/time/Cargo.toml b/time/Cargo.toml
index e013a8937..d63988b54 100644
--- a/time/Cargo.toml
+++ b/time/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "time"
-version = "0.3.40"
+version = "0.3.41"
 authors = ["Jacob Pratt <open-source@jhpratt.dev>", "Time contributors"]
 edition = "2021"
 rust-version = "1.67.1"
diff --git a/time/src/date.rs b/time/src/date.rs
index 48e940574..3772c2dae 100644
--- a/time/src/date.rs
+++ b/time/src/date.rs
@@ -141,8 +141,8 @@ impl Date {
                 return Err(error::ComponentRange {
                     name: "day",
                     minimum: 1,
-                    maximum: month.length(year) as _,
-                    value: day as _,
+                    maximum: month.length(year) as i64,
+                    value: day as i64,
                     conditional_message: Some("for the given month and year"),
                 });
             }
@@ -179,8 +179,8 @@ impl Date {
                 return Err(error::ComponentRange {
                     name: "ordinal",
                     minimum: 1,
-                    maximum: days_in_year(year) as _,
-                    value: ordinal as _,
+                    maximum: days_in_year(year) as i64,
+                    value: ordinal as i64,
                     conditional_message: Some("for the given year"),
                 });
             }
@@ -216,8 +216,8 @@ impl Date {
                 return Err(error::ComponentRange {
                     name: "week",
                     minimum: 1,
-                    maximum: weeks_in_year(year) as _,
-                    value: week as _,
+                    maximum: weeks_in_year(year) as i64,
+                    value: week as i64,
                     conditional_message: Some("for the given year"),
                 });
             }
@@ -252,7 +252,7 @@ impl Date {
             }
         } else {
             // Safety: `ordinal` is not zero.
-            unsafe { Self::__from_ordinal_date_unchecked(year, ordinal as _) }
+            unsafe { Self::__from_ordinal_date_unchecked(year, ordinal as u16) }
         })
     }
 
@@ -316,7 +316,7 @@ impl Date {
 
         // Safety: `ordinal` is not zero and `is_leap_year` is correct, so long as the Julian day
         // number is in range.
-        unsafe { Self::from_parts(y_g, is_leap_year, ordinal as _) }
+        unsafe { Self::from_parts(y_g, is_leap_year, ordinal as u16) }
     }
 
     /// Whether `is_leap_year(self.year())` is `true`.
@@ -391,7 +391,7 @@ impl Date {
         let ordinal = ordinal - ordinal_adj;
         let month = (ordinal * 268 + 8031) >> 13;
         let days_in_preceding_months = (month * 3917 - 3866) >> 7;
-        (ordinal - days_in_preceding_months) as _
+        (ordinal - days_in_preceding_months) as u8
     }
 
     /// Get the day of the year.
@@ -404,14 +404,14 @@ impl Date {
     /// assert_eq!(date!(2019-12-31).ordinal(), 365);
     /// ```
     pub const fn ordinal(self) -> u16 {
-        (self.value.get() & 0x1FF) as _
+        (self.value.get() & 0x1FF) as u16
     }
 
     /// Get the ISO 8601 year and week number.
     pub(crate) const fn iso_year_week(self) -> (i32, u8) {
         let (year, ordinal) = self.to_ordinal_date();
 
-        match ((ordinal + 10 - self.weekday().number_from_monday() as u16) / 7) as _ {
+        match ((ordinal + 10 - self.weekday().number_from_monday() as u16) / 7) as u8 {
             0 => (year - 1, weeks_in_year(year - 1)),
             53 if weeks_in_year(year) == 52 => (year + 1, 1),
             week => (year, week),
@@ -446,7 +446,7 @@ impl Date {
     /// assert_eq!(date!(2021-01-01).sunday_based_week(), 0);
     /// ```
     pub const fn sunday_based_week(self) -> u8 {
-        ((self.ordinal() as i16 - self.weekday().number_days_from_sunday() as i16 + 6) / 7) as _
+        ((self.ordinal() as i16 - self.weekday().number_days_from_sunday() as i16 + 6) / 7) as u8
     }
 
     /// Get the week number where week 1 begins on the first Monday.
@@ -461,7 +461,7 @@ impl Date {
     /// assert_eq!(date!(2021-01-01).monday_based_week(), 0);
     /// ```
     pub const fn monday_based_week(self) -> u8 {
-        ((self.ordinal() as i16 - self.weekday().number_days_from_monday() as i16 + 6) / 7) as _
+        ((self.ordinal() as i16 - self.weekday().number_days_from_monday() as i16 + 6) / 7) as u8
     }
 
     /// Get the year, month, and day.
@@ -529,7 +529,7 @@ impl Date {
         let (year, ordinal) = self.to_ordinal_date();
         let weekday = self.weekday();
 
-        match ((ordinal + 10 - weekday.number_from_monday() as u16) / 7) as _ {
+        match ((ordinal + 10 - weekday.number_from_monday() as u16) / 7) as u8 {
             0 => (year - 1, weeks_in_year(year - 1), weekday),
             53 if weeks_in_year(year) == 52 => (year + 1, 1, weekday),
             week => (year, week, weekday),
@@ -779,7 +779,7 @@ impl Date {
             return None;
         }
 
-        let julian_day = const_try_opt!(self.to_julian_day().checked_add(whole_days as _));
+        let julian_day = const_try_opt!(self.to_julian_day().checked_add(whole_days as i32));
         if let Ok(date) = Self::from_julian_day(julian_day) {
             Some(date)
         } else {
@@ -822,7 +822,7 @@ impl Date {
             return None;
         }
 
-        let julian_day = const_try_opt!(self.to_julian_day().checked_add(whole_days as _));
+        let julian_day = const_try_opt!(self.to_julian_day().checked_add(whole_days as i32));
         if let Ok(date) = Self::from_julian_day(julian_day) {
             Some(date)
         } else {
@@ -867,7 +867,7 @@ impl Date {
             return None;
         }
 
-        let julian_day = const_try_opt!(self.to_julian_day().checked_sub(whole_days as _));
+        let julian_day = const_try_opt!(self.to_julian_day().checked_sub(whole_days as i32));
         if let Ok(date) = Self::from_julian_day(julian_day) {
             Some(date)
         } else {
@@ -910,7 +910,7 @@ impl Date {
             return None;
         }
 
-        let julian_day = const_try_opt!(self.to_julian_day().checked_sub(whole_days as _));
+        let julian_day = const_try_opt!(self.to_julian_day().checked_sub(whole_days as i32));
         if let Ok(date) = Self::from_julian_day(julian_day) {
             Some(date)
         } else {
@@ -1141,8 +1141,8 @@ impl Date {
                 return Err(error::ComponentRange {
                     name: "day",
                     minimum: 1,
-                    maximum: self.month().length(self.year()) as _,
-                    value: day as _,
+                    maximum: self.month().length(self.year()) as i64,
+                    value: day as i64,
                     conditional_message: Some("for the given month and year"),
                 });
             }
@@ -1152,7 +1152,7 @@ impl Date {
         Ok(unsafe {
             Self::__from_ordinal_date_unchecked(
                 self.year(),
-                (self.ordinal() as i16 - self.day() as i16 + day as i16) as _,
+                (self.ordinal() as i16 - self.day() as i16 + day as i16) as u16,
             )
         })
     }
@@ -1174,8 +1174,8 @@ impl Date {
                 return Err(error::ComponentRange {
                     name: "ordinal",
                     minimum: 1,
-                    maximum: days_in_year(self.year()) as _,
-                    value: ordinal as _,
+                    maximum: days_in_year(self.year()) as i64,
+                    value: ordinal as i64,
                     conditional_message: Some("for the given year"),
                 });
             }
diff --git a/time/src/duration.rs b/time/src/duration.rs
index 3933afcba..b86bfe7cf 100644
--- a/time/src/duration.rs
+++ b/time/src/duration.rs
@@ -437,7 +437,7 @@ impl Duration {
     /// This may panic if an overflow occurs.
     pub const fn weeks(weeks: i64) -> Self {
         Self::seconds(expect_opt!(
-            weeks.checked_mul(Second::per(Week) as _),
+            weeks.checked_mul(Second::per(Week) as i64),
             "overflow constructing `time::Duration`"
         ))
     }
@@ -455,7 +455,7 @@ impl Duration {
     /// This may panic if an overflow occurs.
     pub const fn days(days: i64) -> Self {
         Self::seconds(expect_opt!(
-            days.checked_mul(Second::per(Day) as _),
+            days.checked_mul(Second::per(Day) as i64),
             "overflow constructing `time::Duration`"
         ))
     }
@@ -473,7 +473,7 @@ impl Duration {
     /// This may panic if an overflow occurs.
     pub const fn hours(hours: i64) -> Self {
         Self::seconds(expect_opt!(
-            hours.checked_mul(Second::per(Hour) as _),
+            hours.checked_mul(Second::per(Hour) as i64),
             "overflow constructing `time::Duration`"
         ))
     }
@@ -491,7 +491,7 @@ impl Duration {
     /// This may panic if an overflow occurs.
     pub const fn minutes(minutes: i64) -> Self {
         Self::seconds(expect_opt!(
-            minutes.checked_mul(Second::per(Minute) as _),
+            minutes.checked_mul(Second::per(Minute) as i64),
             "overflow constructing `time::Duration`"
         ))
     }
@@ -691,7 +691,7 @@ impl Duration {
             Self::new_unchecked(
                 milliseconds / Millisecond::per(Second) as i64,
                 (milliseconds % Millisecond::per(Second) as i64
-                    * Nanosecond::per(Millisecond) as i64) as _,
+                    * Nanosecond::per(Millisecond) as i64) as i32,
             )
         }
     }
@@ -709,7 +709,7 @@ impl Duration {
             Self::new_unchecked(
                 microseconds / Microsecond::per(Second) as i64,
                 (microseconds % Microsecond::per(Second) as i64
-                    * Nanosecond::per(Microsecond) as i64) as _,
+                    * Nanosecond::per(Microsecond) as i64) as i32,
             )
         }
     }
@@ -726,7 +726,7 @@ impl Duration {
         unsafe {
             Self::new_unchecked(
                 nanoseconds / Nanosecond::per(Second) as i64,
-                (nanoseconds % Nanosecond::per(Second) as i64) as _,
+                (nanoseconds % Nanosecond::per(Second) as i64) as i32,
             )
         }
     }
@@ -744,7 +744,7 @@ impl Duration {
         }
 
         // Safety: `nanoseconds` is guaranteed to be in range because of the modulus above.
-        unsafe { Self::new_unchecked(seconds as _, nanoseconds as _) }
+        unsafe { Self::new_unchecked(seconds as i64, nanoseconds as i32) }
     }
 
     /// Get the number of whole weeks in the duration.
@@ -859,7 +859,7 @@ impl Duration {
     /// ```
     // Allow the lint, as the value is guaranteed to be less than 1000.
     pub const fn subsec_milliseconds(self) -> i16 {
-        (self.nanoseconds.get() / Nanosecond::per(Millisecond) as i32) as _
+        (self.nanoseconds.get() / Nanosecond::per(Millisecond) as i32) as i16
     }
 
     /// Get the number of whole microseconds in the duration.
@@ -933,7 +933,7 @@ impl Duration {
         let mut seconds = const_try_opt!(self.seconds.checked_add(rhs.seconds));
         let mut nanoseconds = self.nanoseconds.get() + rhs.nanoseconds.get();
 
-        if nanoseconds >= Nanosecond::per(Second) as _ || seconds < 0 && nanoseconds > 0 {
+        if nanoseconds >= Nanosecond::per(Second) as i32 || seconds < 0 && nanoseconds > 0 {
             nanoseconds -= Nanosecond::per(Second) as i32;
             seconds = const_try_opt!(seconds.checked_add(1));
         } else if nanoseconds <= -(Nanosecond::per(Second) as i32) || seconds > 0 && nanoseconds < 0
@@ -958,7 +958,7 @@ impl Duration {
         let mut seconds = const_try_opt!(self.seconds.checked_sub(rhs.seconds));
         let mut nanoseconds = self.nanoseconds.get() - rhs.nanoseconds.get();
 
-        if nanoseconds >= Nanosecond::per(Second) as _ || seconds < 0 && nanoseconds > 0 {
+        if nanoseconds >= Nanosecond::per(Second) as i32 || seconds < 0 && nanoseconds > 0 {
             nanoseconds -= Nanosecond::per(Second) as i32;
             seconds = const_try_opt!(seconds.checked_add(1));
         } else if nanoseconds <= -(Nanosecond::per(Second) as i32) || seconds > 0 && nanoseconds < 0
@@ -985,9 +985,9 @@ impl Duration {
         // Multiply nanoseconds as i64, because it cannot overflow that way.
         let total_nanos = self.nanoseconds.get() as i64 * rhs as i64;
         let extra_secs = total_nanos / Nanosecond::per(Second) as i64;
-        let nanoseconds = (total_nanos % Nanosecond::per(Second) as i64) as _;
+        let nanoseconds = (total_nanos % Nanosecond::per(Second) as i64) as i32;
         let seconds = const_try_opt!(
-            const_try_opt!(self.seconds.checked_mul(rhs as _)).checked_add(extra_secs)
+            const_try_opt!(self.seconds.checked_mul(rhs as i64)).checked_add(extra_secs)
         );
 
         // Safety: `nanoseconds` is guaranteed to be in range because of the modulus above.
@@ -1056,7 +1056,7 @@ impl Duration {
         }
         let mut nanoseconds = self.nanoseconds.get() + rhs.nanoseconds.get();
 
-        if nanoseconds >= Nanosecond::per(Second) as _ || seconds < 0 && nanoseconds > 0 {
+        if nanoseconds >= Nanosecond::per(Second) as i32 || seconds < 0 && nanoseconds > 0 {
             nanoseconds -= Nanosecond::per(Second) as i32;
             seconds = match seconds.checked_add(1) {
                 Some(seconds) => seconds,
@@ -1097,7 +1097,7 @@ impl Duration {
         }
         let mut nanoseconds = self.nanoseconds.get() - rhs.nanoseconds.get();
 
-        if nanoseconds >= Nanosecond::per(Second) as _ || seconds < 0 && nanoseconds > 0 {
+        if nanoseconds >= Nanosecond::per(Second) as i32 || seconds < 0 && nanoseconds > 0 {
             nanoseconds -= Nanosecond::per(Second) as i32;
             seconds = match seconds.checked_add(1) {
                 Some(seconds) => seconds,
@@ -1132,8 +1132,8 @@ impl Duration {
         // Multiply nanoseconds as i64, because it cannot overflow that way.
         let total_nanos = self.nanoseconds.get() as i64 * rhs as i64;
         let extra_secs = total_nanos / Nanosecond::per(Second) as i64;
-        let nanoseconds = (total_nanos % Nanosecond::per(Second) as i64) as _;
-        let (seconds, overflow1) = self.seconds.overflowing_mul(rhs as _);
+        let nanoseconds = (total_nanos % Nanosecond::per(Second) as i64) as i32;
+        let (seconds, overflow1) = self.seconds.overflowing_mul(rhs as i64);
         if overflow1 {
             if self.seconds > 0 && rhs > 0 || self.seconds < 0 && rhs < 0 {
                 return Self::MAX;
diff --git a/time/src/ext/numerical_duration.rs b/time/src/ext/numerical_duration.rs
index fb9209d23..a1e93cc4c 100644
--- a/time/src/ext/numerical_duration.rs
+++ b/time/src/ext/numerical_duration.rs
@@ -107,34 +107,34 @@ impl NumericalDuration for i64 {
 
 impl NumericalDuration for f64 {
     fn nanoseconds(self) -> Duration {
-        Duration::nanoseconds(self as _)
+        Duration::nanoseconds(self as i64)
     }
 
     fn microseconds(self) -> Duration {
-        Duration::nanoseconds((self * Nanosecond::per(Microsecond) as Self) as _)
+        Duration::nanoseconds((self * Nanosecond::per(Microsecond) as Self) as i64)
     }
 
     fn milliseconds(self) -> Duration {
-        Duration::nanoseconds((self * Nanosecond::per(Millisecond) as Self) as _)
+        Duration::nanoseconds((self * Nanosecond::per(Millisecond) as Self) as i64)
     }
 
     fn seconds(self) -> Duration {
-        Duration::nanoseconds((self * Nanosecond::per(Second) as Self) as _)
+        Duration::nanoseconds((self * Nanosecond::per(Second) as Self) as i64)
     }
 
     fn minutes(self) -> Duration {
-        Duration::nanoseconds((self * Nanosecond::per(Minute) as Self) as _)
+        Duration::nanoseconds((self * Nanosecond::per(Minute) as Self) as i64)
     }
 
     fn hours(self) -> Duration {
-        Duration::nanoseconds((self * Nanosecond::per(Hour) as Self) as _)
+        Duration::nanoseconds((self * Nanosecond::per(Hour) as Self) as i64)
     }
 
     fn days(self) -> Duration {
-        Duration::nanoseconds((self * Nanosecond::per(Day) as Self) as _)
+        Duration::nanoseconds((self * Nanosecond::per(Day) as Self) as i64)
     }
 
     fn weeks(self) -> Duration {
-        Duration::nanoseconds((self * Nanosecond::per(Week) as Self) as _)
+        Duration::nanoseconds((self * Nanosecond::per(Week) as Self) as i64)
     }
 }
diff --git a/time/src/ext/numerical_std_duration.rs b/time/src/ext/numerical_std_duration.rs
index 062b33f76..d6bc7babe 100644
--- a/time/src/ext/numerical_std_duration.rs
+++ b/time/src/ext/numerical_std_duration.rs
@@ -131,7 +131,7 @@ impl NumericalStdDuration for f64 {
     /// This will panic if self is negative.
     fn std_nanoseconds(self) -> StdDuration {
         assert!(self >= 0.);
-        StdDuration::from_nanos(self as _)
+        StdDuration::from_nanos(self as u64)
     }
 
     /// # Panics
@@ -139,7 +139,7 @@ impl NumericalStdDuration for f64 {
     /// This will panic if self is negative.
     fn std_microseconds(self) -> StdDuration {
         assert!(self >= 0.);
-        StdDuration::from_nanos((self * Nanosecond::per(Microsecond) as Self) as _)
+        StdDuration::from_nanos((self * Nanosecond::per(Microsecond) as Self) as u64)
     }
 
     /// # Panics
@@ -147,7 +147,7 @@ impl NumericalStdDuration for f64 {
     /// This will panic if self is negative.
     fn std_milliseconds(self) -> StdDuration {
         assert!(self >= 0.);
-        StdDuration::from_nanos((self * Nanosecond::per(Millisecond) as Self) as _)
+        StdDuration::from_nanos((self * Nanosecond::per(Millisecond) as Self) as u64)
     }
 
     /// # Panics
@@ -155,7 +155,7 @@ impl NumericalStdDuration for f64 {
     /// This will panic if self is negative.
     fn std_seconds(self) -> StdDuration {
         assert!(self >= 0.);
-        StdDuration::from_nanos((self * Nanosecond::per(Second) as Self) as _)
+        StdDuration::from_nanos((self * Nanosecond::per(Second) as Self) as u64)
     }
 
     /// # Panics
@@ -163,7 +163,7 @@ impl NumericalStdDuration for f64 {
     /// This will panic if self is negative.
     fn std_minutes(self) -> StdDuration {
         assert!(self >= 0.);
-        StdDuration::from_nanos((self * Nanosecond::per(Minute) as Self) as _)
+        StdDuration::from_nanos((self * Nanosecond::per(Minute) as Self) as u64)
     }
 
     /// # Panics
@@ -171,7 +171,7 @@ impl NumericalStdDuration for f64 {
     /// This will panic if self is negative.
     fn std_hours(self) -> StdDuration {
         assert!(self >= 0.);
-        StdDuration::from_nanos((self * Nanosecond::per(Hour) as Self) as _)
+        StdDuration::from_nanos((self * Nanosecond::per(Hour) as Self) as u64)
     }
 
     /// # Panics
@@ -179,7 +179,7 @@ impl NumericalStdDuration for f64 {
     /// This will panic if self is negative.
     fn std_days(self) -> StdDuration {
         assert!(self >= 0.);
-        StdDuration::from_nanos((self * Nanosecond::per(Day) as Self) as _)
+        StdDuration::from_nanos((self * Nanosecond::per(Day) as Self) as u64)
     }
 
     /// # Panics
@@ -187,6 +187,6 @@ impl NumericalStdDuration for f64 {
     /// This will panic if self is negative.
     fn std_weeks(self) -> StdDuration {
         assert!(self >= 0.);
-        StdDuration::from_nanos((self * Nanosecond::per(Week) as Self) as _)
+        StdDuration::from_nanos((self * Nanosecond::per(Week) as Self) as u64)
     }
 }
diff --git a/time/src/format_description/parse/ast.rs b/time/src/format_description/parse/ast.rs
index f20386f96..cf13de89d 100644
--- a/time/src/format_description/parse/ast.rs
+++ b/time/src/format_description/parse/ast.rs
@@ -193,7 +193,7 @@ fn parse_component<
         return Err(Error {
             _inner: unused(span.error("expected component name")),
             public: crate::error::InvalidFormatDescription::MissingComponentName {
-                index: span.start.byte as _,
+                index: span.start.byte as usize,
             },
         });
     };
@@ -204,7 +204,7 @@ fn parse_component<
                 _inner: unused(name.span.error("expected whitespace after `optional`")),
                 public: crate::error::InvalidFormatDescription::Expected {
                     what: "whitespace after `optional`",
-                    index: name.span.end.byte as _,
+                    index: name.span.end.byte as usize,
                 },
             });
         };
@@ -215,7 +215,7 @@ fn parse_component<
             return Err(Error {
                 _inner: unused(opening_bracket.error("unclosed bracket")),
                 public: crate::error::InvalidFormatDescription::UnclosedOpeningBracket {
-                    index: opening_bracket.byte as _,
+                    index: opening_bracket.byte as usize,
                 },
             });
         };
@@ -236,7 +236,7 @@ fn parse_component<
                 _inner: unused(name.span.error("expected whitespace after `first`")),
                 public: crate::error::InvalidFormatDescription::Expected {
                     what: "whitespace after `first`",
-                    index: name.span.end.byte as _,
+                    index: name.span.end.byte as usize,
                 },
             });
         };
@@ -250,7 +250,7 @@ fn parse_component<
             return Err(Error {
                 _inner: unused(opening_bracket.error("unclosed bracket")),
                 public: crate::error::InvalidFormatDescription::UnclosedOpeningBracket {
-                    index: opening_bracket.byte as _,
+                    index: opening_bracket.byte as usize,
                 },
             });
         };
@@ -282,7 +282,7 @@ fn parse_component<
                 ),
                 public: crate::error::InvalidFormatDescription::InvalidModifier {
                     value: String::from("["),
-                    index: location.byte as _,
+                    index: location.byte as usize,
                 },
             });
         }
@@ -296,7 +296,7 @@ fn parse_component<
                 _inner: unused(span.error("modifier must be of the form `key:value`")),
                 public: crate::error::InvalidFormatDescription::InvalidModifier {
                     value: String::from_utf8_lossy(value).into_owned(),
-                    index: span.start.byte as _,
+                    index: span.start.byte as usize,
                 },
             });
         };
@@ -308,7 +308,7 @@ fn parse_component<
                 _inner: unused(span.shrink_to_start().error("expected modifier key")),
                 public: crate::error::InvalidFormatDescription::InvalidModifier {
                     value: String::new(),
-                    index: span.start.byte as _,
+                    index: span.start.byte as usize,
                 },
             });
         }
@@ -317,16 +317,16 @@ fn parse_component<
                 _inner: unused(span.shrink_to_end().error("expected modifier value")),
                 public: crate::error::InvalidFormatDescription::InvalidModifier {
                     value: String::new(),
-                    index: span.shrink_to_end().start.byte as _,
+                    index: span.shrink_to_end().start.byte as usize,
                 },
             });
         }
 
         modifiers.push(Modifier {
             _leading_whitespace: unused(whitespace),
-            key: key.spanned(span.shrink_to_before(colon_index as _)),
-            _colon: unused(span.start.offset(colon_index as _)),
-            value: value.spanned(span.shrink_to_after(colon_index as _)),
+            key: key.spanned(span.shrink_to_before(colon_index as u32)),
+            _colon: unused(span.start.offset(colon_index as u32)),
+            value: value.spanned(span.shrink_to_after(colon_index as u32)),
         });
     };
 
@@ -334,7 +334,7 @@ fn parse_component<
         return Err(Error {
             _inner: unused(opening_bracket.error("unclosed bracket")),
             public: crate::error::InvalidFormatDescription::UnclosedOpeningBracket {
-                index: opening_bracket.byte as _,
+                index: opening_bracket.byte as usize,
             },
         });
     };
@@ -360,7 +360,7 @@ fn parse_nested<'a, I: Iterator<Item = Result<lexer::Token<'a>, Error>>, const V
             _inner: unused(last_location.error("expected opening bracket")),
             public: crate::error::InvalidFormatDescription::Expected {
                 what: "opening bracket",
-                index: last_location.byte as _,
+                index: last_location.byte as usize,
             },
         });
     };
@@ -369,7 +369,7 @@ fn parse_nested<'a, I: Iterator<Item = Result<lexer::Token<'a>, Error>>, const V
         return Err(Error {
             _inner: unused(opening_bracket.error("unclosed bracket")),
             public: crate::error::InvalidFormatDescription::UnclosedOpeningBracket {
-                index: opening_bracket.byte as _,
+                index: opening_bracket.byte as usize,
             },
         });
     };
diff --git a/time/src/format_description/parse/format_item.rs b/time/src/format_description/parse/format_item.rs
index 2a7a797cf..d401daa58 100644
--- a/time/src/format_description/parse/format_item.rs
+++ b/time/src/format_description/parse/format_item.rs
@@ -116,7 +116,7 @@ impl<'a> TryFrom<Item<'a>> for crate::format_description::BorrowedFormatItem<'a>
                 public: crate::error::InvalidFormatDescription::NotSupported {
                     what: "optional item",
                     context: "runtime-parsed format descriptions",
-                    index: span.start.byte as _,
+                    index: span.start.byte as usize,
                 },
             }),
             Item::First { value: _, span } => Err(Error {
@@ -126,7 +126,7 @@ impl<'a> TryFrom<Item<'a>> for crate::format_description::BorrowedFormatItem<'a>
                 public: crate::error::InvalidFormatDescription::NotSupported {
                     what: "'first' item",
                     context: "runtime-parsed format descriptions",
-                    index: span.start.byte as _,
+                    index: span.start.byte as usize,
                 },
             }),
         }
@@ -207,7 +207,7 @@ macro_rules! component_definition {
                         _inner: unused(modifier.key.span.error("invalid modifier key")),
                         public: crate::error::InvalidFormatDescription::InvalidModifier {
                             value: String::from_utf8_lossy(*modifier.key).into_owned(),
-                            index: modifier.key.span.start.byte as _,
+                            index: modifier.key.span.start.byte as usize,
                         }
                     });
                 }
@@ -219,7 +219,7 @@ macro_rules! component_definition {
                             public:
                                 crate::error::InvalidFormatDescription::MissingRequiredModifier {
                                     name: $parse_field,
-                                    index: _component_span.start.byte as _,
+                                    index: _component_span.start.byte as usize,
                                 }
                         });
                     }
@@ -265,7 +265,7 @@ macro_rules! component_definition {
                 _inner: unused(name.span.error("invalid component")),
                 public: crate::error::InvalidFormatDescription::InvalidComponentName {
                     name: String::from_utf8_lossy(name).into_owned(),
-                    index: name.span.start.byte as _,
+                    index: name.span.start.byte as usize,
                 },
             })
         }
@@ -402,7 +402,7 @@ macro_rules! modifier {
                     _inner: unused(value.span.error("invalid modifier value")),
                     public: crate::error::InvalidFormatDescription::InvalidModifier {
                         value: String::from_utf8_lossy(value).into_owned(),
-                        index: value.span.start.byte as _,
+                        index: value.span.start.byte as usize,
                     },
                 })
             }
@@ -543,7 +543,7 @@ fn parse_from_modifier_value<T: FromStr>(value: &Spanned<&[u8]>) -> Result<Optio
             _inner: unused(value.span.error("invalid modifier value")),
             public: crate::error::InvalidFormatDescription::InvalidModifier {
                 value: String::from_utf8_lossy(value).into_owned(),
-                index: value.span.start.byte as _,
+                index: value.span.start.byte as usize,
             },
         })
 }
diff --git a/time/src/format_description/parse/lexer.rs b/time/src/format_description/parse/lexer.rs
index 257c39400..a63722e17 100644
--- a/time/src/format_description/parse/lexer.rs
+++ b/time/src/format_description/parse/lexer.rs
@@ -180,7 +180,7 @@ pub(super) fn lex<const VERSION: usize>(
                             _inner: unused(loc.error("invalid escape sequence")),
                             public: crate::error::InvalidFormatDescription::Expected {
                                 what: "valid escape sequence",
-                                index: loc.byte as _,
+                                index: loc.byte as usize,
                             },
                         }));
                     }
@@ -189,7 +189,7 @@ pub(super) fn lex<const VERSION: usize>(
                             _inner: unused(backslash_loc.error("unexpected end of input")),
                             public: crate::error::InvalidFormatDescription::Expected {
                                 what: "valid escape sequence",
-                                index: backslash_loc.byte as _,
+                                index: backslash_loc.byte as usize,
                             },
                         }));
                     }
diff --git a/time/src/format_description/parse/strftime.rs b/time/src/format_description/parse/strftime.rs
index bae516c66..5fcaf1842 100644
--- a/time/src/format_description/parse/strftime.rs
+++ b/time/src/format_description/parse/strftime.rs
@@ -91,7 +91,7 @@ fn lex(mut input: &[u8]) -> iter::Peekable<impl Iterator<Item = Result<Token<'_>
                         _inner: unused(percent_loc.error("unexpected end of input")),
                         public: InvalidFormatDescription::Expected {
                             what: "valid escape sequence",
-                            index: percent_loc.byte as _,
+                            index: percent_loc.byte as usize,
                         },
                     }));
                 }
@@ -317,7 +317,7 @@ fn parse_component(
                 public: InvalidFormatDescription::NotSupported {
                     what: "modifier",
                     context: "",
-                    index: component.span.start.byte as _,
+                    index: component.span.start.byte as usize,
                 },
             })
         }
@@ -467,7 +467,7 @@ fn parse_component(
                 public: InvalidFormatDescription::NotSupported {
                     what: "component",
                     context: "",
-                    index: component.span.start.byte as _,
+                    index: component.span.start.byte as usize,
                 },
             })
         }
@@ -479,7 +479,7 @@ fn parse_component(
                 }),
                 public: InvalidFormatDescription::InvalidComponentName {
                     name: String::from_utf8_lossy(&[*component]).into_owned(),
-                    index: component.span.start.byte as _,
+                    index: component.span.start.byte as usize,
                 },
             })
         }
diff --git a/time/src/format_description/well_known/iso8601/adt_hack.rs b/time/src/format_description/well_known/iso8601/adt_hack.rs
index c9f7ba23b..6d3daebbd 100644
--- a/time/src/format_description/well_known/iso8601/adt_hack.rs
+++ b/time/src/format_description/well_known/iso8601/adt_hack.rs
@@ -65,8 +65,8 @@ impl Config {
             FC::DateTimeOffset => 5,
             FC::TimeOffset => 6,
         };
-        bytes[1] = self.use_separators as _;
-        bytes[2] = self.year_is_six_digits as _;
+        bytes[1] = self.use_separators as u8;
+        bytes[2] = self.year_is_six_digits as u8;
         bytes[3] = match self.date_kind {
             DateKind::Calendar => 0,
             DateKind::Week => 1,
diff --git a/time/src/internal_macros.rs b/time/src/internal_macros.rs
index 34b3339ad..74205ac49 100644
--- a/time/src/internal_macros.rs
+++ b/time/src/internal_macros.rs
@@ -118,9 +118,9 @@ macro_rules! ensure_ranged {
                 #[allow(trivial_numeric_casts)]
                 return Err(crate::error::ComponentRange {
                     name: stringify!($value),
-                    minimum: $type::MIN.get() as _,
-                    maximum: $type::MAX.get() as _,
-                    value: $value as _,
+                    minimum: $type::MIN.get() as i64,
+                    maximum: $type::MAX.get() as i64,
+                    value: $value as i64,
                     conditional_message: None,
                 });
             }
@@ -137,7 +137,7 @@ macro_rules! ensure_ranged {
                         name: stringify!($value),
                         minimum: $type::MIN.get() as i64 / $factor as i64,
                         maximum: $type::MAX.get() as i64 / $factor as i64,
-                        value: $value as _,
+                        value: $value as i64,
                         conditional_message: None,
                     });
                 }
@@ -147,7 +147,7 @@ macro_rules! ensure_ranged {
                     name: stringify!($value),
                     minimum: $type::MIN.get() as i64 / $factor as i64,
                     maximum: $type::MAX.get() as i64 / $factor as i64,
-                    value: $value as _,
+                    value: $value as i64,
                     conditional_message: None,
                 });
             }
diff --git a/time/src/month.rs b/time/src/month.rs
index a621c9faa..18bb091c6 100644
--- a/time/src/month.rs
+++ b/time/src/month.rs
@@ -59,7 +59,7 @@ impl Month {
                 name: "month",
                 minimum: 1,
                 maximum: 12,
-                value: n as _,
+                value: n as i64,
                 conditional_message: None,
             }),
         }
@@ -251,7 +251,7 @@ impl FromStr for Month {
 
 impl From<Month> for u8 {
     fn from(month: Month) -> Self {
-        month as _
+        month as Self
     }
 }
 
diff --git a/time/src/offset_date_time.rs b/time/src/offset_date_time.rs
index 0e1ae081e..274fad2bb 100644
--- a/time/src/offset_date_time.rs
+++ b/time/src/offset_date_time.rs
@@ -320,13 +320,13 @@ impl OffsetDateTime {
 
         (
             year,
-            ordinal as _,
+            ordinal as u16,
             // Safety: The cascades above ensure the values are in range.
             unsafe {
                 Time::__from_hms_nanos_unchecked(
-                    hour as _,
-                    minute as _,
-                    second as _,
+                    hour as u8,
+                    minute as u8,
+                    second as u8,
                     self.nanosecond(),
                 )
             },
@@ -381,13 +381,13 @@ impl OffsetDateTime {
             )
         };
 
-        let seconds_within_day = timestamp.rem_euclid(Second::per(Day) as _);
+        let seconds_within_day = timestamp.rem_euclid(Second::per(Day) as i64);
         // Safety: All values are in range.
         let time = unsafe {
             Time::__from_hms_nanos_unchecked(
-                (seconds_within_day / Second::per(Hour) as i64) as _,
-                ((seconds_within_day % Second::per(Hour) as i64) / Minute::per(Hour) as i64) as _,
-                (seconds_within_day % Second::per(Minute) as i64) as _,
+                (seconds_within_day / Second::per(Hour) as i64) as u8,
+                ((seconds_within_day % Second::per(Hour) as i64) / Minute::per(Hour) as i64) as u8,
+                (seconds_within_day % Second::per(Minute) as i64) as u8,
                 0,
             )
         };
@@ -424,7 +424,7 @@ impl OffsetDateTime {
                     datetime.hour(),
                     datetime.minute(),
                     datetime.second(),
-                    timestamp.rem_euclid(Nanosecond::per(Second) as _) as u32,
+                    timestamp.rem_euclid(Nanosecond::per(Second) as i128) as u32,
                 )
             },
             UtcOffset::UTC,
diff --git a/time/src/parsing/iso8601.rs b/time/src/parsing/iso8601.rs
index 83c58ac91..a57d62745 100644
--- a/time/src/parsing/iso8601.rs
+++ b/time/src/parsing/iso8601.rs
@@ -129,16 +129,17 @@ impl<const CONFIG: EncodedConfig> Iso8601<CONFIG> {
                     *parsed = parsed
                         .with_hour_24(hour)
                         .ok_or(InvalidComponent("hour"))?
-                        .with_minute((fractional_part * Second::per(Minute) as f64) as _)
+                        .with_minute((fractional_part * Second::per(Minute) as f64) as u8)
                         .ok_or(InvalidComponent("minute"))?
                         .with_second(
                             (fractional_part * Second::per(Hour) as f64 % Minute::per(Hour) as f64)
-                                as _,
+                                as u8,
                         )
                         .ok_or(InvalidComponent("second"))?
                         .with_subsecond(
                             (fractional_part * Nanosecond::per(Hour) as f64
-                                % Nanosecond::per(Second) as f64) as _,
+                                % Nanosecond::per(Second) as f64)
+                                as u32,
                         )
                         .ok_or(InvalidComponent("subsecond"))?;
                     return Ok(input);
@@ -166,11 +167,12 @@ impl<const CONFIG: EncodedConfig> Iso8601<CONFIG> {
                     *parsed = parsed
                         .with_minute(minute)
                         .ok_or(InvalidComponent("minute"))?
-                        .with_second((fractional_part * Second::per(Minute) as f64) as _)
+                        .with_second((fractional_part * Second::per(Minute) as f64) as u8)
                         .ok_or(InvalidComponent("second"))?
                         .with_subsecond(
                             (fractional_part * Nanosecond::per(Minute) as f64
-                                % Nanosecond::per(Second) as f64) as _,
+                                % Nanosecond::per(Second) as f64)
+                                as u32,
                         )
                         .ok_or(InvalidComponent("subsecond"))?;
                     return Ok(input);
@@ -213,7 +215,7 @@ impl<const CONFIG: EncodedConfig> Iso8601<CONFIG> {
                 Some(ParsedItem(input, (second, Some(fractional_part)))) => (
                     input,
                     second,
-                    round(fractional_part * Nanosecond::per(Second) as f64) as _,
+                    round(fractional_part * Nanosecond::per(Second) as f64) as u32,
                 ),
                 None if extended_kind.is_extended() => {
                     return Err(error::Parse::ParseFromDescription(InvalidComponent(
diff --git a/time/src/parsing/parsed.rs b/time/src/parsing/parsed.rs
index 18cfdc7c9..a6f00d9b0 100644
--- a/time/src/parsing/parsed.rs
+++ b/time/src/parsing/parsed.rs
@@ -160,10 +160,10 @@ pub struct Parsed {
     offset_hour: OptionRangedI8<-23, 23>,
     /// Minutes within the hour of the UTC offset.
     offset_minute:
-        OptionRangedI8<{ -((Minute::per(Hour) - 1) as i8) }, { (Minute::per(Hour) - 1) as _ }>,
+        OptionRangedI8<{ -((Minute::per(Hour) - 1) as i8) }, { (Minute::per(Hour) - 1) as i8 }>,
     /// Seconds within the minute of the UTC offset.
     offset_second:
-        OptionRangedI8<{ -((Second::per(Minute) - 1) as i8) }, { (Second::per(Minute) - 1) as _ }>,
+        OptionRangedI8<{ -((Second::per(Minute) - 1) as i8) }, { (Second::per(Minute) - 1) as i8 }>,
     /// The Unix timestamp in nanoseconds.
     unix_timestamp_nanos: OptionRangedI128<
         {
@@ -810,7 +810,7 @@ impl Parsed {
         if value > i8::MAX as u8 {
             None
         } else {
-            self.with_offset_minute_signed(value as _)
+            self.with_offset_minute_signed(value as i8)
         }
     }
 
@@ -830,7 +830,7 @@ impl Parsed {
         if value > i8::MAX as u8 {
             None
         } else {
-            self.with_offset_second_signed(value as _)
+            self.with_offset_second_signed(value as i8)
         }
     }
 
diff --git a/time/src/time.rs b/time/src/time.rs
index 8283b504b..627a25045 100644
--- a/time/src/time.rs
+++ b/time/src/time.rs
@@ -423,7 +423,7 @@ impl Time {
     /// assert_eq!(time!(23:59:59.999).millisecond(), 999);
     /// ```
     pub const fn millisecond(self) -> u16 {
-        (self.nanosecond.get() / Nanosecond::per(Millisecond)) as _
+        (self.nanosecond.get() / Nanosecond::per(Millisecond)) as u16
     }
 
     /// Get the microseconds within the second.
@@ -464,10 +464,10 @@ impl Time {
             self.hour.get() as i8 + (duration.whole_hours() % Hour::per(Day) as i64) as i8;
         let mut date_adjustment = DateAdjustment::None;
 
-        cascade!(nanoseconds in 0..Nanosecond::per(Second) as _ => seconds);
-        cascade!(seconds in 0..Second::per(Minute) as _ => minutes);
-        cascade!(minutes in 0..Minute::per(Hour) as _ => hours);
-        if hours >= Hour::per(Day) as _ {
+        cascade!(nanoseconds in 0..Nanosecond::per(Second) as i32 => seconds);
+        cascade!(seconds in 0..Second::per(Minute) as i8 => minutes);
+        cascade!(minutes in 0..Minute::per(Hour) as i8 => hours);
+        if hours >= Hour::per(Day) as i8 {
             hours -= Hour::per(Day) as i8;
             date_adjustment = DateAdjustment::Next;
         } else if hours < 0 {
@@ -480,10 +480,10 @@ impl Time {
             // Safety: The cascades above ensure the values are in range.
             unsafe {
                 Self::__from_hms_nanos_unchecked(
-                    hours as _,
-                    minutes as _,
-                    seconds as _,
-                    nanoseconds as _,
+                    hours as u8,
+                    minutes as u8,
+                    seconds as u8,
+                    nanoseconds as u32,
                 )
             },
         )
@@ -501,10 +501,10 @@ impl Time {
             self.hour.get() as i8 - (duration.whole_hours() % Hour::per(Day) as i64) as i8;
         let mut date_adjustment = DateAdjustment::None;
 
-        cascade!(nanoseconds in 0..Nanosecond::per(Second) as _ => seconds);
-        cascade!(seconds in 0..Second::per(Minute) as _ => minutes);
-        cascade!(minutes in 0..Minute::per(Hour) as _ => hours);
-        if hours >= Hour::per(Day) as _ {
+        cascade!(nanoseconds in 0..Nanosecond::per(Second) as i32 => seconds);
+        cascade!(seconds in 0..Second::per(Minute) as i8 => minutes);
+        cascade!(minutes in 0..Minute::per(Hour) as i8 => hours);
+        if hours >= Hour::per(Day) as i8 {
             hours -= Hour::per(Day) as i8;
             date_adjustment = DateAdjustment::Next;
         } else if hours < 0 {
@@ -517,10 +517,10 @@ impl Time {
             // Safety: The cascades above ensure the values are in range.
             unsafe {
                 Self::__from_hms_nanos_unchecked(
-                    hours as _,
-                    minutes as _,
-                    seconds as _,
-                    nanoseconds as _,
+                    hours as u8,
+                    minutes as u8,
+                    seconds as u8,
+                    nanoseconds as u32,
                 )
             },
         )
@@ -565,9 +565,9 @@ impl Time {
             - ((duration.as_secs() / Second::per(Hour) as u64) % Hour::per(Day) as u64) as i8;
         let mut is_previous_day = false;
 
-        cascade!(nanosecond in 0..Nanosecond::per(Second) as _ => second);
-        cascade!(second in 0..Second::per(Minute) as _ => minute);
-        cascade!(minute in 0..Minute::per(Hour) as _ => hour);
+        cascade!(nanosecond in 0..Nanosecond::per(Second) as i32 => second);
+        cascade!(second in 0..Second::per(Minute) as i8 => minute);
+        cascade!(minute in 0..Minute::per(Hour) as i8 => hour);
         if hour < 0 {
             hour += Hour::per(Day) as i8;
             is_previous_day = true;
@@ -578,10 +578,10 @@ impl Time {
             // Safety: The cascades above ensure the values are in range.
             unsafe {
                 Self::__from_hms_nanos_unchecked(
-                    hour as _,
-                    minute as _,
-                    second as _,
-                    nanosecond as _,
+                    hour as u8,
+                    minute as u8,
+                    second as u8,
+                    nanosecond as u32,
                 )
             },
         )
diff --git a/time/src/utc_date_time.rs b/time/src/utc_date_time.rs
index e68574277..e7bb80268 100644
--- a/time/src/utc_date_time.rs
+++ b/time/src/utc_date_time.rs
@@ -202,13 +202,13 @@ impl UtcDateTime {
             )
         };
 
-        let seconds_within_day = timestamp.rem_euclid(Second::per(Day) as _);
+        let seconds_within_day = timestamp.rem_euclid(Second::per(Day) as i64);
         // Safety: All values are in range.
         let time = unsafe {
             Time::__from_hms_nanos_unchecked(
-                (seconds_within_day / Second::per(Hour) as i64) as _,
-                ((seconds_within_day % Second::per(Hour) as i64) / Minute::per(Hour) as i64) as _,
-                (seconds_within_day % Second::per(Minute) as i64) as _,
+                (seconds_within_day / Second::per(Hour) as i64) as u8,
+                ((seconds_within_day % Second::per(Hour) as i64) / Minute::per(Hour) as i64) as u8,
+                (seconds_within_day % Second::per(Minute) as i64) as u8,
                 0,
             )
         };
@@ -244,7 +244,7 @@ impl UtcDateTime {
                     datetime.hour(),
                     datetime.minute(),
                     datetime.second(),
-                    timestamp.rem_euclid(Nanosecond::per(Second) as _) as u32,
+                    timestamp.rem_euclid(Nanosecond::per(Second) as i128) as u32,
                 )
             },
         ))
@@ -339,13 +339,13 @@ impl UtcDateTime {
 
         (
             year,
-            ordinal as _,
+            ordinal as u16,
             // Safety: The cascades above ensure the values are in range.
             unsafe {
                 Time::__from_hms_nanos_unchecked(
-                    hour as _,
-                    minute as _,
-                    second as _,
+                    hour as u8,
+                    minute as u8,
+                    second as u8,
                     self.nanosecond(),
                 )
             },
diff --git a/time/src/utc_offset.rs b/time/src/utc_offset.rs
index 38eb18ec4..73bcf2d1a 100644
--- a/time/src/utc_offset.rs
+++ b/time/src/utc_offset.rs
@@ -198,9 +198,9 @@ impl UtcOffset {
         // Safety: The type of `seconds` guarantees that all values are in range.
         unsafe {
             Self::__from_hms_unchecked(
-                (seconds.get() / Second::per(Hour) as i32) as _,
-                ((seconds.get() % Second::per(Hour) as i32) / Minute::per(Hour) as i32) as _,
-                (seconds.get() % Second::per(Minute) as i32) as _,
+                (seconds.get() / Second::per(Hour) as i32) as i8,
+                ((seconds.get() % Second::per(Hour) as i32) / Minute::per(Hour) as i32) as i8,
+                (seconds.get() % Second::per(Minute) as i32) as i8,
             )
         }
     }
diff --git a/time/src/weekday.rs b/time/src/weekday.rs
index 543ecb22c..4331da83a 100644
--- a/time/src/weekday.rs
+++ b/time/src/weekday.rs
@@ -139,7 +139,7 @@ impl Weekday {
     /// assert_eq!(Weekday::Monday.number_days_from_monday(), 0);
     /// ```
     pub const fn number_days_from_monday(self) -> u8 {
-        self as _
+        self as u8
     }
 
     /// Get the zero-indexed number of days from Sunday.