Merge branch 'chronotope:main' into main

pebender · web-flow · commit 9ca7a50389eb · 2025-10-03T16:27:57.000-07:00
diff --git a/src/datetime/mod.rs b/src/datetime/mod.rs
@@ -21,8 +21,8 @@ use crate::format::Locale;
 #[cfg(feature = "alloc")]
 use crate::format::{DelayedFormat, SecondsFormat, write_rfc2822, write_rfc3339};
 use crate::format::{
-    Fixed, Item, ParseError, ParseResult, Parsed, StrftimeItems, TOO_LONG, parse,
-    parse_and_remainder, parse_rfc3339,
+    Fixed, Item, ParseError, ParseResult, Parsed, StrftimeItems, parse, parse_and_remainder,
+    parse_rfc3339,
 };
 use crate::naive::{Days, IsoWeek, NaiveDate, NaiveDateTime, NaiveTime};
 #[cfg(feature = "clock")]
@@ -1068,12 +1068,7 @@ impl DateTime<FixedOffset> {
     /// also simultaneously valid RFC 3339 values, but not all RFC 3339 values are valid ISO 8601
     /// values (or the other way around).
     pub fn parse_from_rfc3339(s: &str) -> ParseResult<DateTime<FixedOffset>> {
-        let mut parsed = Parsed::new();
-        let (s, _) = parse_rfc3339(&mut parsed, s)?;
-        if !s.is_empty() {
-            return Err(TOO_LONG);
-        }
-        parsed.to_datetime()
+        parse_rfc3339(s)
     }
 
     /// Parses a string from a user-specified format into a `DateTime<FixedOffset>` value.
diff --git a/src/format/parse.rs b/src/format/parse.rs
@@ -11,7 +11,7 @@ use super::scan;
 use super::{BAD_FORMAT, INVALID, OUT_OF_RANGE, TOO_LONG, TOO_SHORT};
 use super::{Fixed, InternalFixed, InternalInternal, Item, Numeric, Pad, Parsed};
 use super::{ParseError, ParseResult};
-use crate::{DateTime, FixedOffset, Weekday};
+use crate::{DateTime, FixedOffset, MappedLocalTime, NaiveDate, NaiveTime, Weekday};
 
 fn set_weekday_with_num_days_from_sunday(p: &mut Parsed, v: i64) -> ParseResult<()> {
     p.set_weekday(match v {
@@ -151,7 +151,7 @@ fn parse_rfc2822<'a>(parsed: &mut Parsed, mut s: &'a str) -> ParseResult<(&'a st
     Ok((s, ()))
 }
 
-pub(crate) fn parse_rfc3339<'a>(parsed: &mut Parsed, mut s: &'a str) -> ParseResult<(&'a str, ())> {
+pub(crate) fn parse_rfc3339(mut s: &str) -> ParseResult<DateTime<FixedOffset>> {
     macro_rules! try_consume {
         ($e:expr) => {{
             let (s_, v) = $e?;
@@ -189,40 +189,81 @@ pub(crate) fn parse_rfc3339<'a>(parsed: &mut Parsed, mut s: &'a str) -> ParseRes
     //
     // - For readability a full-date and a full-time may be separated by a space character.
 
-    parsed.set_year(try_consume!(scan::number(s, 4, 4)))?;
-    s = scan::char(s, b'-')?;
-    parsed.set_month(try_consume!(scan::number(s, 2, 2)))?;
-    s = scan::char(s, b'-')?;
-    parsed.set_day(try_consume!(scan::number(s, 2, 2)))?;
+    let bytes = s.as_bytes();
+    if bytes.len() < 19 {
+        return Err(TOO_SHORT);
+    }
 
-    s = match s.as_bytes().first() {
-        Some(&b't' | &b'T' | &b' ') => &s[1..],
-        Some(_) => return Err(INVALID),
-        None => return Err(TOO_SHORT),
-    };
+    let fixed = <&[u8; 19]>::try_from(&bytes[..19]).unwrap(); // we just checked the length
+    let year = digit(fixed, 0)? as u16 * 1000
+        + digit(fixed, 1)? as u16 * 100
+        + digit(fixed, 2)? as u16 * 10
+        + digit(fixed, 3)? as u16;
+    if bytes.get(4) != Some(&b'-') {
+        return Err(INVALID);
+    }
 
-    parsed.set_hour(try_consume!(scan::number(s, 2, 2)))?;
-    s = scan::char(s, b':')?;
-    parsed.set_minute(try_consume!(scan::number(s, 2, 2)))?;
-    s = scan::char(s, b':')?;
-    parsed.set_second(try_consume!(scan::number(s, 2, 2)))?;
-    if s.starts_with('.') {
-        let nanosecond = try_consume!(scan::nanosecond(&s[1..]));
-        parsed.set_nanosecond(nanosecond)?;
+    let month = digit(fixed, 5)? * 10 + digit(fixed, 6)?;
+    if bytes.get(7) != Some(&b'-') {
+        return Err(INVALID);
     }
 
-    let offset = try_consume!(scan::timezone_offset(s, |s| scan::char(s, b':'), true, false, true));
-    // This range check is similar to the one in `FixedOffset::east_opt`, so it would be redundant.
-    // But it is possible to read the offset directly from `Parsed`. We want to only successfully
-    // populate `Parsed` if the input is fully valid RFC 3339.
+    let day = digit(fixed, 8)? * 10 + digit(fixed, 9)?;
+    let date =
+        NaiveDate::from_ymd_opt(year as i32, month as u32, day as u32).ok_or(OUT_OF_RANGE)?;
+
+    if !matches!(bytes.get(10), Some(&b't' | &b'T' | &b' ')) {
+        return Err(INVALID);
+    }
+
+    let hour = digit(fixed, 11)? * 10 + digit(fixed, 12)?;
+    if bytes.get(13) != Some(&b':') {
+        return Err(INVALID);
+    }
+
+    let min = digit(fixed, 14)? * 10 + digit(fixed, 15)?;
+    if bytes.get(16) != Some(&b':') {
+        return Err(INVALID);
+    }
+
+    let sec = digit(fixed, 17)? * 10 + digit(fixed, 18)?;
+    let (sec, extra_nanos) = match sec {
+        60 => (59, 1_000_000_000), // rfc3339 allows leap seconds
+        _ => (sec, 0),
+    };
+
+    let nano = if bytes.get(19) == Some(&b'.') {
+        let nanosecond = try_consume!(scan::nanosecond(&s[20..]));
+        extra_nanos + nanosecond
+    } else {
+        s = &s[19..];
+        extra_nanos
+    };
+
+    let time = NaiveTime::from_hms_nano_opt(hour as u32, min as u32, sec as u32, nano)
+        .ok_or(OUT_OF_RANGE)?;
+
     // Max for the hours field is `23`, and for the minutes field `59`.
-    const MAX_RFC3339_OFFSET: i32 = (23 * 60 + 59) * 60;
-    if !(-MAX_RFC3339_OFFSET..=MAX_RFC3339_OFFSET).contains(&offset) {
-        return Err(OUT_OF_RANGE);
+    let offset = try_consume!(scan::timezone_offset(s, |s| scan::char(s, b':'), true, false, true));
+    if !s.is_empty() {
+        return Err(TOO_LONG);
     }
-    parsed.set_offset(i64::from(offset))?;
 
-    Ok((s, ()))
+    let tz = FixedOffset::east_opt(offset).ok_or(OUT_OF_RANGE)?;
+    Ok(match date.and_time(time).and_local_timezone(tz) {
+        MappedLocalTime::Single(dt) => dt,
+        // `FixedOffset::with_ymd_and_hms` doesn't return `MappedLocalTime::Ambiguous`
+        // and returns `MappedLocalTime::None` on invalid data
+        MappedLocalTime::Ambiguous(_, _) | MappedLocalTime::None => unreachable!(),
+    })
+}
+
+#[inline]
+fn digit(bytes: &[u8; 19], index: usize) -> ParseResult<u8> {
+    match bytes[index].is_ascii_digit() {
+        true => Ok(bytes[index] - b'0'),
+        false => Err(INVALID),
+    }
 }
 
 /// Tries to parse given string into `parsed` with given formatting items.
@@ -420,7 +461,7 @@ where
                     &Nanosecond => {
                         if s.starts_with('.') {
                             let nano = try_consume!(scan::nanosecond(&s[1..]));
-                            parsed.set_nanosecond(nano)?;
+                            parsed.set_nanosecond(nano as i64)?;
                         }
                     }
 
@@ -1830,29 +1871,34 @@ mod tests {
                 "2015-01-20T17:35:20.000000000452−08:00",
                 Ok(ymd_hmsn(2015, 1, 20, 17, 35, 20, 0, -8)),
             ), // too small with MINUS SIGN (U+2212)
+            ("2023-11-05T01:30:00-04:00", Ok(ymd_hmsn(2023, 11, 5, 1, 30, 0, 0, -4))), // ambiguous timestamp
             ("2015-01-20 17:35:20-08:00", Ok(ymd_hmsn(2015, 1, 20, 17, 35, 20, 0, -8))), // without 'T'
-            ("2015/01/20T17:35:20.001-08:00", Err(INVALID)), // wrong separator char YMD
-            ("2015-01-20T17-35-20.001-08:00", Err(INVALID)), // wrong separator char HMS
-            ("-01-20T17:35:20-08:00", Err(INVALID)),         // missing year
-            ("99-01-20T17:35:20-08:00", Err(INVALID)),       // bad year format
-            ("99999-01-20T17:35:20-08:00", Err(INVALID)),    // bad year value
-            ("-2000-01-20T17:35:20-08:00", Err(INVALID)),    // bad year value
+            ("2015-01-20_17:35:20-08:00", Err(INVALID)), // wrong date time separator
+            ("2015/01/20T17:35:20.001-08:00", Err(INVALID)), // wrong separator char YM
+            ("2015-01/20T17:35:20.001-08:00", Err(INVALID)), // wrong separator char MD
+            ("2015-01-20T17-35-20.001-08:00", Err(INVALID)), // wrong separator char HM
+            ("2015-01-20T17-35:20.001-08:00", Err(INVALID)), // wrong separator char MS
+            ("-01-20T17:35:20-08:00", Err(INVALID)),     // missing year
+            ("99-01-20T17:35:20-08:00", Err(INVALID)),   // bad year format
+            ("99999-01-20T17:35:20-08:00", Err(INVALID)), // bad year value
+            ("-2000-01-20T17:35:20-08:00", Err(INVALID)), // bad year value
+            ("2015-00-30T17:35:20-08:00", Err(OUT_OF_RANGE)), // bad month value
             ("2015-02-30T17:35:20-08:00", Err(OUT_OF_RANGE)), // bad day of month value
             ("2015-01-20T25:35:20-08:00", Err(OUT_OF_RANGE)), // bad hour value
             ("2015-01-20T17:65:20-08:00", Err(OUT_OF_RANGE)), // bad minute value
             ("2015-01-20T17:35:90-08:00", Err(OUT_OF_RANGE)), // bad second value
             ("2015-01-20T17:35:20-24:00", Err(OUT_OF_RANGE)), // bad offset value
-            ("15-01-20T17:35:20-08:00", Err(INVALID)),       // bad year format
-            ("15-01-20T17:35:20-08:00:00", Err(INVALID)),    // bad year format, bad offset format
-            ("2015-01-20T17:35:2008:00", Err(INVALID)),      // missing offset sign
-            ("2015-01-20T17:35:20 08:00", Err(INVALID)),     // missing offset sign
-            ("2015-01-20T17:35:20Zulu", Err(TOO_LONG)),      // bad offset format
-            ("2015-01-20T17:35:20 Zulu", Err(INVALID)),      // bad offset format
-            ("2015-01-20T17:35:20GMT", Err(INVALID)),        // bad offset format
-            ("2015-01-20T17:35:20 GMT", Err(INVALID)),       // bad offset format
-            ("2015-01-20T17:35:20+GMT", Err(INVALID)),       // bad offset format
-            ("2015-01-20T17:35:20++08:00", Err(INVALID)),    // bad offset format
-            ("2015-01-20T17:35:20--08:00", Err(INVALID)),    // bad offset format
+            ("15-01-20T17:35:20-08:00", Err(INVALID)),   // bad year format
+            ("15-01-20T17:35:20-08:00:00", Err(INVALID)), // bad year format, bad offset format
+            ("2015-01-20T17:35:2008:00", Err(INVALID)),  // missing offset sign
+            ("2015-01-20T17:35:20 08:00", Err(INVALID)), // missing offset sign
+            ("2015-01-20T17:35:20Zulu", Err(TOO_LONG)),  // bad offset format
+            ("2015-01-20T17:35:20 Zulu", Err(INVALID)),  // bad offset format
+            ("2015-01-20T17:35:20GMT", Err(INVALID)),    // bad offset format
+            ("2015-01-20T17:35:20 GMT", Err(INVALID)),   // bad offset format
+            ("2015-01-20T17:35:20+GMT", Err(INVALID)),   // bad offset format
+            ("2015-01-20T17:35:20++08:00", Err(INVALID)), // bad offset format
+            ("2015-01-20T17:35:20--08:00", Err(INVALID)), // bad offset format
             ("2015-01-20T17:35:20−−08:00", Err(INVALID)), // bad offset format with MINUS SIGN (U+2212)
             ("2015-01-20T17:35:20±08:00", Err(INVALID)),  // bad offset sign
             ("2015-01-20T17:35:20-08-00", Err(INVALID)),  // bad offset separator
diff --git a/src/format/scan.rs b/src/format/scan.rs
@@ -47,14 +47,15 @@ pub(super) fn number(s: &str, min: usize, max: usize) -> ParseResult<(&str, i64)
 
 /// Tries to consume at least one digits as a fractional second.
 /// Returns the number of whole nanoseconds (0--999,999,999).
-pub(super) fn nanosecond(s: &str) -> ParseResult<(&str, i64)> {
+pub(super) fn nanosecond(s: &str) -> ParseResult<(&str, u32)> {
     // record the number of digits consumed for later scaling.
     let origlen = s.len();
     let (s, v) = number(s, 1, 9)?;
+    let v = u32::try_from(v).expect("999,999,999 should fit u32");
     let consumed = origlen - s.len();
 
     // scale the number accordingly.
-    static SCALE: [i64; 10] =
+    const SCALE: [u32; 10] =
         [0, 100_000_000, 10_000_000, 1_000_000, 100_000, 10_000, 1_000, 100, 10, 1];
     let v = v.checked_mul(SCALE[consumed]).ok_or(OUT_OF_RANGE)?;
 
