use temporal parser in from_utf8

blarfoon · blarfoon · commit 172fe6469d33 · 2025-06-29T18:21:55.000+02:00
diff --git a/src/builtins/core/datetime.rs b/src/builtins/core/datetime.rs
@@ -12,10 +12,10 @@ use crate::{
         DisplayCalendar, ResolvedRoundingOptions, RoundingOptions, ToStringRoundingOptions, Unit,
         UnitGroup,
     },
-    parsers::{parse_date_time, IxdtfStringBuilder},
+    parsers::{IxdtfStringBuilder, TemporalParser},
     primitive::FiniteF64,
     provider::{NeverProvider, TimeZoneProvider},
-    temporal_assert, MonthCode, TemporalError, TemporalResult, TemporalUnwrap, TimeZone,
+    temporal_assert, MonthCode, TemporalError, TemporalResult, TimeZone,
 };
 use alloc::string::String;
 use core::{cmp::Ordering, str::FromStr};
@@ -549,30 +549,17 @@ impl PlainDateTime {
 
     // Converts a UTF-8 encoded string into a `PlainDateTime`.
     pub fn from_utf8(s: &[u8]) -> TemporalResult<Self> {
-        let parse_record = parse_date_time(s)?;
-
-        let calendar = parse_record
-            .calendar
-            .map(Calendar::try_from_utf8)
-            .transpose()?
-            .unwrap_or_default();
-
-        let time = parse_record
-            .time
-            .map(IsoTime::from_time_record)
-            .transpose()?
-            .unwrap_or_default();
-
-        let parsed_date = parse_record.date.temporal_unwrap()?;
-
-        let date = IsoDate::new_with_overflow(
-            parsed_date.year,
-            parsed_date.month,
-            parsed_date.day,
-            ArithmeticOverflow::Reject,
-        )?;
+        let parser = TemporalParser::new();
+        let parsed = parser.parse_date_time(core::str::from_utf8(s)
+            .map_err(|_| TemporalError::syntax().with_message("Invalid UTF-8 in datetime string"))?)?;
+
+        let calendar = if let Some(cal_str) = &parsed.calendar {
+            Calendar::try_from_utf8(cal_str.as_bytes())?
+        } else {
+            Calendar::default()
+        };
 
-        Ok(Self::new_unchecked(IsoDateTime::new(date, time)?, calendar))
+        Ok(Self::new_unchecked(parsed.iso, calendar))
     }
 
     /// Creates a new `DateTime` with the fields of a `PartialDateTime`.
diff --git a/src/builtins/core/instant.rs b/src/builtins/core/instant.rs
@@ -12,7 +12,7 @@ use crate::{
         DifferenceOperation, DifferenceSettings, DisplayOffset, ResolvedRoundingOptions,
         RoundingOptions, ToStringRoundingOptions, Unit, UnitGroup,
     },
-    parsers::{parse_instant, IxdtfStringBuilder},
+    parsers::{IxdtfStringBuilder, TemporalParser},
     provider::TimeZoneProvider,
     rounding::{IncrementRounder, Round},
     unix_time::EpochNanoseconds,
@@ -278,10 +278,12 @@ impl Instant {
 
     // Converts a UTF-8 encoded string into a `Instant`.
     pub fn from_utf8(s: &[u8]) -> TemporalResult<Self> {
-        let ixdtf_record = parse_instant(s)?;
+        let parser = TemporalParser::new();
+        let parsed = parser.parse_instant(core::str::from_utf8(s)
+            .map_err(|_| TemporalError::syntax().with_message("Invalid UTF-8 in instant string"))?)?;
 
-        // Find the offset
-        let ns_offset = match ixdtf_record.offset {
+        // Find the offset  
+        let ns_offset = match parsed.offset {
             UtcOffsetRecordOrZ::Offset(offset) => {
                 let ns = offset
                     .fraction()
@@ -296,21 +298,19 @@ impl Instant {
             UtcOffsetRecordOrZ::Z => 0,
         };
 
-        let time_nanoseconds = ixdtf_record
-            .time
-            .fraction
-            .and_then(|x| x.to_nanoseconds())
-            .unwrap_or(0);
+        let time_nanoseconds = parsed.iso.time.millisecond as u32 * 1_000_000
+            + parsed.iso.time.microsecond as u32 * 1_000
+            + parsed.iso.time.nanosecond as u32;
         let (millisecond, rem) = time_nanoseconds.div_rem_euclid(&1_000_000);
         let (microsecond, nanosecond) = rem.div_rem_euclid(&1_000);
 
         let balanced = IsoDateTime::balance(
-            ixdtf_record.date.year,
-            ixdtf_record.date.month.into(),
-            ixdtf_record.date.day.into(),
-            ixdtf_record.time.hour.into(),
-            ixdtf_record.time.minute.into(),
-            ixdtf_record.time.second.clamp(0, 59).into(),
+            parsed.iso.date.year,
+            parsed.iso.date.month.into(),
+            parsed.iso.date.day.into(),
+            parsed.iso.time.hour.into(),
+            parsed.iso.time.minute.into(),
+            parsed.iso.time.second.clamp(0, 59).into(),
             millisecond.into(),
             microsecond.into(),
             i128::from(nanosecond) - i128::from(ns_offset),
diff --git a/src/builtins/core/month_day.rs b/src/builtins/core/month_day.rs
@@ -6,8 +6,8 @@ use core::str::FromStr;
 use crate::{
     iso::IsoDate,
     options::{ArithmeticOverflow, DisplayCalendar},
-    parsers::{FormattableCalendar, FormattableDate, FormattableMonthDay},
-    Calendar, MonthCode, TemporalError, TemporalResult, TemporalUnwrap,
+    parsers::{FormattableCalendar, FormattableDate, FormattableMonthDay, TemporalParser},
+    Calendar, MonthCode, TemporalError, TemporalResult,
 };
 
 use super::{calendar::month_to_month_code, PartialDate, PlainDate};
@@ -189,13 +189,15 @@ impl PlainMonthDay {
 
     // Converts a UTF-8 encoded string into a `PlainMonthDay`.
     pub fn from_utf8(s: &[u8]) -> TemporalResult<Self> {
-        let record = crate::parsers::parse_month_day(s)?;
+        let parser = TemporalParser::new();
+        let parsed = parser.parse_month_day(core::str::from_utf8(s)
+            .map_err(|_| TemporalError::syntax().with_message("Invalid UTF-8 in month-day string"))?)?;
 
-        let calendar = record
-            .calendar
-            .map(Calendar::try_from_utf8)
-            .transpose()?
-            .unwrap_or_default();
+        let calendar = if let Some(cal_str) = &parsed.calendar {
+            Calendar::try_from_utf8(cal_str.as_bytes())?
+        } else {
+            Calendar::default()
+        };
 
         // ParseISODateTime
         // Step 4.a.ii.3
@@ -206,13 +208,9 @@ impl PlainMonthDay {
             return Err(TemporalError::range().with_message("non-ISO calendar not supported."));
         }
 
-        let date = record.date;
-
-        let date = date.temporal_unwrap()?;
-
         Self::new_with_overflow(
-            date.month,
-            date.day,
+            parsed.iso.month,
+            parsed.iso.day,
             calendar,
             ArithmeticOverflow::Reject,
             None,
diff --git a/src/builtins/core/time.rs b/src/builtins/core/time.rs
@@ -7,7 +7,7 @@ use crate::{
         ArithmeticOverflow, DifferenceOperation, DifferenceSettings, ResolvedRoundingOptions,
         RoundingIncrement, RoundingMode, ToStringRoundingOptions, Unit, UnitGroup,
     },
-    parsers::{parse_time, IxdtfStringBuilder},
+    parsers::{IxdtfStringBuilder, TemporalParser},
     TemporalError, TemporalResult,
 };
 use alloc::string::String;
@@ -418,9 +418,10 @@ impl PlainTime {
 
     // Converts a UTF-8 encoded string into a `PlainTime`.
     pub fn from_utf8(s: &[u8]) -> TemporalResult<Self> {
-        let result = parse_time(s)?;
-        let iso = IsoTime::from_time_record(result)?;
-        Ok(Self::new_unchecked(iso))
+        let parser = TemporalParser::new();
+        let parsed = parser.parse_time(core::str::from_utf8(s)
+            .map_err(|_| TemporalError::syntax().with_message("Invalid UTF-8 in time string"))?)?;
+        Ok(Self::new_unchecked(parsed.iso))
     }
 
     /// Creates a new `PlainTime` using the current `PlainTime` fields as a fallback.
diff --git a/src/builtins/core/year_month.rs b/src/builtins/core/year_month.rs
@@ -11,10 +11,10 @@ use crate::{
         ArithmeticOverflow, DifferenceOperation, DifferenceSettings, DisplayCalendar,
         ResolvedRoundingOptions, RoundingIncrement, Unit, UnitGroup,
     },
-    parsers::{FormattableCalendar, FormattableDate, FormattableYearMonth},
+    parsers::{FormattableCalendar, FormattableDate, FormattableYearMonth, TemporalParser},
     provider::NeverProvider,
     utils::pad_iso_year,
-    Calendar, MonthCode, TemporalError, TemporalResult, TemporalUnwrap, TimeZone,
+    Calendar, MonthCode, TemporalError, TemporalResult, TimeZone,
 };
 use icu_calendar::AnyCalendarKind;
 
@@ -460,12 +460,15 @@ impl PlainYearMonth {
 
     // Converts a UTF-8 encoded string into a `PlainYearMonth`.
     pub fn from_utf8(s: &[u8]) -> TemporalResult<Self> {
-        let record = crate::parsers::parse_year_month(s)?;
-        let calendar = record
-            .calendar
-            .map(Calendar::try_from_utf8)
-            .transpose()?
-            .unwrap_or_default();
+        let parser = TemporalParser::new();
+        let parsed = parser.parse_year_month(core::str::from_utf8(s)
+            .map_err(|_| TemporalError::syntax().with_message("Invalid UTF-8 in year-month string"))?)?;
+
+        let calendar = if let Some(cal_str) = &parsed.calendar {
+            Calendar::try_from_utf8(cal_str.as_bytes())?
+        } else {
+            Calendar::default()
+        };
 
         // ParseISODateTime
         // Step 4.a.ii.3
@@ -476,11 +479,9 @@ impl PlainYearMonth {
             return Err(TemporalError::range().with_message("non-ISO calendar not supported."));
         }
 
-        let date = record.date.temporal_unwrap()?;
-
         // The below steps are from `ToTemporalYearMonth`
         // 10. Let isoDate be CreateISODateRecord(result.[[Year]], result.[[Month]], result.[[Day]]).
-        let iso = IsoDate::new_unchecked(date.year, date.month, date.day);
+        let iso = parsed.iso;
 
         // 11. If ISOYearMonthWithinLimits(isoDate) is false, throw a RangeError exception.
         if !year_month_within_limits(iso.year, iso.month) {
