Add feature to force float64-representable durations (#621)

Fixes #613

Author: Manishearth

Cargo.toml

@@ -109,6 +109,10 @@ tzdb = [
     "timezone_provider/tzif",
 ]
 std = []
+# https://github.com/boa-dev/temporal/issues/613
+# ECMA-conformant implementations must store durations as float64-representable numbers
+# Rust users probably should not enable this, unless they wish to match the quirks of JavaScript
+float64_representable_durations = []
 
 [package.metadata.cargo-all-features]
 denylist = ["default"]

src/builtins/core/duration.rs

@@ -389,8 +389,21 @@ impl Duration {
             hours,
             minutes,
             seconds,
+
+            // https://github.com/boa-dev/temporal/issues/613
+            // With float64_representable_durations enabled, force all smaller units
+            // to be in the float64-representable range.
+            #[cfg(feature = "float64_representable_durations")]
+            milliseconds: milliseconds as f64 as u64,
+            #[cfg(feature = "float64_representable_durations")]
+            microseconds: microseconds as f64 as u128,
+            #[cfg(feature = "float64_representable_durations")]
+            nanoseconds: nanoseconds as f64 as u128,
+            #[cfg(not(feature = "float64_representable_durations"))]
             milliseconds,
+            #[cfg(not(feature = "float64_representable_durations"))]
             microseconds,
+            #[cfg(not(feature = "float64_representable_durations"))]
             nanoseconds,
         }
     }

src/builtins/core/duration/tests.rs

@@ -404,23 +404,40 @@ fn test_duration_compare() {
         )
     }
 }
-/*
-TODO: Uncomment
 
-The below test should fail, but currently doesn't. This has to do with weird
-floating point math in IsValidDuration Step 6-8 that defers to C++ std::remquo
-
-Needs further clarification.
+const MAX_SAFE_INT: i64 = 9_007_199_254_740_991;
 
 #[test]
 fn duration_round_out_of_range_norm_conversion() {
-    const MAX_SAFE_INT: i64 = 9_007_199_254_740_991;
     let duration = Duration::new(0, 0, 0, 0, 0, 0, MAX_SAFE_INT, 0, 0, 999_999_999).unwrap();
-    let err = duration.round_with_provider( RoundingOptions {
-        largest_unit: Some(Unit::Nanosecond),
-        increment: Some(RoundingIncrement::ONE),
-        ..Default::default()
-    }, None, &NeverProvider::default());
+    let err = duration.round_with_provider(
+        RoundingOptions {
+            largest_unit: Some(Unit::Nanosecond),
+            increment: Some(RoundingIncrement::ONE),
+            ..Default::default()
+        },
+        None,
+        &NeverProvider::default(),
+    );
     assert!(err.is_err())
 }
-*/
+
+#[test]
+#[cfg_attr(not(feature = "float64_representable_durations"), should_panic)]
+fn duration_float64_representable() {
+    // built-ins/Temporal/Duration/prototype/add/float64-representable-integer
+    let duration = Duration::new(0, 0, 0, 0, 0, 0, 0, 0, MAX_SAFE_INT as i128, 0).unwrap();
+    let duration2 = Duration::new(0, 0, 0, 0, 0, 0, 0, 0, MAX_SAFE_INT as i128 - 1, 0).unwrap();
+    let added = duration.add(&duration2).unwrap();
+    assert_eq!(added.microseconds, 18014398509481980);
+    assert_eq!(
+        added.as_temporal_string(Default::default()).unwrap(),
+        "PT18014398509.48198S"
+    );
+    let one_ms = Duration::new(0, 0, 0, 0, 0, 0, 0, 0, 1, 0).unwrap();
+    let added_plus_one = added.add(&one_ms).unwrap();
+    assert_eq!(
+        added, added_plus_one,
+        "Should not internally use a more accurate representation when adding"
+    );
+}