Review feedback

src/components/calendar.rs

@@ -495,8 +495,10 @@ impl<C: CalendarProtocol> CalendarSlot<C> {
             CalendarSlot::Builtin(AnyCalendar::Iso(_)) => {
                 // 8. Let norm be NormalizeTimeDuration(duration.[[Hours]], duration.[[Minutes]], duration.[[Seconds]], duration.[[Milliseconds]], duration.[[Microseconds]], duration.[[Nanoseconds]]).
                 // 9. Let balanceResult be BalanceTimeDuration(norm, "day").
-                let (balance_days, _) =
-                    TimeDuration::from_normalized(duration.time().as_norm(), TemporalUnit::Day)?;
+                let (balance_days, _) = TimeDuration::from_normalized(
+                    duration.time().to_normalized(),
+                    TemporalUnit::Day,
+                )?;
                 // 10. Let result be ? AddISODate(date.[[ISOYear]], date.[[ISOMonth]], date.[[ISODay]], duration.[[Years]], duration.[[Months]], duration.[[Weeks]], duration.[[Days]] + balanceResult.[[Days]], overflow).
                 let result = date.iso().add_iso_date(
                     &DateDuration::new_unchecked(

src/components/date.rs

@@ -359,7 +359,7 @@ impl<C: CalendarProtocol> Date<C> {
         // 3. Let overflow be ? ToTemporalOverflow(options).
         // 4. Let days be ? BalanceTimeDuration(duration.[[Days]], duration.[[Hours]], duration.[[Minutes]], duration.[[Seconds]], duration.[[Milliseconds]], duration.[[Microseconds]], duration.[[Nanoseconds]], "day").[[Days]].
         let (days, _) =
-            TimeDuration::from_normalized(duration.time().as_norm(), TemporalUnit::Day)?;
+            TimeDuration::from_normalized(duration.time().to_normalized(), TemporalUnit::Day)?;
 
         // 5. Let result be ? AddISODate(plainDate.[[ISOYear]], plainDate.[[ISOMonth]], plainDate.[[ISODay]], 0, 0, 0, days, overflow).
         let result = self

src/components/duration.rs

@@ -924,7 +924,7 @@ impl Duration {
     /// Calls `TimeDuration`'s balance method on the current `Duration`.
     #[inline]
     pub fn balance_time_duration(&self, unit: TemporalUnit) -> TemporalResult<(f64, TimeDuration)> {
-        TimeDuration::from_normalized(self.time().as_norm(), unit)
+        TimeDuration::from_normalized(self.time().to_normalized(), unit)
     }
 }
 

src/components/duration/time.rs

@@ -399,8 +399,8 @@ impl TimeDuration {
     }
 
     /// Returns this `TimeDuration` as a `NormalizedTimeDuration`.
-    pub(crate) fn as_norm(&self) -> NormalizedTimeDuration {
-        NormalizedTimeDuration::from_time_duration(self)
+    pub(crate) fn to_normalized(self) -> NormalizedTimeDuration {
+        NormalizedTimeDuration::from_time_duration(&self)
     }
 }
 

src/components/instant.rs

@@ -78,7 +78,8 @@ impl Instant {
 
         if smallest_unit == TemporalUnit::Nanosecond {
             let (_, result) = TimeDuration::from_normalized(
-                TimeDuration::new_unchecked(0f64, 0f64, secs, millis, micros, nanos).as_norm(),
+                TimeDuration::new_unchecked(0f64, 0f64, secs, millis, micros, nanos)
+                    .to_normalized(),
                 largest_unit,
             )?;
             return Ok(result);
@@ -89,7 +90,8 @@ impl Instant {
             smallest_unit,
             rounding_mode,
         )?;
-        let (_, result) = TimeDuration::from_normalized(round_result.as_norm(), largest_unit)?;
+        let (_, result) =
+            TimeDuration::from_normalized(round_result.to_normalized(), largest_unit)?;
         Ok(result)
     }