Fix incorrect decimal digits bug (#679)

This closes #677.

We are not correctly throwing on invalid time records when the decimal
digits exceed 9 digits. This PR addresses that problem and adds unit
tests.

Author: nekevss

src/builtins/core/instant.rs

@@ -303,7 +303,13 @@ impl Instant {
             UtcOffsetRecordOrZ::Offset(offset) => {
                 let ns = offset
                     .fraction()
-                    .and_then(|x| x.to_nanoseconds())
+                    .map(|x| {
+                        x.to_nanoseconds().ok_or(
+                            TemporalError::range()
+                                .with_enum(ErrorMessage::FractionalTimeMoreThanNineDigits),
+                        )
+                    })
+                    .transpose()?
                     .unwrap_or(0);
                 (offset.hour() as i64 * NANOSECONDS_PER_HOUR
                     + i64::from(offset.minute()) * NANOSECONDS_PER_MINUTE
@@ -317,7 +323,13 @@ impl Instant {
         let time_nanoseconds = ixdtf_record
             .time
             .fraction
-            .and_then(|x| x.to_nanoseconds())
+            .map(|x| {
+                x.to_nanoseconds().ok_or(
+                    TemporalError::range()
+                        .with_enum(ErrorMessage::FractionalTimeMoreThanNineDigits),
+                )
+            })
+            .transpose()?
             .unwrap_or(0);
         let (millisecond, rem) = time_nanoseconds.div_rem_euclid(&1_000_000);
         let (microsecond, nanosecond) = rem.div_rem_euclid(&1_000);

src/builtins/core/zoned_date_time/tests.rs

@@ -1175,6 +1175,34 @@ fn test_same_date_reverse_wallclock() {
     })
 }
 
+#[test]
+fn test_invalid_fractional_offset_digits() {
+    test_all_providers!(provider: {
+        let test = "2020-01-01T00:00:00.123456789+02:30:00.1234567890[UTC]";
+        let result = ZonedDateTime::from_utf8_with_provider(
+            test.as_bytes(),
+            crate::options::Disambiguation::Compatible,
+            crate::options::OffsetDisambiguation::Use,
+            &provider,
+        );
+        assert!(result.is_err(), "ZonedDateTime should be invalid");
+    })
+}
+
+#[test]
+fn test_valid_fractional_offset_digits() {
+    test_all_providers!(provider: {
+        let test = "2020-01-01T00:00:00.123456789+02:30:00.123456789[UTC]";
+        let result = ZonedDateTime::from_utf8_with_provider(
+            test.as_bytes(),
+            crate::options::Disambiguation::Compatible,
+            crate::options::OffsetDisambiguation::Use,
+            &provider,
+        );
+        assert!(result.is_ok(), "ZonedDateTime should be valid");
+    })
+}
+
 #[test]
 fn test_relativeto_back_transition() {
     // intl402/Temporal/Duration/prototype/round/relativeto-dst-back-transition

src/builtins/mod.rs

@@ -19,3 +19,46 @@ pub static TZ_PROVIDER: LazyLock<CompiledTzdbProvider> =
 
 #[cfg(all(test, feature = "compiled_data"))]
 pub(crate) static FS_TZ_PROVIDER: LazyLock<FsTzdbProvider> = LazyLock::new(FsTzdbProvider::default);
+
+#[cfg(test)]
+mod tests {
+    use super::{Instant, PlainDate, PlainDateTime};
+    #[test]
+    fn builtins_from_str_10_digit_fractions() {
+        // Failure case with 10 digits
+        let test = "2020-01-01T00:00:00.1234567890Z";
+        let result = Instant::from_utf8(test.as_bytes());
+        assert!(result.is_err(), "Instant fraction should be invalid");
+        let result = PlainDate::from_utf8(test.as_bytes());
+        assert!(result.is_err(), "PlainDate fraction should be invalid");
+        let result = PlainDateTime::from_utf8(test.as_bytes());
+        assert!(result.is_err(), "PlainDateTime fraction should be invalid");
+    }
+
+    #[test]
+    fn instant_based_10_digit_offset() {
+        let test = "2020-01-01T00:00:00.123456789+02:30:00.1234567890[UTC]";
+        let result = Instant::from_utf8(test.as_bytes());
+        assert!(result.is_err(), "Instant should be invalid");
+    }
+
+    #[test]
+    fn instant_based_9_digit_offset() {
+        let test = "2020-01-01T00:00:00.123456789+02:30:00.123456789[UTC]";
+        let result = Instant::from_utf8(test.as_bytes());
+        assert!(result.is_ok(), "Instant should be valid");
+    }
+
+    #[test]
+    fn builtin_from_str_9_digit_fractions() {
+        // Success case with 9 digits
+        let test = "2020-01-01T00:00:00.123456789Z";
+        let result = Instant::from_utf8(test.as_bytes());
+        assert!(result.is_ok(), "Instant fraction should be valid");
+        let test = "2020-01-01T00:00:00.123456789";
+        let result = PlainDate::from_utf8(test.as_bytes());
+        assert!(result.is_ok(), "PlainDate fraction should be valid");
+        let result = PlainDateTime::from_utf8(test.as_bytes());
+        assert!(result.is_ok(), "PlainDateTime fraction should be valid");
+    }
+}

src/parsed_intermediates.rs

@@ -48,6 +48,16 @@ impl ParsedDate {
         // Assertion: PlainDate must exist on a DateTime parse.
         let record = parse_record.date.temporal_unwrap()?;
 
+        // TODO: Potentially, remove this check in favor of type guarantee of a
+        // Temporal parser.
+        // NOTE: The check here is to confirm that the time component is
+        // valid.
+        let _time = parse_record
+            .time
+            .map(IsoTime::from_time_record)
+            .transpose()?
+            .unwrap_or_default();
+
         Ok(Self { record, calendar })
     }
     /// Converts a UTF-8 encoded YearMonth string into a `ParsedDate`.
@@ -59,8 +69,19 @@ impl ParsedDate {
         // Assertion: PlainDate must exist on a DateTime parse.
         let record = parse_record.date.temporal_unwrap()?;
 
+        // TODO: Potentially, remove this check in favor of type guarantee of a
+        // Temporal parser.
+        // NOTE: The check here is to confirm that the time component is
+        // valid.
+        let _time = parse_record
+            .time
+            .map(IsoTime::from_time_record)
+            .transpose()?
+            .unwrap_or_default();
+
         Ok(Self { record, calendar })
     }
+
     /// Converts a UTF-8 encoded MonthDay string into a `ParsedDate`.
     pub fn month_day_from_utf8(s: &[u8]) -> TemporalResult<Self> {
         let parse_record = parsers::parse_month_day(s)?;
@@ -70,6 +91,16 @@ impl ParsedDate {
         // Assertion: PlainDate must exist on a DateTime parse.
         let record = parse_record.date.temporal_unwrap()?;
 
+        // TODO: Potentially, remove this check in favor of type guarantee of a
+        // Temporal parser.
+        // NOTE: The check here is to confirm that the time component is
+        // valid.
+        let _time = parse_record
+            .time
+            .map(IsoTime::from_time_record)
+            .transpose()?
+            .unwrap_or_default();
+
         Ok(Self { record, calendar })
     }
 }