Improve parser errors for one of multiple ascii characters

Author: ictrobot

crates/utils/src/ascii.rs

@@ -0,0 +1,99 @@
+//! ASCII helpers.
+
+use crate::bit::BitIterator;
+use std::fmt::{Debug, Display, Formatter};
+
+/// A set of ASCII characters.
+///
+/// # Examples
+/// ```
+/// # use utils::ascii::AsciiSet;
+/// let set1 = AsciiSet::new((1 << b'A') | (1 << b'B') | (1 << b'C'));
+/// assert_eq!(set1.len(), 3);
+/// assert_eq!(set1.to_string(), "'A', 'B', 'C'");
+/// assert_eq!(format!("{set1:?}"), "{'A', 'B', 'C'}");
+///
+/// let mut array = [false; 128];
+/// array[b'A' as usize] = true;
+/// array[b'B' as usize] = true;
+/// array[b'C' as usize] = true;
+/// assert_eq!(AsciiSet::from(array), set1);
+///
+/// assert_eq!(AsciiSet::from(|b| (b'A'..=b'C').contains(&b)), set1);
+/// ```
+#[derive(Copy, Clone, Eq, PartialEq, Default)]
+#[repr(transparent)]
+#[must_use]
+pub struct AsciiSet {
+    set: u128,
+}
+
+impl AsciiSet {
+    /// Creates a new `AsciiSet` from the specified bitset.
+    pub const fn new(set: u128) -> Self {
+        Self { set }
+    }
+
+    #[must_use]
+    pub const fn is_empty(&self) -> bool {
+        self.set == 0
+    }
+
+    #[must_use]
+    pub const fn len(&self) -> usize {
+        self.set.count_ones() as usize
+    }
+}
+
+impl Display for AsciiSet {
+    #[expect(clippy::cast_possible_truncation)]
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        if self.set == 0 {
+            return write!(f, "(empty)");
+        }
+
+        for (i, (c, _)) in BitIterator::ones(self.set).enumerate() {
+            let c = c as u8 as char;
+            if i == 0 {
+                write!(f, "{c:?}")?;
+            } else {
+                write!(f, ", {c:?}")?;
+            }
+        }
+        Ok(())
+    }
+}
+
+impl Debug for AsciiSet {
+    #[expect(clippy::cast_possible_truncation)]
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        f.debug_set()
+            .entries(BitIterator::ones(self.set).map(|(c, _)| c as u8 as char))
+            .finish()
+    }
+}
+
+impl From<u128> for AsciiSet {
+    fn from(set: u128) -> Self {
+        Self { set }
+    }
+}
+
+impl From<[bool; 128]> for AsciiSet {
+    fn from(value: [bool; 128]) -> Self {
+        Self {
+            set: value
+                .iter()
+                .enumerate()
+                .fold(0, |s, (i, &b)| s | u128::from(b) << i),
+        }
+    }
+}
+
+impl<F: Fn(u8) -> bool> From<F> for AsciiSet {
+    fn from(value: F) -> Self {
+        Self {
+            set: (0u8..=127).fold(0, |s, i| s | u128::from(value(i)) << i),
+        }
+    }
+}

crates/utils/src/lib.rs

@@ -2,6 +2,7 @@
 #![cfg_attr(not(feature = "unsafe"), forbid(unsafe_code))]
 
 pub mod array;
+pub mod ascii;
 pub mod bit;
 pub mod date;
 mod framework;

crates/utils/src/parser/error.rs

@@ -1,3 +1,4 @@
+use crate::ascii::AsciiSet;
 use crate::parser::then::Then2;
 use crate::parser::{ParseResult, Parser};
 use std::error::Error;
@@ -15,6 +16,8 @@ pub enum ParseError {
     ExpectedByte(u8),
     /// Expected $min - $max.
     ExpectedByteRange(u8, u8),
+    /// Expected one of $set.
+    ExpectedOneOf(AsciiSet),
     /// Expected at least $n matches.
     ExpectedMatches(usize),
     /// Expected $n items or less.
@@ -68,6 +71,7 @@ impl Display for ParseError {
                     max.escape_ascii().to_string(),
                 )
             }
