Added Duration::try_milliseconds()

  - Added a new Duration::try_milliseconds() function, to attempt to
    create a new milliseconds-based Duration, and return None if it
    fails, based on checking against MAX and MIN. Currently, failure can
    only happen for exactly one value, which is i64::MIN.

  - Updated Duration::milliseconds() to call try_milliseconds() and
    panic if None is returned. Although panicking in production code and
    especially library code is bad, this is in keeping with current
    Chrono behaviour. Note that this function is now no longer const.

  - Updated the Duration::milliseconds() documentation to make it clear
    that it now panics.

  - Added documentation to Duration::microseconds() and nanoseconds() to
    make it clear that they are infallible.

  - All tests now pass.

src/duration.rs

@@ -211,14 +211,44 @@ impl Duration {
     }
 
     /// Makes a new `Duration` with the given number of milliseconds.
+    ///
+    /// # Panics
+    ///
+    /// Panics when the duration is out of bounds, i.e. when the duration is
+    /// more than `i64::MAX` milliseconds or less than `-i64::MAX` milliseconds.
+    /// Notably, this is not the same as `i64::MIN`.
     #[inline]
-    pub const fn milliseconds(milliseconds: i64) -> Duration {
+    pub fn milliseconds(milliseconds: i64) -> Duration {
+        Duration::try_milliseconds(milliseconds).expect("Duration::milliseconds out of bounds")
+    }
+
+    /// Makes a new `Duration` with the given number of milliseconds.
+    ///
+    /// # Errors
+    ///
+    /// Returns `None` when the duration is more than `i64::MAX` milliseconds or
+    /// less than `-i64::MAX` milliseconds. Notably, this is not the same as
+    /// `i64::MIN`.
+    #[inline]
+    pub fn try_milliseconds(milliseconds: i64) -> Option<Duration> {
         let (secs, millis) = div_mod_floor_64(milliseconds, MILLIS_PER_SEC);
-        let nanos = millis as i32 * NANOS_PER_MILLI;
-        Duration { secs, nanos }
+        let d = Duration { secs, nanos: millis as i32 * NANOS_PER_MILLI };
+        // Technically we don't need to compare against MAX, as this function
+        // accepts an i64, and MAX is aligned to i64::MAX milliseconds. However,
+        // it is good practice to check it here in order to catch any future
+        // changes that might be made.
+        if d < MIN || d > MAX {
+            return None;
+        }
+        Some(d)
     }
 
     /// Makes a new `Duration` with the given number of microseconds.
+    ///
+    /// The number of microseconds acceptable by this constructor is far less
+    /// than the total number that can actually be stored in a `Duration`, so it
+    /// is not possible to specify a value that would be out of bounds. This
+    /// function is therefore infallible.
     #[inline]
     pub const fn microseconds(microseconds: i64) -> Duration {
         let (secs, micros) = div_mod_floor_64(microseconds, MICROS_PER_SEC);
@@ -227,6 +257,11 @@ impl Duration {
     }
 
     /// Makes a new `Duration` with the given number of nanoseconds.
+    ///
+    /// The number of nanoseconds acceptable by this constructor is far less
+    /// than the total number that can actually be stored in a `Duration`, so it
+    /// is not possible to specify a value that would be out of bounds. This
+    /// function is therefore infallible.
     #[inline]
     pub const fn nanoseconds(nanos: i64) -> Duration {
         let (secs, nanos) = div_mod_floor_64(nanos, NANOS_PER_SEC as i64);