Constify SystemTime methods

clarfonthey · clarfonthey · commit 15a79a341441 · 2025-08-11T02:24:15.000-04:00
diff --git a/library/std/src/lib.rs b/library/std/src/lib.rs
@@ -281,9 +281,11 @@
 #![feature(cfg_target_thread_local)]
 #![feature(cfi_encoding)]
 #![feature(char_max_len)]
+#![feature(const_trait_impl)]
 #![feature(core_float_math)]
 #![feature(decl_macro)]
 #![feature(deprecated_suggestion)]
+#![feature(derive_const)]
 #![feature(doc_cfg)]
 #![feature(doc_cfg_hide)]
 #![feature(doc_masked)]
@@ -329,6 +331,10 @@
 #![feature(bstr_internals)]
 #![feature(char_internals)]
 #![feature(clone_to_uninit)]
+#![feature(const_cmp)]
+#![feature(const_ops)]
+#![feature(const_option_ops)]
+#![feature(const_try)]
 #![feature(core_intrinsics)]
 #![feature(core_io_borrowed_buf)]
 #![feature(drop_guard)]
diff --git a/library/std/src/sys/pal/hermit/time.rs b/library/std/src/sys/pal/hermit/time.rs
@@ -25,8 +25,15 @@ impl Timespec {
         Timespec { t: timespec { tv_sec, tv_nsec } }
     }
 
