Merge pull request #285 from zesterer/perf

zesterer · web-flow · commit 7aa32b7fa904 · 2023-02-16T21:51:48.000Z
Reduced use of Marker for more performance wins
diff --git a/benches/json.rs b/benches/json.rs
@@ -100,8 +100,7 @@ mod chumsky_zero_copy {
 
             let frac = just(b'.').then(digits.clone());
 
-            let exp = just(b'e')
-                .or(just(b'E'))
+            let exp = one_of(b"eE")
                 .then(one_of(b"+-").or_not())
                 .then(digits.clone());
 
@@ -124,8 +123,7 @@ mod chumsky_zero_copy {
                     just(b'r').to(b'\r'),
                     just(b't').to(b'\t'),
                 )))
-                .ignored()
-                .boxed();
+                .ignored();
 
             let string = none_of(b"\\\"")
                 .ignored()
diff --git a/benches/lex.rs b/benches/lex.rs
@@ -63,8 +63,7 @@ fn bench_lex(c: &mut Criterion) {
 
     c.bench_function("lex_logos", |b| {
         b.iter(|| {
-            assert!(black_box(logos::lexer(black_box(SAMPLE)))
-                .all(|t| t != logos::Token::Error))
+            assert!(black_box(logos::lexer(black_box(SAMPLE))).all(|t| t != logos::Token::Error))
         })
     });
 }
@@ -88,8 +87,7 @@ mod logos {
         str::from_utf8(lex.slice()).unwrap().parse().unwrap()
     }
 
-    #[derive(Logos)]
-    #[derive(Debug, Clone, PartialEq)]
+    #[derive(Logos, Debug, Clone, PartialEq)]
     pub enum Token<'a> {
         #[token("null")]
         Null,
diff --git a/src/zero_copy/combinator.rs b/src/zero_copy/combinator.rs
@@ -241,7 +241,7 @@ where
             } else {
                 let span = inp.span_since(before);
                 Err(Located::at(
-                    inp.save(),
+                    inp.offset().into(),
                     E::Error::expected_found(None, None, span),
                 ))
             }
@@ -397,7 +397,7 @@ where
             let span = inp.span_since(before);
             match (self.mapper)(out, span) {
                 Ok(out) => Ok(M::bind(|| out)),
-                Err(e) => Err(Located::at(inp.save(), e)),
+                Err(e) => Err(Located::at(inp.offset().into(), e)),
             }
         })
     }
@@ -438,7 +438,7 @@ where
             let state = inp.state();
             match (self.mapper)(out, span, state) {
                 Ok(out) => Ok(M::bind(|| out)),
-                Err(e) => Err(Located::at(inp.save(), e)),
+                Err(e) => Err(Located::at(inp.offset().into(), e)),
             }
         })
     }
