Optimize Rfc2822 parsing

jhpratt · jhpratt · commit 6cb1896a600b · 2026-01-31T05:08:50.000-05:00
diff --git a/time/src/parsing/combinator/mod.rs b/time/src/parsing/combinator/mod.rs
@@ -27,34 +27,6 @@ pub(crate) const fn sign(input: &[u8]) -> Option<ParsedItem<'_, Sign>> {
     }
 }
 
-/// Consume the first matching item, returning its associated value.
-#[inline]
-pub(crate) fn first_match<'a, T, I>(
-    options: I,
-    case_sensitive: bool,
-) -> impl for<'b> FnMut(&'b [u8]) -> Option<ParsedItem<'b, T>>
-where
-    I: IntoIterator<Item = (&'a [u8], T)>,
-{
-    let mut options = options.into_iter();
-    move |input| {
-        if case_sensitive {
-            options.find_map(|(expected, t)| Some(ParsedItem(input.strip_prefix(expected)?, t)))
-        } else {
-            options.find_map(|(expected, t)| {
-                let n = expected.len();
-                if n <= input.len() {
-                    let (head, tail) = input.split_at(n);
-                    if head.eq_ignore_ascii_case(expected) {
-                        return Some(ParsedItem(tail, t));
-                    }
-                }
-                None
-            })
-        }
-    }
-}
-
 /// Consume zero or more instances of the provided parser. The parser must return the unit value.
 #[inline]
 pub(crate) fn zero_or_more<P>(parser: P) -> impl for<'a> FnMut(&'a [u8]) -> ParsedItem<'a, ()>
diff --git a/time/src/parsing/combinator/rfc/rfc2822.rs b/time/src/parsing/combinator/rfc/rfc2822.rs
@@ -2,6 +2,8 @@
 //!
 //! [RFC 2822]: https://datatracker.ietf.org/doc/html/rfc2822
 
+use num_conv::prelude::*;
+
 use crate::parsing::ParsedItem;
 use crate::parsing::combinator::rfc::rfc2234::wsp;
 use crate::parsing::combinator::{ascii_char, one_or_more, zero_or_more};
@@ -117,3 +119,70 @@ fn text<'a>(input: &'a [u8]) -> ParsedItem<'a, ()> {
 
     new_text(input).unwrap_or_else(|| obs_text(input))
 }
+
+/// Consume an old zone literal, returning the offset in hours.
+#[inline]
+pub(crate) fn zone_literal(input: &[u8]) -> Option<ParsedItem<'_, i8>> {
+    let [first, second, third, rest @ ..] = input else {
+        const UT_VARIANTS: [u16; 4] = [
+            u16::from_ne_bytes([b'u', b't']),
+            u16::from_ne_bytes([b'u', b'T']),
+            u16::from_ne_bytes([b'U', b't']),
+            u16::from_ne_bytes([b'U', b'T']),
+        ];
+
+        let [first, rest @ ..] = input else {
+            return None;
+        };
+        if let [second, rest @ ..] = rest
+            && UT_VARIANTS.contains(&u16::from_ne_bytes([*first, *second]))
+        {
+            return Some(ParsedItem(rest, 0));
+        }
+        return (*first != b'j' && *first != b'J' && first.is_ascii_alphabetic())
+            .then_some(ParsedItem(rest, 0));
+    };
+    let byte = u32::from_ne_bytes([
+        0,
+        first.to_ascii_lowercase(),
+        second.to_ascii_lowercase(),
+        third.to_ascii_lowercase(),
+    ]);
+    const ZONES: [u32; 8] = [
+        u32::from_ne_bytes([0, b'e', b's', b't']),
+        u32::from_ne_bytes([0, b'e', b'd', b't']),
+        u32::from_ne_bytes([0, b'c', b's', b't']),
+        u32::from_ne_bytes([0, b'c', b'd', b't']),
+        u32::from_ne_bytes([0, b'm', b's', b't']),
+        u32::from_ne_bytes([0, b'm', b'd', b't']),
+        u32::from_ne_bytes([0, b'p', b's', b't']),
+        u32::from_ne_bytes([0, b'p', b'd', b't']),
+    ];
+
+    let eq = [
+        if ZONES[0] == byte { i32::MAX } else { 0 },
+        if ZONES[1] == byte { i32::MAX } else { 0 },
+        if ZONES[2] == byte { i32::MAX } else { 0 },
+        if ZONES[3] == byte { i32::MAX } else { 0 },
+        if ZONES[4] == byte { i32::MAX } else { 0 },
+        if ZONES[5] == byte { i32::MAX } else { 0 },
+        if ZONES[6] == byte { i32::MAX } else { 0 },
+        if ZONES[7] == byte { i32::MAX } else { 0 },
+    ];
+    if eq == [0; 8] && byte != const { u32::from_ne_bytes([0, b'g', b'm', b't']) } {
+        return None;
+    }
+
+    let nonzero_zones = [
+        eq[0] & -5,
+        eq[1] & -4,
+        eq[2] & -6,
+        eq[3] & -5,
+        eq[4] & -7,
+        eq[5] & -6,
+        eq[6] & -8,
+        eq[7] & -7,
+    ];
+    let zone = nonzero_zones.iter().sum::<i32>().truncate();
+    Some(ParsedItem(rest, zone))
+}
diff --git a/time/src/parsing/mod.rs b/time/src/parsing/mod.rs
@@ -35,6 +35,13 @@ impl<'a, T> ParsedItem<'a, T> {
         Some(self.0)
     }
 