-    fn sub_timespec(&self, other: &Timespec) -> Result<Duration, Duration> {
-        if self >= other {
+    #[rustc_const_unstable(feature = "const_system_time", issue = "144517")]
+    const fn sub_timespec(&self, other: &Timespec) -> Result<Duration, Duration> {
+        // FIXME: const PartialOrd
+        let mut cmp = self.t.tv_sec - other.t.tv_sec;
+        if cmp == 0 {
+            cmp = self.t.tv_nsec as i64 - other.t.tv_nsec as i64;
+        }
+
+        if cmp >= 0 {
             Ok(if self.t.tv_nsec >= other.t.tv_nsec {
                 Duration::new(
                     (self.t.tv_sec - other.t.tv_sec) as u64,
@@ -46,20 +53,22 @@ impl Timespec {
         }
     }
 
-    fn checked_add_duration(&self, other: &Duration) -> Option<Timespec> {
+    #[rustc_const_unstable(feature = "const_system_time", issue = "144517")]
+    const fn checked_add_duration(&self, other: &Duration) -> Option<Timespec> {
         let mut secs = self.t.tv_sec.checked_add_unsigned(other.as_secs())?;
 
         // Nano calculations can't overflow because nanos are <1B which fit
         // in a u32.
-        let mut nsec = other.subsec_nanos() + u32::try_from(self.t.tv_nsec).unwrap();
-        if nsec >= NSEC_PER_SEC.try_into().unwrap() {
-            nsec -= u32::try_from(NSEC_PER_SEC).unwrap();
+        let mut nsec = other.subsec_nanos() + self.t.tv_nsec as u32;
+        if nsec >= NSEC_PER_SEC as u32 {
+            nsec -= NSEC_PER_SEC as u32;
             secs = secs.checked_add(1)?;
         }
         Some(Timespec { t: timespec { tv_sec: secs, tv_nsec: nsec as _ } })
     }
 
-    fn checked_sub_duration(&self, other: &Duration) -> Option<Timespec> {
+    #[rustc_const_unstable(feature = "const_system_time", issue = "144517")]
+    const fn checked_sub_duration(&self, other: &Duration) -> Option<Timespec> {
         let mut secs = self.t.tv_sec.checked_sub_unsigned(other.as_secs())?;
 
         // Similar to above, nanos can't overflow.
@@ -213,15 +222,18 @@ impl SystemTime {
         SystemTime(time)
     }
 
-    pub fn sub_time(&self, other: &SystemTime) -> Result<Duration, Duration> {
+    #[rustc_const_unstable(feature = "const_system_time", issue = "144517")]
+    pub const fn sub_time(&self, other: &SystemTime) -> Result<Duration, Duration> {
         self.0.sub_timespec(&other.0)
     }
 
-    pub fn checked_add_duration(&self, other: &Duration) -> Option<SystemTime> {
+    #[rustc_const_unstable(feature = "const_system_time", issue = "144517")]
+    pub const fn checked_add_duration(&self, other: &Duration) -> Option<SystemTime> {
         Some(SystemTime(self.0.checked_add_duration(other)?))
     }
 
-    pub fn checked_sub_duration(&self, other: &Duration) -> Option<SystemTime> {
+    #[rustc_const_unstable(feature = "const_system_time", issue = "144517")]
+    pub const fn checked_sub_duration(&self, other: &Duration) -> Option<SystemTime> {
         Some(SystemTime(self.0.checked_sub_duration(other)?))
     }
 }
diff --git a/library/std/src/sys/pal/sgx/time.rs b/library/std/src/sys/pal/sgx/time.rs
@@ -32,15 +32,22 @@ impl SystemTime {
         SystemTime(usercalls::insecure_time())
     }
 
-    pub fn sub_time(&self, other: &SystemTime) -> Result<Duration, Duration> {
-        self.0.checked_sub(other.0).ok_or_else(|| other.0 - self.0)
+    #[rustc_const_unstable(feature = "const_system_time", issue = "144517")]
+    pub const fn sub_time(&self, other: &SystemTime) -> Result<Duration, Duration> {
+        // FIXME: ok_or_else with const closures
+        match self.0.checked_sub(other.0) {
+            Some(duration) => Ok(duration),
+            None => Err(other.0 - self.0),
+        }
     }
 
-    pub fn checked_add_duration(&self, other: &Duration) -> Option<SystemTime> {
+    #[rustc_const_unstable(feature = "const_system_time", issue = "144517")]
+    pub const fn checked_add_duration(&self, other: &Duration) -> Option<SystemTime> {
         Some(SystemTime(self.0.checked_add(*other)?))
     }
 
-    pub fn checked_sub_duration(&self, other: &Duration) -> Option<SystemTime> {
+    #[rustc_const_unstable(feature = "const_system_time", issue = "144517")]
+    pub const fn checked_sub_duration(&self, other: &Duration) -> Option<SystemTime> {
         Some(SystemTime(self.0.checked_sub(*other)?))
     }
 }
diff --git a/library/std/src/sys/pal/solid/time.rs b/library/std/src/sys/pal/solid/time.rs
@@ -39,19 +39,22 @@ impl SystemTime {
         Self(t)
     }
 
-    pub fn sub_time(&self, other: &SystemTime) -> Result<Duration, Duration> {
+    #[rustc_const_unstable(feature = "const_system_time", issue = "144517")]
+    pub const fn sub_time(&self, other: &SystemTime) -> Result<Duration, Duration> {
         if self.0 >= other.0 {
             Ok(Duration::from_secs((self.0 as u64).wrapping_sub(other.0 as u64)))
         } else {
             Err(Duration::from_secs((other.0 as u64).wrapping_sub(self.0 as u64)))
         }
     }
 
-    pub fn checked_add_duration(&self, other: &Duration) -> Option<SystemTime> {
+    #[rustc_const_unstable(feature = "const_system_time", issue = "144517")]
+    pub const fn checked_add_duration(&self, other: &Duration) -> Option<SystemTime> {
         Some(SystemTime(self.0.checked_add_unsigned(other.as_secs())?))
     }
 
-    pub fn checked_sub_duration(&self, other: &Duration) -> Option<SystemTime> {
+    #[rustc_const_unstable(feature = "const_system_time", issue = "144517")]
+    pub const fn checked_sub_duration(&self, other: &Duration) -> Option<SystemTime> {
         Some(SystemTime(self.0.checked_sub_unsigned(other.as_secs())?))
     }
 }
diff --git a/library/std/src/sys/pal/uefi/time.rs b/library/std/src/sys/pal/uefi/time.rs
@@ -45,15 +45,22 @@ impl SystemTime {
             .unwrap_or_else(|| panic!("time not implemented on this platform"))
     }
 
-    pub fn sub_time(&self, other: &SystemTime) -> Result<Duration, Duration> {
-        self.0.checked_sub(other.0).ok_or_else(|| other.0 - self.0)
+    #[rustc_const_unstable(feature = "const_system_time", issue = "144517")]
+    pub const fn sub_time(&self, other: &SystemTime) -> Result<Duration, Duration> {
+        // FIXME: ok_or_else with const closures
+        match self.0.checked_sub(other.0) {
+            Some(duration) => Ok(duration),
+            None => Err(other.0 - self.0),
+        }
     }
 
-    pub fn checked_add_duration(&self, other: &Duration) -> Option<SystemTime> {
+    #[rustc_const_unstable(feature = "const_system_time", issue = "144517")]
+    pub const fn checked_add_duration(&self, other: &Duration) -> Option<SystemTime> {
         Some(SystemTime(self.0.checked_add(*other)?))
     }
 
-    pub fn checked_sub_duration(&self, other: &Duration) -> Option<SystemTime> {
+    #[rustc_const_unstable(feature = "const_system_time", issue = "144517")]
+    pub const fn checked_sub_duration(&self, other: &Duration) -> Option<SystemTime> {
         Some(SystemTime(self.0.checked_sub(*other)?))
     }
 }
diff --git a/library/std/src/sys/pal/unix/time.rs b/library/std/src/sys/pal/unix/time.rs
@@ -38,15 +38,18 @@ impl SystemTime {
         SystemTime { t: Timespec::now(libc::CLOCK_REALTIME) }
     }
 
-    pub fn sub_time(&self, other: &SystemTime) -> Result<Duration, Duration> {
+    #[rustc_const_unstable(feature = "const_system_time", issue = "144517")]
+    pub const fn sub_time(&self, other: &SystemTime) -> Result<Duration, Duration> {
         self.t.sub_timespec(&other.t)
     }
 
-    pub fn checked_add_duration(&self, other: &Duration) -> Option<SystemTime> {
+    #[rustc_const_unstable(feature = "const_system_time", issue = "144517")]
+    pub const fn checked_add_duration(&self, other: &Duration) -> Option<SystemTime> {
         Some(SystemTime { t: self.t.checked_add_duration(other)? })
     }
 
-    pub fn checked_sub_duration(&self, other: &Duration) -> Option<SystemTime> {
+    #[rustc_const_unstable(feature = "const_system_time", issue = "144517")]
+    pub const fn checked_sub_duration(&self, other: &Duration) -> Option<SystemTime> {
         Some(SystemTime { t: self.t.checked_sub_duration(other)? })
     }
 }
@@ -133,8 +136,15 @@ impl Timespec {
         Timespec::new(t.tv_sec as i64, t.tv_nsec as i64).unwrap()
     }
 
-    pub fn sub_timespec(&self, other: &Timespec) -> Result<Duration, Duration> {
-        if self >= other {
+    #[rustc_const_unstable(feature = "const_system_time", issue = "144517")]
+    pub const fn sub_timespec(&self, other: &Timespec) -> Result<Duration, Duration> {
+        // FIXME: const PartialOrd
+        let mut cmp = self.tv_sec - other.tv_sec;
+        if cmp == 0 {
+            cmp = self.tv_nsec.as_inner() as i64 - other.tv_nsec.as_inner() as i64;
+        }
+
+        if cmp >= 0 {
             // NOTE(eddyb) two aspects of this `if`-`else` are required for LLVM
             // to optimize it into a branchless form (see also #75545):
             //
@@ -169,7 +179,8 @@ impl Timespec {
         }
     }
 
-    pub fn checked_add_duration(&self, other: &Duration) -> Option<Timespec> {
+    #[rustc_const_unstable(feature = "const_system_time", issue = "144517")]
+    pub const fn checked_add_duration(&self, other: &Duration) -> Option<Timespec> {
         let mut secs = self.tv_sec.checked_add_unsigned(other.as_secs())?;
 
         // Nano calculations can't overflow because nanos are <1B which fit
@@ -179,10 +190,11 @@ impl Timespec {
             nsec -= NSEC_PER_SEC as u32;
             secs = secs.checked_add(1)?;
         }
-        Some(unsafe { Timespec::new_unchecked(secs, nsec.into()) })
+        Some(unsafe { Timespec::new_unchecked(secs, nsec as i64) })
     }
 
-    pub fn checked_sub_duration(&self, other: &Duration) -> Option<Timespec> {
+    #[rustc_const_unstable(feature = "const_system_time", issue = "144517")]
+    pub const fn checked_sub_duration(&self, other: &Duration) -> Option<Timespec> {
         let mut secs = self.tv_sec.checked_sub_unsigned(other.as_secs())?;
 
         // Similar to above, nanos can't overflow.
@@ -191,7 +203,7 @@ impl Timespec {
             nsec += NSEC_PER_SEC as i32;
             secs = secs.checked_sub(1)?;
         }
-        Some(unsafe { Timespec::new_unchecked(secs, nsec.into()) })
+        Some(unsafe { Timespec::new_unchecked(secs, nsec as i64) })
     }
 
     #[allow(dead_code)]
diff --git a/library/std/src/sys/pal/unsupported/time.rs b/library/std/src/sys/pal/unsupported/time.rs
@@ -31,15 +31,22 @@ impl SystemTime {
         panic!("time not implemented on this platform")
     }
 
-    pub fn sub_time(&self, other: &SystemTime) -> Result<Duration, Duration> {
-        self.0.checked_sub(other.0).ok_or_else(|| other.0 - self.0)
+    #[rustc_const_unstable(feature = "const_system_time", issue = "144517")]
+    pub const fn sub_time(&self, other: &SystemTime) -> Result<Duration, Duration> {
+        // FIXME: ok_or_else with const closures
+        match self.0.checked_sub(other.0) {
+            Some(duration) => Ok(duration),
+            None => Err(other.0 - self.0),
+        }
     }
 
-    pub fn checked_add_duration(&self, other: &Duration) -> Option<SystemTime> {
+    #[rustc_const_unstable(feature = "const_system_time", issue = "144517")]
+    pub const fn checked_add_duration(&self, other: &Duration) -> Option<SystemTime> {
         Some(SystemTime(self.0.checked_add(*other)?))
     }
 
-    pub fn checked_sub_duration(&self, other: &Duration) -> Option<SystemTime> {
+    #[rustc_const_unstable(feature = "const_system_time", issue = "144517")]
+    pub const fn checked_sub_duration(&self, other: &Duration) -> Option<SystemTime> {
         Some(SystemTime(self.0.checked_sub(*other)?))
     }
 }
diff --git a/library/std/src/sys/pal/wasi/time.rs b/library/std/src/sys/pal/wasi/time.rs
@@ -43,23 +43,34 @@ impl SystemTime {
         SystemTime(current_time(wasi::CLOCKID_REALTIME))
     }
 
-    pub fn from_wasi_timestamp(ts: wasi::Timestamp) -> SystemTime {
+    #[rustc_const_unstable(feature = "const_system_time", issue = "144517")]
+    pub const fn from_wasi_timestamp(ts: wasi::Timestamp) -> SystemTime {
         SystemTime(Duration::from_nanos(ts))
     }
 
-    pub fn to_wasi_timestamp(&self) -> Option<wasi::Timestamp> {
-        self.0.as_nanos().try_into().ok()
+    #[rustc_const_unstable(feature = "const_system_time", issue = "144517")]
+    pub const fn to_wasi_timestamp(&self) -> Option<wasi::Timestamp> {
+        // FIXME: const TryInto
+        let ns = self.0.as_nanos();
+        if ns <= u64::MAX as u128 { Some(ns as u64) } else { None }
     }
 
-    pub fn sub_time(&self, other: &SystemTime) -> Result<Duration, Duration> {
-        self.0.checked_sub(other.0).ok_or_else(|| other.0 - self.0)
+    #[rustc_const_unstable(feature = "const_system_time", issue = "144517")]
+    pub const fn sub_time(&self, other: &SystemTime) -> Result<Duration, Duration> {
+        // FIXME: ok_or_else with const closures
+        match self.0.checked_sub(other.0) {
+            Some(duration) => Ok(duration),
+            None => Err(other.0 - self.0),
+        }
     }
 
-    pub fn checked_add_duration(&self, other: &Duration) -> Option<SystemTime> {
+    #[rustc_const_unstable(feature = "const_system_time", issue = "144517")]
+    pub const fn checked_add_duration(&self, other: &Duration) -> Option<SystemTime> {
         Some(SystemTime(self.0.checked_add(*other)?))
     }
 
-    pub fn checked_sub_duration(&self, other: &Duration) -> Option<SystemTime> {
+    #[rustc_const_unstable(feature = "const_system_time", issue = "144517")]
+    pub const fn checked_sub_duration(&self, other: &Duration) -> Option<SystemTime> {
         Some(SystemTime(self.0.checked_sub(*other)?))
     }
 }
diff --git a/library/std/src/sys/pal/windows/time.rs b/library/std/src/sys/pal/windows/time.rs
@@ -72,7 +72,8 @@ impl SystemTime {
         }
     }
 
-    fn from_intervals(intervals: i64) -> SystemTime {
+    #[rustc_const_unstable(feature = "const_system_time", issue = "144517")]
+    const fn from_intervals(intervals: i64) -> SystemTime {
         SystemTime {
             t: c::FILETIME {
                 dwLowDateTime: intervals as u32,
@@ -81,11 +82,13 @@ impl SystemTime {
         }
     }
 
-    fn intervals(&self) -> i64 {
+    #[rustc_const_unstable(feature = "const_system_time", issue = "144517")]
+    const fn intervals(&self) -> i64 {
         (self.t.dwLowDateTime as i64) | ((self.t.dwHighDateTime as i64) << 32)
     }
 
-    pub fn sub_time(&self, other: &SystemTime) -> Result<Duration, Duration> {
+    #[rustc_const_unstable(feature = "const_system_time", issue = "144517")]
+    pub const fn sub_time(&self, other: &SystemTime) -> Result<Duration, Duration> {
         let me = self.intervals();
         let other = other.intervals();
         if me >= other {
@@ -95,12 +98,14 @@ impl SystemTime {
         }
     }
 
-    pub fn checked_add_duration(&self, other: &Duration) -> Option<SystemTime> {
+    #[rustc_const_unstable(feature = "const_system_time", issue = "144517")]
+    pub const fn checked_add_duration(&self, other: &Duration) -> Option<SystemTime> {
         let intervals = self.intervals().checked_add(checked_dur2intervals(other)?)?;
         Some(SystemTime::from_intervals(intervals))
     }
 
-    pub fn checked_sub_duration(&self, other: &Duration) -> Option<SystemTime> {
+    #[rustc_const_unstable(feature = "const_system_time", issue = "144517")]
+    pub const fn checked_sub_duration(&self, other: &Duration) -> Option<SystemTime> {
         let intervals = self.intervals().checked_sub(checked_dur2intervals(other)?)?;
         Some(SystemTime::from_intervals(intervals))
     }
@@ -150,15 +155,18 @@ impl Hash for SystemTime {
     }
 }
 
-fn checked_dur2intervals(dur: &Duration) -> Option<i64> {
-    dur.as_secs()
+#[rustc_const_unstable(feature = "const_system_time", issue = "144517")]
+const fn checked_dur2intervals(dur: &Duration) -> Option<i64> {
+    // FIXME: const TryInto
+    let secs = dur
+        .as_secs()
         .checked_mul(INTERVALS_PER_SEC)?
-        .checked_add(dur.subsec_nanos() as u64 / 100)?
-        .try_into()
-        .ok()
+        .checked_add(dur.subsec_nanos() as u64 / 100)?;
+    if secs <= i64::MAX as u64 { Some(secs.cast_signed()) } else { None }
 }
 
-fn intervals2dur(intervals: u64) -> Duration {
+#[rustc_const_unstable(feature = "const_system_time", issue = "144517")]
+const fn intervals2dur(intervals: u64) -> Duration {
     Duration::new(intervals / INTERVALS_PER_SEC, ((intervals % INTERVALS_PER_SEC) * 100) as u32)
 }
 
diff --git a/library/std/src/sys/pal/xous/time.rs b/library/std/src/sys/pal/xous/time.rs
diff --git a/library/std/src/time.rs b/library/std/src/time.rs

Original file line number	Diff line number	Diff line change
`@@ -32,15 +32,22 @@ impl SystemTime {`
`32`	`32`	`SystemTime(usercalls::insecure_time())`
`33`	`33`	`}`
`34`	`34`
`35`		`- pub fn sub_time(&self, other: &SystemTime) -> Result<Duration, Duration> {`
`36`		`- self.0.checked_sub(other.0).ok_or_else(\|\| other.0 - self.0)`
	`35`	`+ #[rustc_const_unstable(feature = "const_system_time", issue = "144517")]`
	`36`	`+ pub const fn sub_time(&self, other: &SystemTime) -> Result<Duration, Duration> {`
	`37`	`+ // FIXME: ok_or_else with const closures`
	`38`	`+ match self.0.checked_sub(other.0) {`
	`39`	`+ Some(duration) => Ok(duration),`
	`40`	`+ None => Err(other.0 - self.0),`
	`41`	`+ }`
`37`	`42`	`}`
`38`	`43`
`39`		`- pub fn checked_add_duration(&self, other: &Duration) -> Option<SystemTime> {`
	`44`	`+ #[rustc_const_unstable(feature = "const_system_time", issue = "144517")]`
	`45`	`+ pub const fn checked_add_duration(&self, other: &Duration) -> Option<SystemTime> {`
`40`	`46`	`Some(SystemTime(self.0.checked_add(*other)?))`
`41`	`47`	`}`
`42`	`48`
`43`		`- pub fn checked_sub_duration(&self, other: &Duration) -> Option<SystemTime> {`
	`49`	`+ #[rustc_const_unstable(feature = "const_system_time", issue = "144517")]`
	`50`	`+ pub const fn checked_sub_duration(&self, other: &Duration) -> Option<SystemTime> {`
`44`	`51`	`Some(SystemTime(self.0.checked_sub(*other)?))`
`45`	`52`	`}`
`46`	`53`	`}`
Original file line number	Diff line number	Diff line change
`@@ -39,19 +39,22 @@ impl SystemTime {`
`39`	`39`	`Self(t)`
`40`	`40`	`}`
`41`	`41`
`42`		`- pub fn sub_time(&self, other: &SystemTime) -> Result<Duration, Duration> {`
	`42`	`+ #[rustc_const_unstable(feature = "const_system_time", issue = "144517")]`
	`43`	`+ pub const fn sub_time(&self, other: &SystemTime) -> Result<Duration, Duration> {`
`43`	`44`	`if self.0 >= other.0 {`
`44`	`45`	`Ok(Duration::from_secs((self.0 as u64).wrapping_sub(other.0 as u64)))`
`45`	`46`	`} else {`
`46`	`47`	`Err(Duration::from_secs((other.0 as u64).wrapping_sub(self.0 as u64)))`
`47`	`48`	`}`
`48`	`49`	`}`
`49`	`50`
`50`		`- pub fn checked_add_duration(&self, other: &Duration) -> Option<SystemTime> {`
	`51`	`+ #[rustc_const_unstable(feature = "const_system_time", issue = "144517")]`
	`52`	`+ pub const fn checked_add_duration(&self, other: &Duration) -> Option<SystemTime> {`
`51`	`53`	`Some(SystemTime(self.0.checked_add_unsigned(other.as_secs())?))`
`52`	`54`	`}`
`53`	`55`
`54`		`- pub fn checked_sub_duration(&self, other: &Duration) -> Option<SystemTime> {`
	`56`	`+ #[rustc_const_unstable(feature = "const_system_time", issue = "144517")]`
	`57`	`+ pub const fn checked_sub_duration(&self, other: &Duration) -> Option<SystemTime> {`
`55`	`58`	`Some(SystemTime(self.0.checked_sub_unsigned(other.as_secs())?))`
`56`	`59`	`}`
`57`	`60`	`}`
Original file line number	Diff line number	Diff line change
`@@ -45,15 +45,22 @@ impl SystemTime {`
`45`	`45`	`.unwrap_or_else(\|\| panic!("time not implemented on this platform"))`
`46`	`46`	`}`
`47`	`47`
`48`		`- pub fn sub_time(&self, other: &SystemTime) -> Result<Duration, Duration> {`
`49`		`- self.0.checked_sub(other.0).ok_or_else(\|\| other.0 - self.0)`
	`48`	`+ #[rustc_const_unstable(feature = "const_system_time", issue = "144517")]`
	`49`	`+ pub const fn sub_time(&self, other: &SystemTime) -> Result<Duration, Duration> {`
	`50`	`+ // FIXME: ok_or_else with const closures`
	`51`	`+ match self.0.checked_sub(other.0) {`
	`52`	`+ Some(duration) => Ok(duration),`
	`53`	`+ None => Err(other.0 - self.0),`
	`54`	`+ }`
`50`	`55`	`}`
`51`	`56`
`52`		`- pub fn checked_add_duration(&self, other: &Duration) -> Option<SystemTime> {`
	`57`	`+ #[rustc_const_unstable(feature = "const_system_time", issue = "144517")]`
	`58`	`+ pub const fn checked_add_duration(&self, other: &Duration) -> Option<SystemTime> {`
`53`	`59`	`Some(SystemTime(self.0.checked_add(*other)?))`
`54`	`60`	`}`
`55`	`61`
`56`		`- pub fn checked_sub_duration(&self, other: &Duration) -> Option<SystemTime> {`
	`62`	`+ #[rustc_const_unstable(feature = "const_system_time", issue = "144517")]`
	`63`	`+ pub const fn checked_sub_duration(&self, other: &Duration) -> Option<SystemTime> {`
`57`	`64`	`Some(SystemTime(self.0.checked_sub(*other)?))`
`58`	`65`	`}`
`59`	`66`	`}`
Original file line number	Diff line number	Diff line change
`@@ -38,15 +38,18 @@ impl SystemTime {`
`38`	`38`	`SystemTime { t: Timespec::now(libc::CLOCK_REALTIME) }`
`39`	`39`	`}`
`40`	`40`
`41`		`- pub fn sub_time(&self, other: &SystemTime) -> Result<Duration, Duration> {`
	`41`	`+ #[rustc_const_unstable(feature = "const_system_time", issue = "144517")]`
	`42`	`+ pub const fn sub_time(&self, other: &SystemTime) -> Result<Duration, Duration> {`
`42`	`43`	`self.t.sub_timespec(&other.t)`
`43`	`44`	`}`
`44`	`45`
`45`		`- pub fn checked_add_duration(&self, other: &Duration) -> Option<SystemTime> {`
	`46`	`+ #[rustc_const_unstable(feature = "const_system_time", issue = "144517")]`
	`47`	`+ pub const fn checked_add_duration(&self, other: &Duration) -> Option<SystemTime> {`
`46`	`48`	`Some(SystemTime { t: self.t.checked_add_duration(other)? })`
`47`	`49`	`}`
`48`	`50`
`49`		`- pub fn checked_sub_duration(&self, other: &Duration) -> Option<SystemTime> {`
	`51`	`+ #[rustc_const_unstable(feature = "const_system_time", issue = "144517")]`
	`52`	`+ pub const fn checked_sub_duration(&self, other: &Duration) -> Option<SystemTime> {`
`50`	`53`	`Some(SystemTime { t: self.t.checked_sub_duration(other)? })`
`51`	`54`	`}`
`52`	`55`	`}`
`@@ -133,8 +136,15 @@ impl Timespec {`
`133`	`136`	`Timespec::new(t.tv_sec as i64, t.tv_nsec as i64).unwrap()`
`134`	`137`	`}`
`135`	`138`
`136`		`- pub fn sub_timespec(&self, other: &Timespec) -> Result<Duration, Duration> {`
`137`		`- if self >= other {`
	`139`	`+ #[rustc_const_unstable(feature = "const_system_time", issue = "144517")]`
	`140`	`+ pub const fn sub_timespec(&self, other: &Timespec) -> Result<Duration, Duration> {`
	`141`	`+ // FIXME: const PartialOrd`
	`142`	`+ let mut cmp = self.tv_sec - other.tv_sec;`
	`143`	`+ if cmp == 0 {`
	`144`	`+ cmp = self.tv_nsec.as_inner() as i64 - other.tv_nsec.as_inner() as i64;`
	`145`	`+ }`
	`146`	`+`
	`147`	`+ if cmp >= 0 {`
`138`	`148`	// NOTE(eddyb) two aspects of this `if`-`else` are required for LLVM
`139`	`149`	`// to optimize it into a branchless form (see also #75545):`
`140`	`150`	`//`
`@@ -169,7 +179,8 @@ impl Timespec {`
`169`	`179`	`}`
`170`	`180`	`}`
`171`	`181`
`172`		`- pub fn checked_add_duration(&self, other: &Duration) -> Option<Timespec> {`
	`182`	`+ #[rustc_const_unstable(feature = "const_system_time", issue = "144517")]`
	`183`	`+ pub const fn checked_add_duration(&self, other: &Duration) -> Option<Timespec> {`
`173`	`184`	`let mut secs = self.tv_sec.checked_add_unsigned(other.as_secs())?;`
`174`	`185`
`175`	`186`	`// Nano calculations can't overflow because nanos are <1B which fit`
`@@ -179,10 +190,11 @@ impl Timespec {`
`179`	`190`	`nsec -= NSEC_PER_SEC as u32;`
`180`	`191`	`secs = secs.checked_add(1)?;`
`181`	`192`	`}`
`182`		`- Some(unsafe { Timespec::new_unchecked(secs, nsec.into()) })`
	`193`	`+ Some(unsafe { Timespec::new_unchecked(secs, nsec as i64) })`
`183`	`194`	`}`
`184`	`195`
`185`		`- pub fn checked_sub_duration(&self, other: &Duration) -> Option<Timespec> {`
	`196`	`+ #[rustc_const_unstable(feature = "const_system_time", issue = "144517")]`
	`197`	`+ pub const fn checked_sub_duration(&self, other: &Duration) -> Option<Timespec> {`
`186`	`198`	`let mut secs = self.tv_sec.checked_sub_unsigned(other.as_secs())?;`
`187`	`199`
`188`	`200`	`// Similar to above, nanos can't overflow.`
`@@ -191,7 +203,7 @@ impl Timespec {`
`191`	`203`	`nsec += NSEC_PER_SEC as i32;`
`192`	`204`	`secs = secs.checked_sub(1)?;`
`193`	`205`	`}`
`194`		`- Some(unsafe { Timespec::new_unchecked(secs, nsec.into()) })`
	`206`	`+ Some(unsafe { Timespec::new_unchecked(secs, nsec as i64) })`
`195`	`207`	`}`
`196`	`208`
`197`	`209`	`#[allow(dead_code)]`
Original file line number	Diff line number	Diff line change
`@@ -31,15 +31,22 @@ impl SystemTime {`
`31`	`31`	`panic!("time not implemented on this platform")`
`32`	`32`	`}`
`33`	`33`
`34`		`- pub fn sub_time(&self, other: &SystemTime) -> Result<Duration, Duration> {`
`35`		`- self.0.checked_sub(other.0).ok_or_else(\|\| other.0 - self.0)`
	`34`	`+ #[rustc_const_unstable(feature = "const_system_time", issue = "144517")]`
	`35`	`+ pub const fn sub_time(&self, other: &SystemTime) -> Result<Duration, Duration> {`
	`36`	`+ // FIXME: ok_or_else with const closures`
	`37`	`+ match self.0.checked_sub(other.0) {`
	`38`	`+ Some(duration) => Ok(duration),`
	`39`	`+ None => Err(other.0 - self.0),`
	`40`	`+ }`
`36`	`41`	`}`
`37`	`42`
`38`		`- pub fn checked_add_duration(&self, other: &Duration) -> Option<SystemTime> {`
	`43`	`+ #[rustc_const_unstable(feature = "const_system_time", issue = "144517")]`
	`44`	`+ pub const fn checked_add_duration(&self, other: &Duration) -> Option<SystemTime> {`
`39`	`45`	`Some(SystemTime(self.0.checked_add(*other)?))`
`40`	`46`	`}`
`41`	`47`
`42`		`- pub fn checked_sub_duration(&self, other: &Duration) -> Option<SystemTime> {`
	`48`	`+ #[rustc_const_unstable(feature = "const_system_time", issue = "144517")]`
	`49`	`+ pub const fn checked_sub_duration(&self, other: &Duration) -> Option<SystemTime> {`
`43`	`50`	`Some(SystemTime(self.0.checked_sub(*other)?))`
`44`	`51`	`}`
`45`	`52`	`}`
Original file line number	Diff line number	Diff line change
`@@ -43,23 +43,34 @@ impl SystemTime {`
`43`	`43`	`SystemTime(current_time(wasi::CLOCKID_REALTIME))`
`44`	`44`	`}`
`45`	`45`
`46`		`- pub fn from_wasi_timestamp(ts: wasi::Timestamp) -> SystemTime {`
	`46`	`+ #[rustc_const_unstable(feature = "const_system_time", issue = "144517")]`
	`47`	`+ pub const fn from_wasi_timestamp(ts: wasi::Timestamp) -> SystemTime {`
`47`	`48`	`SystemTime(Duration::from_nanos(ts))`
`48`	`49`	`}`
`49`	`50`
`50`		`- pub fn to_wasi_timestamp(&self) -> Option<wasi::Timestamp> {`
`51`		`- self.0.as_nanos().try_into().ok()`
	`51`	`+ #[rustc_const_unstable(feature = "const_system_time", issue = "144517")]`
	`52`	`+ pub const fn to_wasi_timestamp(&self) -> Option<wasi::Timestamp> {`
	`53`	`+ // FIXME: const TryInto`
	`54`	`+ let ns = self.0.as_nanos();`
	`55`	`+ if ns <= u64::MAX as u128 { Some(ns as u64) } else { None }`
`52`	`56`	`}`
`53`	`57`
`54`		`- pub fn sub_time(&self, other: &SystemTime) -> Result<Duration, Duration> {`
`55`		`- self.0.checked_sub(other.0).ok_or_else(\|\| other.0 - self.0)`
	`58`	`+ #[rustc_const_unstable(feature = "const_system_time", issue = "144517")]`
	`59`	`+ pub const fn sub_time(&self, other: &SystemTime) -> Result<Duration, Duration> {`
	`60`	`+ // FIXME: ok_or_else with const closures`
	`61`	`+ match self.0.checked_sub(other.0) {`
	`62`	`+ Some(duration) => Ok(duration),`
	`63`	`+ None => Err(other.0 - self.0),`
	`64`	`+ }`
`56`	`65`	`}`
`57`	`66`
`58`		`- pub fn checked_add_duration(&self, other: &Duration) -> Option<SystemTime> {`
	`67`	`+ #[rustc_const_unstable(feature = "const_system_time", issue = "144517")]`
	`68`	`+ pub const fn checked_add_duration(&self, other: &Duration) -> Option<SystemTime> {`
`59`	`69`	`Some(SystemTime(self.0.checked_add(*other)?))`
`60`	`70`	`}`
`61`	`71`
`62`		`- pub fn checked_sub_duration(&self, other: &Duration) -> Option<SystemTime> {`
	`72`	`+ #[rustc_const_unstable(feature = "const_system_time", issue = "144517")]`
	`73`	`+ pub const fn checked_sub_duration(&self, other: &Duration) -> Option<SystemTime> {`
`63`	`74`	`Some(SystemTime(self.0.checked_sub(*other)?))`
`64`	`75`	`}`
`65`	`76`	`}`
Original file line number	Diff line number	Diff line change
`@@ -72,7 +72,8 @@ impl SystemTime {`
`72`	`72`	`}`
`73`	`73`	`}`
`74`	`74`
`75`		`- fn from_intervals(intervals: i64) -> SystemTime {`
	`75`	`+ #[rustc_const_unstable(feature = "const_system_time", issue = "144517")]`
	`76`	`+ const fn from_intervals(intervals: i64) -> SystemTime {`
`76`	`77`	`SystemTime {`
`77`	`78`	`t: c::FILETIME {`
`78`	`79`	`dwLowDateTime: intervals as u32,`
`@@ -81,11 +82,13 @@ impl SystemTime {`
`81`	`82`	`}`
`82`	`83`	`}`
`83`	`84`
`84`		`- fn intervals(&self) -> i64 {`
	`85`	`+ #[rustc_const_unstable(feature = "const_system_time", issue = "144517")]`
	`86`	`+ const fn intervals(&self) -> i64 {`
`85`	`87`	`(self.t.dwLowDateTime as i64) \| ((self.t.dwHighDateTime as i64) << 32)`
`86`	`88`	`}`
`87`	`89`
`88`		`- pub fn sub_time(&self, other: &SystemTime) -> Result<Duration, Duration> {`
	`90`	`+ #[rustc_const_unstable(feature = "const_system_time", issue = "144517")]`
	`91`	`+ pub const fn sub_time(&self, other: &SystemTime) -> Result<Duration, Duration> {`
`89`	`92`	`let me = self.intervals();`
`90`	`93`	`let other = other.intervals();`
`91`	`94`	`if me >= other {`
`@@ -95,12 +98,14 @@ impl SystemTime {`
`95`	`98`	`}`
`96`	`99`	`}`
`97`	`100`
`98`		`- pub fn checked_add_duration(&self, other: &Duration) -> Option<SystemTime> {`
	`101`	`+ #[rustc_const_unstable(feature = "const_system_time", issue = "144517")]`
	`102`	`+ pub const fn checked_add_duration(&self, other: &Duration) -> Option<SystemTime> {`
`99`	`103`	`let intervals = self.intervals().checked_add(checked_dur2intervals(other)?)?;`
`100`	`104`	`Some(SystemTime::from_intervals(intervals))`
`101`	`105`	`}`
`102`	`106`
`103`		`- pub fn checked_sub_duration(&self, other: &Duration) -> Option<SystemTime> {`
	`107`	`+ #[rustc_const_unstable(feature = "const_system_time", issue = "144517")]`
	`108`	`+ pub const fn checked_sub_duration(&self, other: &Duration) -> Option<SystemTime> {`
`104`	`109`	`let intervals = self.intervals().checked_sub(checked_dur2intervals(other)?)?;`
`105`	`110`	`Some(SystemTime::from_intervals(intervals))`
`106`	`111`	`}`
`@@ -150,15 +155,18 @@ impl Hash for SystemTime {`
`150`	`155`	`}`
`151`	`156`	`}`
`152`	`157`
`153`		`-fn checked_dur2intervals(dur: &Duration) -> Option<i64> {`
`154`		`- dur.as_secs()`
	`158`	`+#[rustc_const_unstable(feature = "const_system_time", issue = "144517")]`
	`159`	`+const fn checked_dur2intervals(dur: &Duration) -> Option<i64> {`
	`160`	`+ // FIXME: const TryInto`
	`161`	`+ let secs = dur`
	`162`	`+ .as_secs()`
`155`	`163`	`.checked_mul(INTERVALS_PER_SEC)?`
`156`		`- .checked_add(dur.subsec_nanos() as u64 / 100)?`
`157`		`- .try_into()`
`158`		`- .ok()`
	`164`	`+ .checked_add(dur.subsec_nanos() as u64 / 100)?;`
	`165`	`+ if secs <= i64::MAX as u64 { Some(secs.cast_signed()) } else { None }`
`159`	`166`	`}`
`160`	`167`
`161`		`-fn intervals2dur(intervals: u64) -> Duration {`
	`168`	`+#[rustc_const_unstable(feature = "const_system_time", issue = "144517")]`
	`169`	`+const fn intervals2dur(intervals: u64) -> Duration {`
`162`	`170`	`Duration::new(intervals / INTERVALS_PER_SEC, ((intervals % INTERVALS_PER_SEC) * 100) as u32)`
`163`	`171`	`}`
`164`	`172`