Attempt to automagically generate jump tables for choice

README.md

@@ -24,7 +24,7 @@ that you may need. It also has `no_std` support, making it suitable for embedded
 - ☑️ **Check-only mode** for fast verification of inputs, automatically supported
 - 🚀 **Internal optimiser** leverages the power of [GATs](https://smallcultfollowing.com/babysteps/blog/2022/06/27/many-modes-a-gats-pattern/) to optimise your parser for you
 - 📖 **Text-oriented parsers** for text inputs (i.e: `&[u8]` and `&str`)
-- 👁️‍🗨️ **Context-free grammars** are fully supported, with support for context-sensitivity
+- 👁️ **Context-free grammars** are fully supported, with support for context-sensitivity
 - 🔄 **Left recursion and memoization** have opt-in support
 - 🪺 **Nested inputs** such as token trees are fully supported both as inputs and outputs
 - 🏷️ **Pattern labelling** for dynamic, user-friendly error messages

benches/json.rs

@@ -178,10 +178,14 @@ mod chumsky_zero_copy {
                 just(b"null").to(JsonZero::Null),
                 just(b"true").to(JsonZero::Bool(true)),
                 just(b"false").to(JsonZero::Bool(false)),
-                number.map(JsonZero::Num),
-                string.map(JsonZero::Str),
-                array.map(JsonZero::Array),
-                object.map(JsonZero::Object),
+                one_of(b"0123456789-")
+                    .rewind()
+                    .ignore_then(number.map(JsonZero::Num)),
+                just(b'"').rewind().ignore_then(string.map(JsonZero::Str)),
+                just(b'[').rewind().ignore_then(array.map(JsonZero::Array)),
+                just(b'{')
+                    .rewind()
+                    .ignore_then(object.map(JsonZero::Object)),
             ))
             .padded()
         })

src/combinator.rs

@@ -223,6 +223,7 @@ where
     }
 
     go_extra!(I::Slice);
+    could_match!(parser : A);
 }
 
 /// See [`Parser::filter`].
@@ -323,6 +324,7 @@ where
     }
 
     go_extra!(O);
+    could_match!(parser : A);
 }
 
 impl<'src, I, O, E, A, OA, F> IterParser<'src, I, O, E> for Map<A, OA, F>
@@ -396,6 +398,7 @@ where
     }
 
     go_extra!(O);
+    could_match!(parser : A);
 }
 
 impl<'src, I, O, E, A, OA, F> IterParser<'src, I, O, E> for MapWith<A, OA, F>
@@ -474,6 +477,7 @@ where
     }
 
     go_extra!(O);
+    could_match!(parser : A);
 }
 
 #[cfg(feature = "nightly")]
@@ -544,6 +548,7 @@ where
     }
 
     go_extra!(I::Span);
+    could_match!(parser : A);
 }
 
 /// See [`Parser::try_foldl`].
@@ -607,6 +612,7 @@ where
     }
 
     go_extra!(OA);
+    could_match!(parser_a : A);
 }
 
 /// See [`Parser::try_map`].
@@ -779,6 +785,7 @@ where
     }
 
     go_extra!(O);
+    could_match!(parser : A);
 }
 
 /// See [`Parser::into_iter`].
@@ -812,6 +819,7 @@ where
     }
 
     go_extra!(());
+    could_match!(parser : A);
 }
 
 impl<'src, A, O, I, E> IterParser<'src, I, O::Item, E> for IntoIter<A, O>
@@ -875,6 +883,7 @@ where
     }
 
     go_extra!(());
+    could_match!(parser : A);
 }
 
 /// See [`Parser::unwrapped`].
@@ -1118,6 +1127,7 @@ where
     }
 
     go_extra!(OB);
+    could_match!(parser_a : A);
 }
 
 /// See [`Parser::then_ignore`].
@@ -1154,6 +1164,7 @@ where
     }
 
     go_extra!(OA);
+    could_match!(parser_a : A);
 }
 
 /// See [`Parser::nested_in`].
@@ -1213,6 +1224,7 @@ where
     }
 
     go_extra!(O);
+    could_match!(parser_b : B);
 }
 
 /// See [`Parser::ignore_with_ctx`].
@@ -1250,6 +1262,7 @@ where
     }
 
     go_extra!(OB);
+    could_match!(parser : A);
 }
 
 impl<'src, I, E, A, B, OA, OB> IterParser<'src, I, OB, E>
@@ -1325,6 +1338,7 @@ where
     }
 
     go_extra!((OA, OB));
+    could_match!(parser : A);
 }
 
 impl<'src, I, E, A, B, OA, OB> IterParser<'src, I, OB, E>
@@ -1393,6 +1407,7 @@ where
     }
 
     go_extra!(O);
+    could_match!(parser : A);
 }
 
 /// See [`Parser::with_state`].
@@ -1424,6 +1439,7 @@ where
     }
 
     go_extra!(O);
+    could_match!(parser : A);
 }
 
 /// See [`Parser::delimited_by`].
@@ -1464,6 +1480,7 @@ where
     }
 
     go_extra!(OA);
+    could_match!(start : B);
 }
 
 /// See [`Parser::padded_by`].
@@ -1501,6 +1518,7 @@ where
     }
 
     go_extra!(OA);