+    /// Discard the stored value, returning the remaining input.
+    #[must_use = "this returns the remaining input"]
+    #[inline]
+    pub(crate) fn discard_value(self) -> &'a [u8] {
+        self.0
+    }
+
     /// Filter the value with the provided function. If the function returns `false`, the value
     /// is discarded and `None` is returned. Otherwise, the value is preserved and `Some(self)` is
     /// returned.
diff --git a/time/src/parsing/parsable.rs b/time/src/parsing/parsable.rs
@@ -14,7 +14,7 @@ use crate::format_description::well_known::{Iso8601, Rfc2822, Rfc3339};
 use crate::internal_macros::bug;
 use crate::parsing::combinator::{Sign, one_or_two_digits};
 use crate::parsing::{Parsed, ParsedItem};
-use crate::{Date, Month, OffsetDateTime, Time, UtcOffset, Weekday, error};
+use crate::{Date, Month, OffsetDateTime, Time, UtcOffset, error};
 
 /// A type that can be parsed.
 #[cfg_attr(docsrs, doc(notable_trait))]
@@ -172,25 +172,23 @@ impl sealed::Sealed for Rfc2822 {
         parsed: &mut Parsed,
     ) -> Result<&'a [u8], error::Parse> {
         use crate::error::ParseFromDescription::{InvalidComponent, InvalidLiteral};
-        use crate::parsing::combinator::rfc::rfc2822::{cfws, fws};
-        use crate::parsing::combinator::{ExactlyNDigits, ascii_char, first_match, opt, sign};
+        use crate::format_description::modifier;
+        use crate::parsing::combinator::rfc::rfc2822::{cfws, fws, zone_literal};
+        use crate::parsing::combinator::{ExactlyNDigits, ascii_char, opt, sign};
+        use crate::parsing::component;
 
         let colon = ascii_char::<b':'>;
         let comma = ascii_char::<b','>;
 
         let input = opt(cfws)(input).into_inner();