+            ParseError::ExpectedOneOf(set) => write!(f, "expected one of {set}"),
             ParseError::ExpectedEof() => write!(f, "expected end of input"),
             ParseError::ExpectedMatches(x) => write!(f, "expected at least {x} match"),
             ParseError::ExpectedLessItems(x) => write!(f, "expected {x} items or less"),

crates/utils/src/parser/macros.rs

@@ -24,37 +24,6 @@ macro_rules! parser_byte_map {
     (
         $($($l:literal)|+ => $e:expr),+$(,)?
     ) => {{
-        // `let _: u8 = $l` ensures $l is used in the repetition and also ensures all the literals
-        // are byte literals
-        const COUNT: usize = 0usize $($(+ {let _: u8 = $l; 1usize})+)+;
-        const LEN: usize = 14 + 5 * COUNT;
-        const {
-            assert!(COUNT >= 2, "at least two literals must be provided");
-        }
-
-        // Once concat_bytes! is stabilized this error message can be created in the macro similar
-        // to parser_literal_map!
-        const ERROR: [u8; LEN] = {
-            let mut result = [0u8; LEN];
-            let (prefix, vals) = result.split_at_mut(16);
-            prefix.copy_from_slice(b"expected one of ");
-
-            let mut i = 0;
-            let literals = [$($($l),+),+];
-            while i < COUNT {
-                vals[i * 5] = b'\'';
-                vals[i * 5 + 1] = literals[i];
-                vals[i * 5 + 2] = b'\'';
-                if i + 1 < COUNT {
-                    vals[i * 5 + 3] = b',';
-                    vals[i * 5 + 4] = b' ';
-                }
-                i += 1;
-            }
-
-            result
-        };
-
         $crate::parser::byte_lut(&const {
             // Don't use a const item for the lut to avoid naming the value type
             let mut lut = [None; 256];
@@ -63,11 +32,14 @@ macro_rules! parser_byte_map {
                 lut[$l as usize] = Some($e);
             )+)+
             lut
-        }, const {
-            match str::from_utf8(&ERROR) {
-                Ok(v) => v,
-                Err(_) => panic!("one or more of the provided literals is invalid unicode"),
-            }
+        }, {
+            let mut set = 0u128;
+            $($(
+                let v: u8 = $l;
+                assert!(v < 128, "invalid ASCII");
+                set |= 1u128 << v;
+            )+)+
+            $crate::parser::ParseError::ExpectedOneOf($crate::ascii::AsciiSet::new(set))
         })
     }};
 }

crates/utils/src/parser/simple.rs

@@ -42,7 +42,7 @@ pub fn byte() -> Byte {
 #[derive(Copy, Clone)]
 pub struct ByteLut<'a, O> {
     lut: &'a [Option<O>; 256],
-    error: &'static str,
+    error: ParseError,
 }
 impl<'i, O: Copy> Parser<'i> for ByteLut<'_, O> {
     type Output = O;
@@ -55,7 +55,7 @@ impl<'i, O: Copy> Parser<'i> for ByteLut<'_, O> {
         {
             Ok((output, remaining))
         } else {
-            Err((ParseError::Custom(self.error), input))
+            Err((self.error, input))
         }
     }
 }
@@ -78,14 +78,14 @@ impl<'i, O: Copy> Parser<'i> for ByteLut<'_, O> {
 ///     x
 /// };
 ///
-/// let parser = parser::byte_lut(&LOOKUP, "expected '#' or '.'");
+/// let parser = parser::byte_lut(&LOOKUP, ParseError::Custom("expected '#' or '.'"));
 /// assert_eq!(parser.parse(b"#..##"), Ok((true, &b"..##"[..])));
 /// assert_eq!(parser.parse(b"..##"), Ok((false, &b".##"[..])));
 /// assert_eq!(parser.parse(b"abc"), Err((ParseError::Custom("expected '#' or '.'"), &b"abc"[..])));
 /// ```
 #[inline]
 #[must_use]
-pub fn byte_lut<'a, T: Copy>(lut: &'a [Option<T>; 256], error: &'static str) -> ByteLut<'a, T> {
+pub fn byte_lut<T: Copy>(lut: &'_ [Option<T>; 256], error: ParseError) -> ByteLut<'_, T> {
     ByteLut { lut, error }
 }