Slightly faster jump table dispatch heuristic

Author: zesterer

benches/parser.rs

@@ -31,8 +31,7 @@ fn bench_choice(c: &mut Criterion) {
         just('X'),
         just('Y'),
         just('Z'),
-    ))
-    .repeated();
+    ));
 
     let mut group = c.benchmark_group("choice");
 

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/primitive.rs

@@ -967,32 +967,37 @@ macro_rules! impl_choice_for_tuple {
                 // Note that this tends to pessimise behaviour for EmptyErr (which presumably optimises to an jump table already),
                 // so we detect this case and skip this optimisation using size_of.
                 #[cfg(feature = "nightly")]
-                if core::mem::size_of::<E::Error>() > 0 && $Head::Jump::SUPPORTS $(&& $X::Jump::SUPPORTS)* {
-                    if let Some(next) = inp.peek_maybe().as_deref() {
-                        match next {
-                            // The hope is that the optimiser folds this arm condition into the match in such a way that we end up with a jump table
-                            _ if $Head.will_match(&next) => return $Head.go::<M>(inp),
-                            $(
-                                _ if $X.will_match(&next) => return $X.go::<M>(inp),
-                            )*
-                            _ => return Err(()),
+                if core::mem::size_of::<E::Error>() > 0
+                    && $Head::Jump::SUPPORTS $(&& $X::Jump::SUPPORTS)*
+                    && (1 $(+ $X::Jump::SUPPORTS as u64)*) > 1
+                {
+                    return if let Some(next) = inp.peek_maybe_inner().as_ref().map(Borrow::borrow) {
+                        if $Head.will_match(&next) {
+                            $Head.go::<M>(inp)
+                        } $(else if $X.will_match(&next) {
+                            $X.go::<M>(inp)
+                        })* else {
+                            Err(())
                         }
-                    }
-                }
-
-                match $Head.go::<M>(inp) {
-                    Ok(out) => return Ok(out),
-                    Err(()) => inp.rewind(before.clone()),
-                }
-
-                $(
-                    match $X.go::<M>(inp) {
+                    } else {
+                        Err(())
+                    };
+                } else {
+                    match $Head.go::<M>(inp) {
                         Ok(out) => return Ok(out),
-                        Err(()) => inp.rewind(before.clone()),
+                        Err(()) => {},
                     }
-                )*
 
-                Err(())
+                    $(
+                        inp.rewind(before.clone());
+                        match $X.go::<M>(inp) {
+                            Ok(out) => return Ok(out),
+                            Err(()) => {},
+                        }
+                    )*
+
+                    Err(())
+                }
             }
 
             go_extra!(O);