Merge pull request #289 from zesterer/perf

zesterer · web-flow · commit cf7b266b79ed · 2023-02-18T22:00:00.000Z
Perf improvements and minor tweaks
diff --git a/benches/json.rs b/benches/json.rs
@@ -88,11 +88,9 @@ mod chumsky_zero_copy {
 
     pub fn json<'a>() -> impl Parser<'a, [u8], JsonZero<'a>> {
         recursive(|value| {
-            let digits = one_of(b'0'..=b'9').repeated().slice();
+            let digits = one_of(b'0'..=b'9').repeated();
 
             let int = one_of(b'1'..=b'9')
-                .repeated()
-                .at_least(1)
                 .then(one_of(b'0'..=b'9').repeated())
                 .ignored()
                 .or(just(b'0').ignored())
@@ -112,21 +110,18 @@ mod chumsky_zero_copy {
                 .map_slice(|bytes| str::from_utf8(bytes).unwrap().parse().unwrap())
                 .boxed();
 
-            let escape = just(b'\\')
-                .then(choice((
-                    just(b'\\'),
-                    just(b'/'),
-                    just(b'"'),
-                    just(b'b').to(b'\x08'),
-                    just(b'f').to(b'\x0C'),
-                    just(b'n').to(b'\n'),
-                    just(b'r').to(b'\r'),
-                    just(b't').to(b'\t'),
-                )))
-                .ignored();
+            let escape = just(b'\\').ignore_then(choice((
+                just(b'\\'),
+                just(b'/'),
+                just(b'"'),
+                just(b'b').to(b'\x08'),
+                just(b'f').to(b'\x0C'),
+                just(b'n').to(b'\n'),
+                just(b'r').to(b'\r'),
+                just(b't').to(b'\t'),
+            )));
 
             let string = none_of(b"\\\"")
-                .ignored()
                 .or(escape)
                 .repeated()
                 .slice()
@@ -135,7 +130,7 @@ mod chumsky_zero_copy {
 
             let array = value
                 .clone()
-                .separated_by(just(b',').padded())
+                .separated_by(just(b','))
                 .collect()
                 .padded()
                 .delimited_by(just(b'['), just(b']'))
diff --git a/benches/parser.rs b/benches/parser.rs
@@ -1,6 +1,5 @@
-
 use chumsky::zero_copy::prelude::*;
-use criterion::{black_box, criterion_group, criterion_main, Criterion, BenchmarkId};
+use criterion::{black_box, criterion_group, criterion_main, BenchmarkId, Criterion};
 
 fn bench_choice(c: &mut Criterion) {
     let alphabet_choice = choice((
@@ -36,19 +35,25 @@ fn bench_choice(c: &mut Criterion) {
 
     group.bench_function(BenchmarkId::new("choice::<(A..Z)>", "A"), |b| {
         b.iter(|| {
-            black_box(Parser::parse(&alphabet_choice, black_box("A"))).into_result().unwrap();
+            black_box(Parser::parse(&alphabet_choice, black_box("A")))
+                .into_result()
+                .unwrap();
         })
     });
 
     group.bench_function(BenchmarkId::new("choice::<(A..Z)>", "Z"), |b| {
         b.iter(|| {
-            black_box(alphabet_choice.parse(black_box("Z"))).into_result().unwrap();
+            black_box(alphabet_choice.parse(black_box("Z")))
+                .into_result()
+                .unwrap();
         })
     });
 
     group.bench_function(BenchmarkId::new("choice::<(A..Z)>", "0"), |b| {
         b.iter(|| {
-            black_box(alphabet_choice.parse(black_box("0"))).into_result().unwrap_err();
+            black_box(alphabet_choice.parse(black_box("0")))
+                .into_result()
+                .unwrap_err();
         })
     });
 }
diff --git a/src/zero_copy/input.rs b/src/zero_copy/input.rs
@@ -21,7 +21,10 @@ pub trait Input {
     fn start(&self) -> Self::Offset;
 
     /// Get the next offset from the provided one, and the next token if it exists
-    fn next(&self, offset: Self::Offset) -> (Self::Offset, Option<Self::Token>);
+    ///
+    /// Safety: `offset` must be generated be generated by either `Input::start` or a previous call to this function,
+    /// on this input only.
+    unsafe fn next(&self, offset: Self::Offset) -> (Self::Offset, Option<Self::Token>);
 
     /// Create a span from a start and end offset
     fn span(&self, range: Range<Self::Offset>) -> Self::Span;
@@ -55,7 +58,8 @@ impl Input for str {
         0
     }
 
-    fn next(&self, offset: Self::Offset) -> (Self::Offset, Option<Self::Token>) {
+    #[inline]
+    unsafe fn next(&self, offset: Self::Offset) -> (Self::Offset, Option<Self::Token>) {
         if offset < self.len() {
             let c = unsafe {
                 self.get_unchecked(offset..)
@@ -69,6 +73,7 @@ impl Input for str {
         }
     }
 
+    #[inline]
     fn span(&self, range: Range<Self::Offset>) -> Self::Span {
         range.into()
     }
@@ -79,9 +84,12 @@ impl StrInput<char> for str {}
 impl SliceInput for str {
     type Slice = str;
 
+    #[inline]
     fn slice(&self, range: Range<Self::Offset>) -> &Self::Slice {
         &self[range]
     }
+
+    #[inline]
     fn slice_from(&self, from: RangeFrom<Self::Offset>) -> &Self::Slice {
         &self[from]
     }
@@ -96,14 +104,17 @@ impl<T: Clone> Input for [T] {
         0
     }
 
-    fn next(&self, offset: Self::Offset) -> (Self::Offset, Option<Self::Token>) {
+    #[inline]
+    unsafe fn next(&self, offset: Self::Offset) -> (Self::Offset, Option<Self::Token>) {
         if let Some(tok) = self.get(offset) {
             (offset + 1, Some(tok.clone()))
         } else {
+            // We actually don't care if the offset goes beyond the end of the slice, and this seems to be *slightly* faster
             (offset, None)
         }
     }
 
+    #[inline]
     fn span(&self, range: Range<Self::Offset>) -> Self::Span {
         range.into()
     }
@@ -114,9 +125,12 @@ impl StrInput<u8> for [u8] {}
 impl<T: Clone> SliceInput for [T] {
     type Slice = [T];
 
+    #[inline]
     fn slice(&self, range: Range<Self::Offset>) -> &Self::Slice {
         &self[range]
     }
+
+    #[inline]
     fn slice_from(&self, from: RangeFrom<Self::Offset>) -> &Self::Slice {
         &self[from]
     }
@@ -135,7 +149,7 @@ impl<'a, Ctx: Clone, I: Input + ?Sized> Input for WithContext<'a, Ctx, I> {
         self.1.start()
     }
 
-    fn next(&self, offset: Self::Offset) -> (Self::Offset, Option<Self::Token>) {
+    unsafe fn next(&self, offset: Self::Offset) -> (Self::Offset, Option<Self::Token>) {
         self.1.next(offset)
     }
 
@@ -228,13 +242,13 @@ impl<'a, 'parse, I: Input + ?Sized, E: ParserExtra<'a, I>> InputRef<'a, 'parse,
     }
 
     /// Get the input offset that is currently being pointed to.
-    #[inline(always)]
+    #[inline]
     pub fn offset(&self) -> I::Offset {
         self.offset
     }
 
     /// Save off a [`Marker`] to the current position in the input
-    #[inline(always)]
+    #[inline]
     pub fn save(&self) -> Marker<I> {
         Marker {
             offset: self.offset,
@@ -243,30 +257,31 @@ impl<'a, 'parse, I: Input + ?Sized, E: ParserExtra<'a, I>> InputRef<'a, 'parse,
     }
 
     /// Reset the input state to the provided [`Marker`]
-    #[inline(always)]
+    #[inline]
     pub fn rewind(&mut self, marker: Marker<I>) {
         self.errors.truncate(marker.err_count);
         self.offset = marker.offset;
     }
 
-    #[inline(always)]
+    #[inline]
     pub(crate) fn state(&mut self) -> &mut E::State {
         match &mut self.state {
             Ok(state) => *state,
             Err(state) => state,
         }
     }
 
-    #[inline(always)]
+    #[inline]
     pub(crate) fn ctx(&self) -> &E::Context {
         &self.ctx
     }
 
-    #[inline(always)]
+    #[inline]
     pub(crate) fn skip_while<F: FnMut(&I::Token) -> bool>(&mut self, mut f: F) {
         let mut offs = self.offset;
         loop {
-            let (offset, token) = self.input.next(offs);
+            // SAFETY: offset was generated by previous call to `Input::next`
+            let (offset, token) = unsafe { self.input.next(offs) };
             if token.filter(&mut f).is_none() {
                 self.offset = offs;
                 break;
@@ -276,9 +291,10 @@ impl<'a, 'parse, I: Input + ?Sized, E: ParserExtra<'a, I>> InputRef<'a, 'parse,
         }
     }
 
-    #[inline(always)]
+    #[inline]
     pub(crate) fn next(&mut self) -> (I::Offset, Option<I::Token>) {
-        let (offset, token) = self.input.next(self.offset);
+        // SAFETY: offset was generated by previous call to `Input::next`
+        let (offset, token) = unsafe { self.input.next(self.offset) };
         self.offset = offset;
         (self.offset, token)
     }
@@ -290,32 +306,33 @@ 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.offset).1
+        // SAFETY: offset was generated by previous call to `Input::next`
+        unsafe { self.input.next(self.offset).1 }
     }
 
     /// Skip the next token in the input.
-    #[inline(always)]
+    #[inline]
     pub fn skip(&mut self) {
         let _ = self.next();
     }
 
-    #[inline(always)]
+    #[inline]
     pub(crate) fn slice(&self, range: Range<I::Offset>) -> &'a I::Slice
     where
         I: SliceInput,
     {
         self.input.slice(range)
     }
 
-    #[inline(always)]
+    #[inline]
     pub(crate) fn slice_from(&self, from: RangeFrom<I::Offset>) -> &'a I::Slice
     where
         I: SliceInput,
     {
         self.input.slice_from(from)
     }
 
-    #[inline(always)]
+    #[inline]
     pub(crate) fn slice_trailing(&self) -> &'a I::Slice
     where
         I: SliceInput,
@@ -324,12 +341,12 @@ impl<'a, 'parse, I: Input + ?Sized, E: ParserExtra<'a, I>> InputRef<'a, 'parse,
     }
 
     /// Return the span from the provided [`Marker`] to the current position
-    #[inline(always)]
+    #[inline]
     pub fn span_since(&self, before: I::Offset) -> I::Span {
         self.input.span(before..self.offset)
     }
 
-    #[inline(always)]
+    #[inline]
     pub(crate) fn skip_bytes<C>(&mut self, skip: usize)
     where
         C: Char,
@@ -338,7 +355,7 @@ impl<'a, 'parse, I: Input + ?Sized, E: ParserExtra<'a, I>> InputRef<'a, 'parse,
         self.offset += skip;
     }
 
-    #[inline(always)]
+    #[inline]
     pub(crate) fn emit(&mut self, error: E::Error) {
         self.errors.push(error);
     }
diff --git a/src/zero_copy/mod.rs b/src/zero_copy/mod.rs
@@ -2021,6 +2021,14 @@ where
         M::invoke(&*self.inner, inp)
     }
 
+    fn boxed(self) -> Boxed<'a, I, O, E>
+    where
+        Self: Sized + 'a,
+    {
+        // Never double-box parsers
+        self
+    }
+
     go_extra!(O);
 }
 
diff --git a/src/zero_copy/primitive.rs b/src/zero_copy/primitive.rs
@@ -834,24 +834,26 @@ where
 {
     fn go<M: Mode>(&self, inp: &mut InputRef<'a, '_, I, E>) -> PResult<M, O, E::Error> {
         let before = inp.save();
-        let res = self.parsers
-            .iter()
-            .try_fold(None::<Located<E::Error>>, |err, parser, | {
-                match parser.go::<M>(inp) {
-                    Ok(out) => Err(out),
-                    Err(e) => {
-                        Ok(Some(match err {
+        let res =
+            self.parsers
+                .iter()
+                .try_fold(None::<Located<E::Error>>, |err, parser| {
+                    match parser.go::<M>(inp) {
+                        Ok(out) => Err(out),
+                        Err(e) => Ok(Some(match err {
                             Some(err) => err.prioritize(e, |a, b| a.merge(b)),
                             None => e,
-                        }))
+                        })),
                     }
-                }
-            });
+                });
 
         match res {
-            Ok(err) => Err(err.unwrap_or_else(
-                || Located::at(inp.offset().into(), E::Error::expected_found(None, None, inp.span_since(before.offset)))
-            )),
+            Ok(err) => Err(err.unwrap_or_else(|| {
+                Located::at(
+                    inp.offset().into(),
+                    E::Error::expected_found(None, None, inp.span_since(before.offset)),
+                )
+            })),
             Err(out) => Ok(out),
         }
     }

Original file line number	Diff line number	Diff line change
`@@ -21,7 +21,10 @@ pub trait Input {`
`21`	`21`	`fn start(&self) -> Self::Offset;`
`22`	`22`
`23`	`23`	`/// Get the next offset from the provided one, and the next token if it exists`
`24`		`- fn next(&self, offset: Self::Offset) -> (Self::Offset, Option<Self::Token>);`
	`24`	`+ ///`
	`25`	+ /// Safety: `offset` must be generated be generated by either `Input::start` or a previous call to this function,
	`26`	`+ /// on this input only.`
	`27`	`+ unsafe fn next(&self, offset: Self::Offset) -> (Self::Offset, Option<Self::Token>);`
`25`	`28`
`26`	`29`	`/// Create a span from a start and end offset`
`27`	`30`	`fn span(&self, range: Range<Self::Offset>) -> Self::Span;`
`@@ -55,7 +58,8 @@ impl Input for str {`
`55`	`58`	`0`
`56`	`59`	`}`
`57`	`60`
`58`		`- fn next(&self, offset: Self::Offset) -> (Self::Offset, Option<Self::Token>) {`
	`61`	`+ #[inline]`
	`62`	`+ unsafe fn next(&self, offset: Self::Offset) -> (Self::Offset, Option<Self::Token>) {`
`59`	`63`	`if offset < self.len() {`
`60`	`64`	`let c = unsafe {`
`61`	`65`	`self.get_unchecked(offset..)`
`@@ -69,6 +73,7 @@ impl Input for str {`
`69`	`73`	`}`
`70`	`74`	`}`
`71`	`75`
	`76`	`+ #[inline]`
`72`	`77`	`fn span(&self, range: Range<Self::Offset>) -> Self::Span {`
`73`	`78`	`range.into()`
`74`	`79`	`}`
`@@ -79,9 +84,12 @@ impl StrInput<char> for str {}`
`79`	`84`	`impl SliceInput for str {`
`80`	`85`	`type Slice = str;`
`81`	`86`
	`87`	`+ #[inline]`
`82`	`88`	`fn slice(&self, range: Range<Self::Offset>) -> &Self::Slice {`
`83`	`89`	`&self[range]`
`84`	`90`	`}`
	`91`	`+`
	`92`	`+ #[inline]`
`85`	`93`	`fn slice_from(&self, from: RangeFrom<Self::Offset>) -> &Self::Slice {`
`86`	`94`	`&self[from]`
`87`	`95`	`}`
`@@ -96,14 +104,17 @@ impl<T: Clone> Input for [T] {`
`96`	`104`	`0`
`97`	`105`	`}`
`98`	`106`
`99`		`- fn next(&self, offset: Self::Offset) -> (Self::Offset, Option<Self::Token>) {`
	`107`	`+ #[inline]`
	`108`	`+ unsafe fn next(&self, offset: Self::Offset) -> (Self::Offset, Option<Self::Token>) {`
`100`	`109`	`if let Some(tok) = self.get(offset) {`
`101`	`110`	`(offset + 1, Some(tok.clone()))`
`102`	`111`	`} else {`
	`112`	`+ // We actually don't care if the offset goes beyond the end of the slice, and this seems to be slightly faster`
`103`	`113`	`(offset, None)`
`104`	`114`	`}`
`105`	`115`	`}`
`106`	`116`
	`117`	`+ #[inline]`
`107`	`118`	`fn span(&self, range: Range<Self::Offset>) -> Self::Span {`
`108`	`119`	`range.into()`
`109`	`120`	`}`
`@@ -114,9 +125,12 @@ impl StrInput<u8> for [u8] {}`
`114`	`125`	`impl<T: Clone> SliceInput for [T] {`
`115`	`126`	`type Slice = [T];`
`116`	`127`
	`128`	`+ #[inline]`
`117`	`129`	`fn slice(&self, range: Range<Self::Offset>) -> &Self::Slice {`
`118`	`130`	`&self[range]`
`119`	`131`	`}`
	`132`	`+`
	`133`	`+ #[inline]`
`120`	`134`	`fn slice_from(&self, from: RangeFrom<Self::Offset>) -> &Self::Slice {`
`121`	`135`	`&self[from]`
`122`	`136`	`}`
`@@ -135,7 +149,7 @@ impl<'a, Ctx: Clone, I: Input + ?Sized> Input for WithContext<'a, Ctx, I> {`
`135`	`149`	`self.1.start()`
`136`	`150`	`}`
`137`	`151`
`138`		`- fn next(&self, offset: Self::Offset) -> (Self::Offset, Option<Self::Token>) {`
	`152`	`+ unsafe fn next(&self, offset: Self::Offset) -> (Self::Offset, Option<Self::Token>) {`
`139`	`153`	`self.1.next(offset)`
`140`	`154`	`}`
`141`	`155`
`@@ -228,13 +242,13 @@ impl<'a, 'parse, I: Input + ?Sized, E: ParserExtra<'a, I>> InputRef<'a, 'parse,`
`228`	`242`	`}`
`229`	`243`
`230`	`244`	`/// Get the input offset that is currently being pointed to.`
`231`		`- #[inline(always)]`
	`245`	`+ #[inline]`
`232`	`246`	`pub fn offset(&self) -> I::Offset {`
`233`	`247`	`self.offset`
`234`	`248`	`}`
`235`	`249`
`236`	`250`	/// Save off a [`Marker`] to the current position in the input
`237`		`- #[inline(always)]`
	`251`	`+ #[inline]`
`238`	`252`	`pub fn save(&self) -> Marker<I> {`
`239`	`253`	`Marker {`
`240`	`254`	`offset: self.offset,`
`@@ -243,30 +257,31 @@ impl<'a, 'parse, I: Input + ?Sized, E: ParserExtra<'a, I>> InputRef<'a, 'parse,`
`243`	`257`	`}`
`244`	`258`
`245`	`259`	/// Reset the input state to the provided [`Marker`]
`246`		`- #[inline(always)]`
	`260`	`+ #[inline]`
`247`	`261`	`pub fn rewind(&mut self, marker: Marker<I>) {`
`248`	`262`	`self.errors.truncate(marker.err_count);`
`249`	`263`	`self.offset = marker.offset;`
`250`	`264`	`}`
`251`	`265`
`252`		`- #[inline(always)]`
	`266`	`+ #[inline]`
`253`	`267`	`pub(crate) fn state(&mut self) -> &mut E::State {`
`254`	`268`	`match &mut self.state {`
`255`	`269`	`Ok(state) => *state,`
`256`	`270`	`Err(state) => state,`
`257`	`271`	`}`
`258`	`272`	`}`
`259`	`273`
`260`		`- #[inline(always)]`
	`274`	`+ #[inline]`
`261`	`275`	`pub(crate) fn ctx(&self) -> &E::Context {`
`262`	`276`	`&self.ctx`
`263`	`277`	`}`
`264`	`278`
`265`		`- #[inline(always)]`
	`279`	`+ #[inline]`
`266`	`280`	`pub(crate) fn skip_while<F: FnMut(&I::Token) -> bool>(&mut self, mut f: F) {`
`267`	`281`	`let mut offs = self.offset;`
`268`	`282`	`loop {`
`269`		`- let (offset, token) = self.input.next(offs);`
	`283`	+ // SAFETY: offset was generated by previous call to `Input::next`
	`284`	`+ let (offset, token) = unsafe { self.input.next(offs) };`
`270`	`285`	`if token.filter(&mut f).is_none() {`
`271`	`286`	`self.offset = offs;`
`272`	`287`	`break;`
`@@ -276,9 +291,10 @@ impl<'a, 'parse, I: Input + ?Sized, E: ParserExtra<'a, I>> InputRef<'a, 'parse,`
`276`	`291`	`}`
`277`	`292`	`}`
`278`	`293`
`279`		`- #[inline(always)]`
	`294`	`+ #[inline]`
`280`	`295`	`pub(crate) fn next(&mut self) -> (I::Offset, Option<I::Token>) {`
`281`		`- let (offset, token) = self.input.next(self.offset);`
	`296`	+ // SAFETY: offset was generated by previous call to `Input::next`
	`297`	`+ let (offset, token) = unsafe { self.input.next(self.offset) };`
`282`	`298`	`self.offset = offset;`
`283`	`299`	`(self.offset, token)`
`284`	`300`	`}`
`@@ -290,32 +306,33 @@ impl<'a, 'parse, I: Input + ?Sized, E: ParserExtra<'a, I>> InputRef<'a, 'parse,`
`290`	`306`
`291`	`307`	/// Peek the next token in the input. Returns `None` for EOI
`292`	`308`	`pub fn peek(&self) -> Option<I::Token> {`
`293`		`- self.input.next(self.offset).1`
	`309`	+ // SAFETY: offset was generated by previous call to `Input::next`
	`310`	`+ unsafe { self.input.next(self.offset).1 }`
`294`	`311`	`}`
`295`	`312`
`296`	`313`	`/// Skip the next token in the input.`
`297`		`- #[inline(always)]`
	`314`	`+ #[inline]`
`298`	`315`	`pub fn skip(&mut self) {`
`299`	`316`	`let _ = self.next();`
`300`	`317`	`}`
`301`	`318`
`302`		`- #[inline(always)]`
	`319`	`+ #[inline]`
`303`	`320`	`pub(crate) fn slice(&self, range: Range<I::Offset>) -> &'a I::Slice`
`304`	`321`	`where`
`305`	`322`	`I: SliceInput,`
`306`	`323`	`{`
`307`	`324`	`self.input.slice(range)`
`308`	`325`	`}`
`309`	`326`
`310`		`- #[inline(always)]`
	`327`	`+ #[inline]`
`311`	`328`	`pub(crate) fn slice_from(&self, from: RangeFrom<I::Offset>) -> &'a I::Slice`
`312`	`329`	`where`
`313`	`330`	`I: SliceInput,`
`314`	`331`	`{`
`315`	`332`	`self.input.slice_from(from)`
`316`	`333`	`}`
`317`	`334`
`318`		`- #[inline(always)]`
	`335`	`+ #[inline]`
`319`	`336`	`pub(crate) fn slice_trailing(&self) -> &'a I::Slice`
`320`	`337`	`where`
`321`	`338`	`I: SliceInput,`
`@@ -324,12 +341,12 @@ impl<'a, 'parse, I: Input + ?Sized, E: ParserExtra<'a, I>> InputRef<'a, 'parse,`
`324`	`341`	`}`
`325`	`342`
`326`	`343`	/// Return the span from the provided [`Marker`] to the current position
`327`		`- #[inline(always)]`
	`344`	`+ #[inline]`
`328`	`345`	`pub fn span_since(&self, before: I::Offset) -> I::Span {`
`329`	`346`	`self.input.span(before..self.offset)`
`330`	`347`	`}`
`331`	`348`
`332`		`- #[inline(always)]`
	`349`	`+ #[inline]`
`333`	`350`	`pub(crate) fn skip_bytes<C>(&mut self, skip: usize)`
`334`	`351`	`where`
`335`	`352`	`C: Char,`
`@@ -338,7 +355,7 @@ impl<'a, 'parse, I: Input + ?Sized, E: ParserExtra<'a, I>> InputRef<'a, 'parse,`
`338`	`355`	`self.offset += skip;`
`339`	`356`	`}`
`340`	`357`
`341`		`- #[inline(always)]`
	`358`	`+ #[inline]`
`342`	`359`	`pub(crate) fn emit(&mut self, error: E::Error) {`
`343`	`360`	`self.errors.push(error);`
`344`	`361`	`}`
Original file line number	Diff line number	Diff line change
`@@ -2021,6 +2021,14 @@ where`
`2021`	`2021`	`M::invoke(&*self.inner, inp)`
`2022`	`2022`	`}`
`2023`	`2023`
	`2024`	`+ fn boxed(self) -> Boxed<'a, I, O, E>`
	`2025`	`+ where`
	`2026`	`+ Self: Sized + 'a,`
	`2027`	`+ {`
	`2028`	`+ // Never double-box parsers`
	`2029`	`+ self`
	`2030`	`+ }`
	`2031`	`+`
`2024`	`2032`	`go_extra!(O);`
`2025`	`2033`	`}`
`2026`	`2034`