-        let weekday = first_match(
-            [
-                (b"Mon".as_slice(), Weekday::Monday),
-                (b"Tue".as_slice(), Weekday::Tuesday),
-                (b"Wed".as_slice(), Weekday::Wednesday),
-                (b"Thu".as_slice(), Weekday::Thursday),
-                (b"Fri".as_slice(), Weekday::Friday),
-                (b"Sat".as_slice(), Weekday::Saturday),
-                (b"Sun".as_slice(), Weekday::Sunday),
-            ],
-            false,
-        )(input);
+        let weekday = component::parse_weekday(
+            input,
+            modifier::Weekday {
+                repr: modifier::WeekdayRepr::Short,
+                one_indexed: false,
+                case_sensitive: false,
+            },
+        );
         let input = if let Some(item) = weekday {
             let input = item
                 .consume_value(|value| parsed.set_weekday(value))
@@ -204,23 +202,14 @@ impl sealed::Sealed for Rfc2822 {
             .and_then(|item| item.consume_value(|value| parsed.set_day(NonZero::new(value)?)))
             .ok_or(InvalidComponent("day"))?;
         let input = cfws(input).ok_or(InvalidLiteral)?.into_inner();
-        let input = first_match(
-            [
-                (b"Jan".as_slice(), Month::January),
-                (b"Feb".as_slice(), Month::February),
-                (b"Mar".as_slice(), Month::March),
-                (b"Apr".as_slice(), Month::April),
-                (b"May".as_slice(), Month::May),
-                (b"Jun".as_slice(), Month::June),
-                (b"Jul".as_slice(), Month::July),
-                (b"Aug".as_slice(), Month::August),
-                (b"Sep".as_slice(), Month::September),
-                (b"Oct".as_slice(), Month::October),
-                (b"Nov".as_slice(), Month::November),
-                (b"Dec".as_slice(), Month::December),
-            ],
-            false,
-        )(input)
+        let input = component::parse_month(
+            input,
+            modifier::Month {
+                padding: modifier::Padding::None,
+                repr: modifier::MonthRepr::Short,
+                case_sensitive: false,
+            },
+        )
         .and_then(|item| item.consume_value(|value| parsed.set_month(value)))
         .ok_or(InvalidComponent("month"))?;
         let input = cfws(input).ok_or(InvalidLiteral)?.into_inner();
@@ -271,33 +260,7 @@ impl sealed::Sealed for Rfc2822 {
         // The RFC explicitly allows leap seconds.
         parsed.leap_second_allowed = true;
 
-        #[expect(
-            clippy::unnecessary_lazy_evaluations,
-            reason = "rust-lang/rust-clippy#8522"
-        )]
-        let zone_literal = first_match(
-            [
-                (b"UT".as_slice(), 0),
-                (b"GMT".as_slice(), 0),
-                (b"EST".as_slice(), -5),
-                (b"EDT".as_slice(), -4),
-                (b"CST".as_slice(), -6),
-                (b"CDT".as_slice(), -5),
-                (b"MST".as_slice(), -7),
-                (b"MDT".as_slice(), -6),
-                (b"PST".as_slice(), -8),
-                (b"PDT".as_slice(), -7),
-            ],
-            false,
-        )(input)
-        .or_else(|| match input {
-            [
-                b'a'..=b'i' | b'k'..=b'z' | b'A'..=b'I' | b'K'..=b'Z',
-                rest @ ..,
-            ] => Some(ParsedItem(rest, 0)),
-            _ => None,
-        });
-        if let Some(zone_literal) = zone_literal {
+        if let Some(zone_literal) = zone_literal(input) {
             let input = zone_literal
                 .consume_value(|value| parsed.set_offset_hour(value))
                 .ok_or(InvalidComponent("offset hour"))?;
@@ -333,53 +296,40 @@ impl sealed::Sealed for Rfc2822 {
 
     fn parse_offset_date_time(&self, input: &[u8]) -> Result<OffsetDateTime, error::Parse> {
         use crate::error::ParseFromDescription::{InvalidComponent, InvalidLiteral};
-        use crate::parsing::combinator::rfc::rfc2822::{cfws, fws};
-        use crate::parsing::combinator::{ExactlyNDigits, ascii_char, first_match, opt, sign};
+        use crate::format_description::modifier;
+        use crate::parsing::combinator::rfc::rfc2822::{cfws, fws, zone_literal};
+        use crate::parsing::combinator::{ExactlyNDigits, ascii_char, opt, sign};
+        use crate::parsing::component;
 
         let colon = ascii_char::<b':'>;
         let comma = ascii_char::<b','>;
 
         let input = opt(cfws)(input).into_inner();
-        // This parses the weekday, but we don't actually use the value anywhere. Because of this,
-        // just return `()` to avoid unnecessary generated code.
-        let weekday = first_match(
-            [
-                (b"Mon".as_slice(), ()),
-                (b"Tue".as_slice(), ()),
-                (b"Wed".as_slice(), ()),
-                (b"Thu".as_slice(), ()),
-                (b"Fri".as_slice(), ()),
-                (b"Sat".as_slice(), ()),
-                (b"Sun".as_slice(), ()),
-            ],
-            false,
-        )(input);
+        let weekday = component::parse_weekday(
+            input,
+            modifier::Weekday {
+                repr: modifier::WeekdayRepr::Short,
+                one_indexed: false,
+                case_sensitive: false,
+            },
+        );
         let input = if let Some(item) = weekday {
-            let input = item.into_inner();
+            let input = item.discard_value();
             let input = comma(input).ok_or(InvalidLiteral)?.into_inner();
             opt(cfws)(input).into_inner()
         } else {
             input
         };
         let ParsedItem(input, day) = one_or_two_digits(input).ok_or(InvalidComponent("day"))?;
         let input = cfws(input).ok_or(InvalidLiteral)?.into_inner();
-        let ParsedItem(input, month) = first_match(
-            [
-                (b"Jan".as_slice(), Month::January),
-                (b"Feb".as_slice(), Month::February),
-                (b"Mar".as_slice(), Month::March),
-                (b"Apr".as_slice(), Month::April),
-                (b"May".as_slice(), Month::May),
-                (b"Jun".as_slice(), Month::June),
-                (b"Jul".as_slice(), Month::July),
-                (b"Aug".as_slice(), Month::August),
-                (b"Sep".as_slice(), Month::September),
-                (b"Oct".as_slice(), Month::October),
-                (b"Nov".as_slice(), Month::November),
-                (b"Dec".as_slice(), Month::December),
-            ],
-            false,
-        )(input)
+        let ParsedItem(input, month) = component::parse_month(
+            input,
+            modifier::Month {
+                padding: modifier::Padding::None,
+                repr: modifier::MonthRepr::Short,
+                case_sensitive: false,
+            },
+        )
         .ok_or(InvalidComponent("month"))?;
         let input = cfws(input).ok_or(InvalidLiteral)?.into_inner();
         let (input, year) = match ExactlyNDigits::<4>::parse(input) {
@@ -421,34 +371,7 @@ impl sealed::Sealed for Rfc2822 {
             (cfws(input).ok_or(InvalidLiteral)?.into_inner(), 0)
         };
 
-        #[expect(
-            clippy::unnecessary_lazy_evaluations,
-            reason = "rust-lang/rust-clippy#8522"
-        )]
-        let zone_literal = first_match(
-            [
-                (b"UT".as_slice(), 0),
-                (b"GMT".as_slice(), 0),
-                (b"EST".as_slice(), -5),
-                (b"EDT".as_slice(), -4),
-                (b"CST".as_slice(), -6),
-                (b"CDT".as_slice(), -5),
-                (b"MST".as_slice(), -7),
-                (b"MDT".as_slice(), -6),
-                (b"PST".as_slice(), -8),
-                (b"PDT".as_slice(), -7),
-            ],
-            false,
-        )(input)
-        .or_else(|| match input {
-            [
-                b'a'..=b'i' | b'k'..=b'z' | b'A'..=b'I' | b'K'..=b'Z',
-                rest @ ..,
-            ] => Some(ParsedItem(rest, 0)),
-            _ => None,
-        });
-
-        let (input, offset_hour, offset_minute) = if let Some(zone_literal) = zone_literal {
+        let (input, offset_hour, offset_minute) = if let Some(zone_literal) = zone_literal(input) {
             let ParsedItem(input, offset_hour) = zone_literal;
             (input, offset_hour, 0)
         } else {