+    could_match!(padding : B);
 }
 
 /// See [`Parser::or`].
@@ -2773,6 +2791,7 @@ where
     }
 
     go_extra!(O);
+    could_match!(parser : A);
 }
 
 /// See [`Parser::map_err`].
@@ -2800,6 +2819,7 @@ where
     }
 
     go_extra!(O);
+    could_match!(parser : A);
 }
 
 // /// See [`Parser::map_err_with_span`].
@@ -2881,6 +2901,7 @@ where
     }
 
     go_extra!(O);
+    could_match!(parser : A);
 }
 
 /// See [`Parser::validate`]
@@ -2926,6 +2947,7 @@ where
     }
 
     go_extra!(U);
+    could_match!(parser : A);
 }
 
 // /// See [`Parser::or_else`].

src/container.rs

@@ -895,7 +895,17 @@ impl<'p> Seq<'p, &'p Grapheme> for &'p Graphemes {
 /// A utility trait to abstract over *linear* container-like things.
 ///
 /// This trait is likely to change in future versions of the crate, so avoid implementing it yourself.
-pub trait OrderedSeq<'p, T>: Seq<'p, T> {}
+pub trait OrderedSeq<'p, T>: Seq<'p, T> {
+    #[doc(hidden)]
+    #[cfg(feature = "nightly")]
+    #[inline]
+    fn matches_first(&self, start: &T) -> bool
+    where
+        T: PartialEq,
+    {
+        self.seq_iter().next().map_or(true, |x| start == x.borrow())
+    }
+}
 
 impl<T: Clone> OrderedSeq<'_, T> for T {}
 impl<'p, T> OrderedSeq<'p, T> for &'p T {}

src/input.rs

@@ -1605,13 +1605,18 @@ impl<'src, 'parse, I: Input<'src>, E: ParserExtra<'src, I>> InputRef<'src, 'pars
         self.next_ref_inner()
     }
 
+    #[inline(always)]
+    pub(crate) fn peek_maybe_inner(&mut self) -> Option<I::MaybeToken> {
+        // SAFETY: cursor was generated by previous call to `Input::next`
+        unsafe { I::next_maybe(self.cache, &mut self.cursor.clone()) }
+    }
+
     /// Peek the next token in the input. Returns `None` if the end of the input has been reached.
     ///
     /// See [`InputRef::next_maybe`] for more information about what this function guarantees.
     #[inline(always)]
     pub fn peek_maybe(&mut self) -> Option<MaybeRef<'src, I::Token>> {
-        // SAFETY: cursor was generated by previous call to `Input::next`
-        unsafe { I::next_maybe(self.cache, &mut self.cursor.clone()).map(Into::into) }
+        self.peek_maybe_inner().map(Into::into)
     }
 
     /// Peek the next token in the input. Returns `None` if the end of the input has been reached.

src/lib.rs

@@ -2,7 +2,13 @@
 #![cfg_attr(docsrs, feature(doc_auto_cfg, doc_cfg), deny(rustdoc::all))]
 #![cfg_attr(
     feature = "nightly",
-    feature(never_type, fn_traits, tuple_trait, unboxed_closures)
+    feature(
+        never_type,
+        fn_traits,
+        tuple_trait,
+        unboxed_closures,
+        associated_type_defaults
+    )
 )]
 #![doc = include_str!("../README.md")]
 #![deny(missing_docs, clippy::undocumented_unsafe_blocks)]
@@ -28,6 +34,19 @@ macro_rules! go_extra {
     };
 }
 
+macro_rules! could_match {
+    ($field:ident : $T:ty) => {
+        #[cfg(feature = "nightly")]
+        type Jump = <$T>::Jump;
+
+        #[cfg(feature = "nightly")]
+        #[inline]
+        fn will_match(&self, start: &I::Token) -> bool {
+            self.$field.will_match(start)
+        }
+    };
+}
+
 mod blanket;
 #[cfg(feature = "unstable")]
 pub mod cache;
@@ -278,6 +297,16 @@ impl<T, E> ParseResult<T, E> {
     }
 }
 
+#[doc(hidden)]
+pub trait SupportsJump {
+    const SUPPORTS: bool = false;
+}
+#[doc(hidden)]
+pub struct Jump<const SUPPORTS: bool>;
+impl<const SUPPORTS: bool> SupportsJump for Jump<SUPPORTS> {
+    const SUPPORTS: bool = SUPPORTS;
+}
+
 /// A trait implemented by parsers.
 ///
 /// Parsers take inputs of type `I`, which will implement [`Input`]. Refer to the documentation on [`Input`] for examples
@@ -320,6 +349,19 @@ impl<T, E> ParseResult<T, E> {
 //     )
 // )]
 pub trait Parser<'src, I: Input<'src>, O, E: ParserExtra<'src, I> = extra::Default> {
+    #[doc(hidden)]
+    #[cfg(feature = "nightly")]
+    type Jump: SupportsJump
+        = Jump<false>
+    where
+        Self: Sized;
+
+    #[doc(hidden)]
+    #[cfg(feature = "nightly")]
+    fn will_match(&self, _i: &I::Token) -> bool {
+        unimplemented!()
+    }
+
     #[doc(hidden)]
     fn go<M: Mode>(&self, inp: &mut InputRef<'src, '_, I, E>) -> PResult<M, O>
     where