Update Duration types to use a FiniteF64 instead of f64 primitive.

src/components/calendar.rs

@@ -408,7 +408,7 @@ impl Calendar {
                     duration.years(),
                     duration.months(),
                     duration.weeks(),
-                    duration.days() + balance_days,
+                    duration.days().checked_add(&balance_days)?,
                 ),
                 overflow,
             )?;

src/components/date.rs

@@ -14,7 +14,8 @@ use crate::{
         TemporalUnit,
     },
     parsers::parse_date_time,
-    TemporalError, TemporalFields, TemporalResult, TemporalUnwrap,
+    primitive::FiniteF64,
+    Sign, TemporalError, TemporalFields, TemporalResult, TemporalUnwrap,
 };
 use std::str::FromStr;
 
@@ -79,13 +80,20 @@ impl Date {
         // 4. Let overflow be ? ToTemporalOverflow(options).
         // 5. Let norm be NormalizeTimeDuration(duration.[[Hours]], duration.[[Minutes]], duration.[[Seconds]], duration.[[Milliseconds]], duration.[[Microseconds]], duration.[[Nanoseconds]]).
         // 6. Let days be duration.[[Days]] + BalanceTimeDuration(norm, "day").[[Days]].
-        let days = duration.days()
-            + TimeDuration::from_normalized(duration.time().to_normalized(), TemporalUnit::Day)?.0;
+        let days = duration.days().checked_add(
+            &TimeDuration::from_normalized(duration.time().to_normalized(), TemporalUnit::Day)?.0,
+        )?;
 
         // 7. Let result be ? AddISODate(plainDate.[[ISOYear]], plainDate.[[ISOMonth]], plainDate.[[ISODay]], 0, 0, 0, days, overflow).
-        let result = self
-            .iso
-            .add_date_duration(&DateDuration::new(0f64, 0f64, 0f64, days)?, overflow)?;
+        let result = self.iso.add_date_duration(
+            &DateDuration::new(
+                FiniteF64::default(),
+                FiniteF64::default(),
+                FiniteF64::default(),
+                days,
+            )?,
+            overflow,
+        )?;
 
         Ok(Self::new_unchecked(result, self.calendar().clone()))
     }
@@ -109,10 +117,10 @@ impl Date {
         if largest_unit == TemporalUnit::Day {
             let days = self.days_until(other);
             return Ok(Duration::from(DateDuration::new(
-                0f64,
-                0f64,
-                0f64,
-                f64::from(days),
+                FiniteF64::default(),
+                FiniteF64::default(),
+                FiniteF64::default(),
+                FiniteF64::from(days),
             )?));
         }
 
@@ -179,14 +187,11 @@ impl Date {
             duration.date()
         };
 
-        let sign = f64::from(sign as i8);
         // 13. Return ! CreateTemporalDuration(sign × duration.[[Years]], sign × duration.[[Months]], sign × duration.[[Weeks]], sign × duration.[[Days]], 0, 0, 0, 0, 0, 0).
-        Ok(Duration::from(DateDuration::new(
-            date_duration.years * sign,
-            date_duration.months * sign,
-            date_duration.weeks * sign,
-            date_duration.days * sign,
-        )?))
+        match sign {
+            Sign::Positive | Sign::Zero => Ok(Duration::from(date_duration)),
+            Sign::Negative => Ok(Duration::from(date_duration.negated())),
+        }
     }
 }
 

src/components/datetime.rs

@@ -11,6 +11,7 @@ use crate::{
     temporal_assert, Sign, TemporalError, TemporalResult, TemporalUnwrap,
 };
 
+use num_traits::AsPrimitive;
 use std::{cmp::Ordering, str::FromStr};
 use tinystr::TinyAsciiStr;
 
@@ -167,7 +168,7 @@ impl DateTime {
             // a. Let normWithDays be ? Add24HourDaysToNormalizedTimeDuration(diff.[[NormalizedTime]], diff.[[Days]]).
             let norm_with_days = diff
                 .normalized_time_duration()
-                .add_days(diff.date().days as i64)?;
+                .add_days(diff.date().days.as_())?;
             // b. Let timeResult be ! BalanceTimeDuration(normWithDays, largestUnit).
             let (days, time_duration) =
                 TimeDuration::from_normalized(norm_with_days, options.largest_unit)?;
@@ -530,6 +531,7 @@ mod tests {
         components::{calendar::Calendar, duration::DateDuration, Duration},
         iso::{IsoDate, IsoTime},
         options::{DifferenceSettings, RoundingIncrement, TemporalRoundingMode, TemporalUnit},
+        primitive::FiniteF64,
     };
 
     use super::DateTime;
@@ -565,7 +567,15 @@ mod tests {
 
         let result = pdt
             .add(
-                &Duration::from(DateDuration::new(0.0, 1.0, 0.0, 0.0).unwrap()),
+                &Duration::from(
+                    DateDuration::new(
+                        FiniteF64::default(),
+                        FiniteF64(1.0),
+                        FiniteF64::default(),
+                        FiniteF64::default(),
+                    )
+                    .unwrap(),
+                ),
                 None,
             )
             .unwrap();
@@ -582,7 +592,15 @@ mod tests {
 
         let result = pdt
             .subtract(
-                &Duration::from(DateDuration::new(0.0, 1.0, 0.0, 0.0).unwrap()),
+                &Duration::from(
+                    DateDuration::new(
+                        FiniteF64::default(),
+                        FiniteF64(1.0),
+                        FiniteF64::default(),
+                        FiniteF64::default(),
+                    )
+                    .unwrap(),
+                ),
                 None,
             )
             .unwrap();
@@ -597,7 +615,7 @@ mod tests {
         let dt =
             DateTime::new(2019, 10, 29, 10, 46, 38, 271, 986, 102, Calendar::default()).unwrap();
 
-        let result = dt.subtract(&Duration::hour(12.0), None).unwrap();
+        let result = dt.subtract(&Duration::hour(FiniteF64(12.0)), None).unwrap();
 
         assert_eq!(
             result.iso.date,
@@ -619,7 +637,7 @@ mod tests {
             }
         );
 
-        let result = dt.add(&Duration::hour(-12.0), None).unwrap();
+        let result = dt.add(&Duration::hour(FiniteF64(-12.0)), None).unwrap();
 
         assert_eq!(
             result.iso.date,