@@ -875,7 +875,8 @@ impl RepeatedCfg {
 pub struct Repeated<A, OA, I: ?Sized, E> {
     pub(crate) parser: A,
     pub(crate) at_least: usize,
-    pub(crate) at_most: Option<usize>,
+    // Slightly evil: Should be `Option<usize>`, but we encode `!0` as 'no cap' because it's so large
+    pub(crate) at_most: u64,
     pub(crate) phantom: PhantomData<(OA, E, I)>,
 }
 
@@ -905,7 +906,7 @@ where
     /// Require that the pattern appear at most a maximum number of times.
     pub fn at_most(self, at_most: usize) -> Self {
         Self {
-            at_most: Some(at_most),
+            at_most: at_most as u64,
             ..self
         }
     }
@@ -954,7 +955,7 @@ where
     pub fn exactly(self, exactly: usize) -> Self {
         Self {
             at_least: exactly,
-            at_most: Some(exactly),
+            at_most: exactly as u64,
             ..self
         }
     }
@@ -1000,10 +1001,8 @@ where
         inp: &mut InputRef<'a, '_, I, E>,
         count: &mut Self::IterState<M>,
     ) -> Option<PResult<M, O, E::Error>> {
-        if let Some(at_most) = self.at_most {
-            if *count >= at_most {
-                return None;
-            }
+        if *count as u64 >= self.at_most {
+            return None;
         }
 
         let before = inp.save();
@@ -1038,13 +1037,11 @@ where
         count: &mut Self::IterState<M>,
         cfg: &Self::Config,
     ) -> Option<PResult<M, O, E::Error>> {
-        let at_most = cfg.at_most.or(self.at_most);
+        let at_most = cfg.at_most.map(|x| x as u64).unwrap_or(self.at_most);
         let at_least = cfg.at_least.unwrap_or(self.at_least);
 
-        if let Some(at_most) = at_most {
-            if *count >= at_most {
-                return None;
-            }
+        if *count as u64 >= at_most {
+            return None;
         }
 
         let before = inp.save();
@@ -1070,7 +1067,8 @@ pub struct SeparatedBy<A, B, OA, OB, I: ?Sized, E> {
     pub(crate) parser: A,
     pub(crate) separator: B,
     pub(crate) at_least: usize,
-    pub(crate) at_most: Option<usize>,
+    // Slightly evil: Should be `Option<usize>`, but we encode `!0` as 'no cap' because it's so large
+    pub(crate) at_most: u64,
     pub(crate) allow_leading: bool,
     pub(crate) allow_trailing: bool,
     pub(crate) phantom: PhantomData<(OA, OB, E, I)>,
@@ -1142,7 +1140,7 @@ where
     /// ````
     pub fn at_most(self, at_most: usize) -> Self {
         Self {
-            at_most: Some(at_most),
+            at_most: at_most as u64,
             ..self
         }
     }
@@ -1169,7 +1167,7 @@ where
     pub fn exactly(self, exactly: usize) -> Self {
         Self {
             at_least: exactly,
-            at_most: Some(exactly),
+            at_most: exactly as u64,
             ..self
         }
     }
@@ -1253,7 +1251,7 @@ where
         inp: &mut InputRef<'a, '_, I, E>,
         state: &mut Self::IterState<M>,
     ) -> Option<PResult<M, OA, E::Error>> {
-        if self.at_most.map_or(false, |max| *state >= max) {
+        if *state as u64 >= self.at_most {
             return None;
         }
 
@@ -1433,7 +1431,7 @@ where
             Ok(_) => {
                 let (at, tok) = inp.next();
                 Err(Located::at(
-                    at,
+                    at.into(),
                     E::Error::expected_found(None, tok, inp.span_since(before.offset)),
                 ))
             }
diff --git a/src/zero_copy/input.rs b/src/zero_copy/input.rs
@@ -179,11 +179,11 @@ impl<I: Input + ?Sized> Clone for Marker<I> {
 /// Internal type representing an input as well as all the necessary context for parsing.
 pub struct InputRef<'a, 'parse, I: Input + ?Sized, E: ParserExtra<'a, I>> {
     input: &'a I,
-    marker: Marker<I>,
+    offset: I::Offset,
+    errors: Vec<E::Error>,
     // TODO: Don't use a result, use something like `Cow` but that allows `E::State` to not be `Clone`
     state: Result<&'parse mut E::State, E::State>,
     ctx: E::Context,
-    errors: Vec<E::Error>,
 }
 
 impl<'a, 'parse, I: Input + ?Sized, E: ParserExtra<'a, I>> InputRef<'a, 'parse, I, E> {
@@ -193,10 +193,7 @@ impl<'a, 'parse, I: Input + ?Sized, E: ParserExtra<'a, I>> InputRef<'a, 'parse,
     {
         Self {
             input,
-            marker: Marker {
-                offset: input.start(),
-                err_count: 0,
-            },
+            offset: input.start(),
             state,
             ctx: E::Context::default(),
             errors: Vec::new(),
@@ -216,7 +213,7 @@ impl<'a, 'parse, I: Input + ?Sized, E: ParserExtra<'a, I>> InputRef<'a, 'parse,
 
         let mut new_ctx = InputRef {
             input: self.input,
-            marker: self.marker,
+            offset: self.offset,
             state: match &mut self.state {
                 Ok(state) => Ok(*state),
                 Err(state) => Ok(state),
@@ -225,28 +222,31 @@ impl<'a, 'parse, I: Input + ?Sized, E: ParserExtra<'a, I>> InputRef<'a, 'parse,
             errors: mem::take(&mut self.errors),
         };
         let res = f(&mut new_ctx);
-        self.marker = new_ctx.marker;
+        self.offset = new_ctx.offset;
         self.errors = mem::take(&mut new_ctx.errors);
         res
     }
 
     /// Get the input offset that is currently being pointed to.
     #[inline(always)]
     pub fn offset(&self) -> I::Offset {
-        self.marker.offset
+        self.offset
     }
 
     /// Save off a [`Marker`] to the current position in the input
     #[inline(always)]
     pub fn save(&self) -> Marker<I> {
-        self.marker
+        Marker {
+            offset: self.offset,
+            err_count: self.errors.len(),
+        }
     }
 
     /// Reset the input state to the provided [`Marker`]
     #[inline(always)]
     pub fn rewind(&mut self, marker: Marker<I>) {
         self.errors.truncate(marker.err_count);
-        self.marker = marker;
+        self.offset = marker.offset;
     }
 
     #[inline(always)]
@@ -264,11 +264,11 @@ impl<'a, 'parse, I: Input + ?Sized, E: ParserExtra<'a, I>> InputRef<'a, 'parse,
 
     #[inline(always)]
     pub(crate) fn skip_while<F: FnMut(&I::Token) -> bool>(&mut self, mut f: F) {
-        let mut offs = self.marker.offset;
+        let mut offs = self.offset;
         loop {
             let (offset, token) = self.input.next(offs);
             if token.filter(&mut f).is_none() {
-                self.marker.offset = offs;
+                self.offset = offs;
                 break;
             } else {
                 offs = offset;
@@ -277,10 +277,10 @@ impl<'a, 'parse, I: Input + ?Sized, E: ParserExtra<'a, I>> InputRef<'a, 'parse,
     }
 
     #[inline(always)]
-    pub(crate) fn next(&mut self) -> (Marker<I>, Option<I::Token>) {
-        let (offset, token) = self.input.next(self.marker.offset);
-        self.marker.offset = offset;
-        (self.marker, token)
+    pub(crate) fn next(&mut self) -> (I::Offset, Option<I::Token>) {
+        let (offset, token) = self.input.next(self.offset);
+        self.offset = offset;
+        (self.offset, token)
     }
 
     /// Get the next token in the input. Returns `None` for EOI
@@ -290,7 +290,7 @@ impl<'a, 'parse, I: Input + ?Sized, E: ParserExtra<'a, I>> InputRef<'a, 'parse,
 
     /// Peek the next token in the input. Returns `None` for EOI
     pub fn peek(&self) -> Option<I::Token> {
-        self.input.next(self.marker.offset).1
+        self.input.next(self.offset).1
     }
 
     /// Skip the next token in the input.
@@ -320,13 +320,13 @@ impl<'a, 'parse, I: Input + ?Sized, E: ParserExtra<'a, I>> InputRef<'a, 'parse,
     where
         I: SliceInput,
     {
-        self.input.slice_from(self.marker.offset..)
+        self.input.slice_from(self.offset..)
     }
 
     /// Return the span from the provided [`Marker`] to the current position
     #[inline(always)]
     pub fn span_since(&self, before: I::Offset) -> I::Span {
-        self.input.span(before..self.marker.offset)
+        self.input.span(before..self.offset)
     }
 
     #[inline(always)]
@@ -335,13 +335,12 @@ impl<'a, 'parse, I: Input + ?Sized, E: ParserExtra<'a, I>> InputRef<'a, 'parse,
         C: Char,
         I: StrInput<C>,
     {
-        self.marker.offset += skip;
+        self.offset += skip;
     }
 
     #[inline(always)]
     pub(crate) fn emit(&mut self, error: E::Error) {
         self.errors.push(error);
-        self.marker.err_count += 1;
     }
 
     pub(crate) fn into_errs(self) -> Vec<E::Error> {
diff --git a/src/zero_copy/mod.rs b/src/zero_copy/mod.rs
@@ -59,7 +59,9 @@ pub mod prelude {
     pub use super::{
         error::{EmptyErr, Error as _, Rich, Simple},
         extra,
-        primitive::{any, choice, empty, end, group, just, none_of, one_of, take_until, todo, map_ctx},
+        primitive::{
+            any, choice, empty, end, group, just, map_ctx, none_of, one_of, take_until, todo,
+        },
         recovery::{nested_delimiters, skip_until},
         recursive::{recursive, Recursive},
         // select,
@@ -98,7 +100,7 @@ use self::{
     container::*,
     error::Error,
     extra::ParserExtra,
-    input::{Input, InputRef, Marker, SliceInput, StrInput},
+    input::{Input, InputRef, SliceInput, StrInput},
     prelude::*,
     recovery::RecoverWith,
     span::Span,
@@ -200,11 +202,8 @@ pub struct Located<E> {
 }
 
 impl<E> Located<E> {
-    pub fn at<I: Input + ?Sized>(mark: Marker<I>, err: E) -> Self {
-        Self {
-            pos: mark.offset.into(),
-            err,
-        }
+    pub fn at(pos: usize, err: E) -> Self {
+        Self { pos, err }
     }
 
     fn at_pos(pos: usize, err: E) -> Self {
@@ -1266,7 +1265,7 @@ pub trait Parser<'a, I: Input + ?Sized, O, E: ParserExtra<'a, I> = extra::Defaul
         Repeated {
             parser: self,
             at_least: 0,
-            at_most: None,
+            at_most: !0,
             phantom: PhantomData,
         }
     }
@@ -1316,7 +1315,7 @@ pub trait Parser<'a, I: Input + ?Sized, O, E: ParserExtra<'a, I> = extra::Defaul
             parser: self,
             separator,
             at_least: 0,
-            at_most: None,
+            at_most: !0,
             allow_leading: false,
             allow_trailing: false,
             phantom: PhantomData,
@@ -2183,12 +2182,16 @@ fn regex_parser() {
             .collect()
     }
     assert_eq!(
-        parser::<char>().parse("hello world this works").into_result(),
+        parser::<char>()
+            .parse("hello world this works")
+            .into_result(),
         Ok(vec!["hello", "world", "this", "works"]),
     );
 
     assert_eq!(
-        parser::<u8>().parse(b"hello world this works" as &[_]).into_result(),
+        parser::<u8>()
+            .parse(b"hello world this works" as &[_])
+            .into_result(),
         Ok(vec![
             b"hello" as &[_],
             b"world" as &[_],
diff --git a/src/zero_copy/primitive.rs b/src/zero_copy/primitive.rs
diff --git a/src/zero_copy/regex.rs b/src/zero_copy/regex.rs
