Add from_nanos_u128 to Duration for handling large time spans

Add unstable attribute

Add unstable attribute for `from_nanos_u128` with tracking issue #139201

Co-authored-by: Madhav Madhusoodanan <[email protected]>

add feature gate for the new function

- add feature gate
- remove trailing whitespace

Add feature gate at the right place

Co-authored-by: Madhav Madhusoodanan <[email protected]>

Update time.rs

making sure seconds are in u64

Co-authored-by: Madhav Madhusoodanan <[email protected]>

Update time.rs

keeping seconds as u64
removing the use of non const function within const function

Use a u128 example time.rs

Earlier for the example I used 2.pow(64).
correcting it to use u128 type which can contain the value

Synched my fork Dummy commit

dummy commit.

sync local with fork

style: format code with rustfmt

Add panic test for Duration::from_nanos_u128

fix: remove non-const .into() call from const function
A const function cannot call non-const functions, so we remove the trailing
.into() call and use raw literals instead.

remove paratheses

Add comment on largest input and explain safety assumption

Ran Rust fmt again

Author: brokemillenial

Cargo.lock

@@ -225,7 +225,7 @@ dependencies = [
  "memchr",
  "serde",
  "serde_derive",
- "winnow 0.7.4",
+ "winnow 0.7.6",
 ]
 
 [[package]]
@@ -6415,9 +6415,9 @@ dependencies = [
 
 [[package]]
 name = "winnow"
-version = "0.7.4"
+version = "0.7.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0e97b544156e9bebe1a0ffbc03484fc1ffe3100cbce3ffb17eac35f7cdd7ab36"
+checksum = "63d3fcd9bba44b03821e7d699eeee959f3126dcc4aa8e4ae18ec617c2a5cea10"
 dependencies = [
  "memchr",
 ]

library/core/src/time.rs

@@ -1,5 +1,4 @@
 #![stable(feature = "duration_core", since = "1.25.0")]
-
 //! Temporal quantification.
 //!
 //! # Examples:
@@ -308,6 +307,39 @@ impl Duration {
         Duration { secs, nanos: subsec_nanos }
     }
 
+    /// Creates a new Duration from the specified number of nanoseconds.
+    ///
+    /// # Panics
+    ///
+    /// Panics if the given number of nanoseconds is greater than what Duration can handle,
+    /// which is `(u64::MAX * NANOS_PER_SEC) + NANOS_PER_SEC - 1`
+    /// Use this function if you need to specify time greater than what can fit in u64
+    /// (around 584 years).
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// #![feature(duration_from_nanos_u128)]
+    /// use std::time::Duration;
+    /// let time_in_nanos = 2u128.pow(64);
+    /// let duration = Duration::from_nanos_u128(time_in_nanos);
+    /// ```
+    #[unstable(feature = "duration_from_nanos_u128", issue = "139201")]
+    #[must_use]
+    #[inline]
+    pub const fn from_nanos_u128(nanos: u128) -> Duration {
+        const NANOS_PER_SEC: u128 = self::NANOS_PER_SEC as u128;
+        let secs: u128 = nanos / NANOS_PER_SEC;
+        if secs > u64::MAX as u128 {
+            panic!("overflow in duration in Duration::from_nanos_u128");
+        }
+        let subsec_nanos = (nanos % NANOS_PER_SEC) as u32;
+        // SAFETY: x % 1_000_000_000 < 1_000_000_000 also, subsec_nanos >= 0 since u128 >=0 and u32 >=0
+        let subsec_nanos = unsafe { Nanoseconds::new_unchecked(subsec_nanos) };
+
+        Duration { secs: secs as u64, nanos: subsec_nanos }
+    }
+
     /// Creates a new `Duration` from the specified number of weeks.
     ///
     /// # Panics