[temporal] Uplift float64-representable integer patch

Uplifts boa-dev/temporal#621

Bug: 401065166
Change-Id: Iad750a4e3c93dd65c7b2b10ab7e3789f5cc877de
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/7142574
Commit-Queue: Manish Goregaokar <manishearth@google.com>
Reviewed-by: Łukasz Anforowicz <lukasza@chromium.org>
Cr-Commit-Position: refs/heads/main@{#1543294}

Author: Manishearth

third_party/rust/chromium_crates_io/patches/temporal_rs/0005-float64-representable-integer.patch

@@ -0,0 +1,96 @@
+From c5132c3281040b4c7b91a53701d2925ca0c89169 Mon Sep 17 00:00:00 2001
+From: Manish Goregaokar <manishearth@google.com>
+Date: Tue, 11 Nov 2025 17:06:35 +0000
+Subject: [PATCH] [temporal] Uplift float64-representable integer patch
+
+Uplifts https://github.com/boa-dev/temporal/pull/621
+
+Change-Id: Iad750a4e3c93dd65c7b2b10ab7e3789f5cc877de
+---
+ .../vendor/temporal_rs-v0_1/Cargo.toml.orig   | 190 +++++++++---------
+ .../src/builtins/core/duration.rs             |  10 +-
+ .../src/builtins/core/duration/tests.rs       |  43 ++--
+ 3 files changed, 136 insertions(+), 107 deletions(-)
+
+diff --git a/third_party/rust/chromium_crates_io/vendor/temporal_rs-v0_1/src/builtins/core/duration.rs b/third_party/rust/chromium_crates_io/vendor/temporal_rs-v0_1/src/builtins/core/duration.rs
+index f687cee32795b..59682fccb7be9 100644
+--- a/third_party/rust/chromium_crates_io/vendor/temporal_rs-v0_1/src/builtins/core/duration.rs
++++ b/third_party/rust/chromium_crates_io/vendor/temporal_rs-v0_1/src/builtins/core/duration.rs
+@@ -389,9 +389,13 @@ impl Duration {
+             hours,
+             minutes,
+             seconds,
+-            milliseconds,
+-            microseconds,
+-            nanoseconds,
++
++            // https://github.com/boa-dev/temporal/issues/613
++            // With float64_representable_durations enabled, force all smaller units
++            // to be in the float64-representable range.
++            milliseconds: milliseconds as f64 as u64,
++            microseconds: microseconds as f64 as u128,
++            nanoseconds: nanoseconds as f64 as u128,
+         }
+     }
+ 
+diff --git a/third_party/rust/chromium_crates_io/vendor/temporal_rs-v0_1/src/builtins/core/duration/tests.rs b/third_party/rust/chromium_crates_io/vendor/temporal_rs-v0_1/src/builtins/core/duration/tests.rs
+index 5eae2888ba21f..688968433ffc6 100644
+--- a/third_party/rust/chromium_crates_io/vendor/temporal_rs-v0_1/src/builtins/core/duration/tests.rs
++++ b/third_party/rust/chromium_crates_io/vendor/temporal_rs-v0_1/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"
++    );
++}
+-- 
+2.51.2.1041.gc1ab5b90ca-goog
+

third_party/rust/chromium_crates_io/vendor/temporal_rs-v0_1/src/builtins/core/duration.rs

@@ -389,9 +389,13 @@ impl Duration {
             hours,
             minutes,
             seconds,
-            milliseconds,
-            microseconds,
-            nanoseconds,
+
+            // https://github.com/boa-dev/temporal/issues/613
+            // With float64_representable_durations enabled, force all smaller units
+            // to be in the float64-representable range.
+            milliseconds: milliseconds as f64 as u64,
+            microseconds: microseconds as f64 as u128,
+            nanoseconds: nanoseconds as f64 as u128,
         }
     }
 

third_party/rust/chromium_crates_io/vendor/temporal_rs-v0_1/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"
+    );
+}