diff --git a/build.zig b/build.zig
index 03774ca9ac707c2c01d8c8d7815aa0aa1cb4bbfd..385d4d5b7e0288d79a07c4c2c314cb7e6bc30c5d 100644
--- a/build.zig
+++ b/build.zig
@@ -719,6 +719,30 @@ pub fn build(b: *std.Build) !void {
     check_mingw_run.addDirectoryArg(b.path("lib/libc/mingw"));
     check_mingw_step.dependOn(&check_mingw_run.step);
 
+    {
+        const gen_oracle_exe = b.addExecutable(.{
+            .name = "gen_parser_oracle",
+            .root_module = b.createModule(.{
+                .root_source_file = b.path("tools/gen_parser_oracle.zig"),
+                .target = b.graph.host,
+            }),
+        });
+
+        const gen_oracle_step = b.step("gen-parser-oracle", "Regenerate lib/std/zig/parser_generated_oracle.zig from doc/langref/grammar.peg");
+        const gen_oracle_run = b.addRunArtifact(gen_oracle_exe);
+        gen_oracle_run.addFileArg(b.path("doc/langref/grammar.peg"));
+        gen_oracle_run.addFileArg(b.path("lib/std/zig/parser_generated_oracle.zig"));
+        gen_oracle_step.dependOn(&gen_oracle_run.step);
+
+        const check_oracle_step = b.step("check-parser-oracle", "Check if doc/langref/grammar.peg was modified without regenerating the oracle");
+        const check_oracle_run = b.addRunArtifact(gen_oracle_exe);
+        check_oracle_run.addFileArg(b.path("doc/langref/grammar.peg"));
+        check_oracle_run.addFileArg(b.path("lib/std/zig/parser_generated_oracle.zig"));
+        check_oracle_run.addArg("--check");
+        check_oracle_step.dependOn(&check_oracle_run.step);
+        test_step.dependOn(check_oracle_step);
+    }
+
     const test_incremental_step = b.step("test-incremental", "Run the incremental compilation test cases");
     try tests.addIncrementalTests(b, test_incremental_step, test_filters);
     if (!skip_test_incremental) test_step.dependOn(test_incremental_step);
@@ -1569,8 +1593,9 @@ fn generateLangRef(b: *std.Build) !std.Build.LazyPath {
 
     var it = dir.iterateAssumeFirstIteration();
     while (it.next(io) catch @panic("failed to read dir")) |entry| {
-        if (std.mem.startsWith(u8, entry.name, ".") or entry.kind != .file)
-            continue;
+        if (entry.kind != .file) continue;
+        if (std.mem.startsWith(u8, entry.name, ".")) continue;
+        if (!std.mem.endsWith(u8, entry.name, ".zig")) continue;
 
         const out_basename = b.fmt("{s}.out", .{std.fs.path.stem(entry.name)});
         const cmd = b.addRunArtifact(doctest_exe);
@@ -1603,6 +1628,8 @@ fn generateLangRef(b: *std.Build) !std.Build.LazyPath {
     const docgen_cmd = b.addRunArtifact(docgen_exe);
     docgen_cmd.addArgs(&.{"--code-dir"});
     docgen_cmd.addDirectoryArg(wf.getDirectory());
+    docgen_cmd.addArgs(&.{"--grammar"});
+    docgen_cmd.addFileArg(b.path("doc/langref/grammar.peg"));
 
     docgen_cmd.addFileArg(b.path("doc/langref.html.in"));
     return docgen_cmd.addOutputFileArg("langref.html");
diff --git a/doc/langref.html.in b/doc/langref.html.in
index f24f03c981f5d78513468aa31c3983b06ae2670d..4766e8d508d31b76b6258501ef1226f7d809c1e1 100644
--- a/doc/langref.html.in
+++ b/doc/langref.html.in
@@ -7798,597 +7798,7 @@ fn readU32Be() u32 {}
 
       {#header_open|Appendix#}
       {#header_open|Grammar#}
-      {#syntax_block|peg|grammar.peg#}
-Root <- skip ContainerMembers eof
-
-# *** Top level ***
-ContainerMembers <- container_doc_comment? ContainerDeclaration* (ContainerField COMMA)* (ContainerField / ContainerDeclaration*)
-
-ContainerDeclaration <- TestDecl / ComptimeDecl / doc_comment? KEYWORD_pub? Decl
-
-TestDecl <- KEYWORD_test (STRINGLITERALSINGLE / IDENTIFIER)? Block
-
-ComptimeDecl <- KEYWORD_comptime Block
-
-Decl
-    <- (KEYWORD_export / KEYWORD_inline / KEYWORD_noinline)? FnProto (SEMICOLON / Block)
-     / KEYWORD_extern STRINGLITERALSINGLE? FnProto SEMICOLON
-     / (KEYWORD_export / KEYWORD_extern STRINGLITERALSINGLE?)? KEYWORD_threadlocal? GlobalVarDecl
-
-FnProto <- KEYWORD_fn IDENTIFIER? LPAREN ParamDeclList RPAREN ByteAlign? AddrSpace? LinkSection? CallConv? EXCLAMATIONMARK? TypeExpr !ExprSuffix
-
-VarDeclProto <- (KEYWORD_const / KEYWORD_var) IDENTIFIER (COLON TypeExpr)? ByteAlign? AddrSpace? LinkSection?
-
-GlobalVarDecl <- VarDeclProto (EQUAL Expr)? SEMICOLON
-
-ContainerField <- doc_comment? (KEYWORD_comptime / !KEYWORD_comptime) !KEYWORD_fn (IDENTIFIER COLON / !(IDENTIFIER COLON))? TypeExpr ByteAlign? (EQUAL Expr)?
-
-# *** Block Level ***
-BlockStatement
-    <- Statement
-     / KEYWORD_defer BlockExprStatement
-     / KEYWORD_errdefer BlockExprStatement
-     / !ExprStatement (KEYWORD_comptime !BlockExpr)? VarAssignStatement
-
-Statement
-    <- ExprStatement
-     / KEYWORD_suspend BlockExprStatement
-     / !ExprStatement (KEYWORD_comptime !BlockExpr)? AssignExpr SEMICOLON
-
-ExprStatement
-    <- IfStatement
-     / LabeledStatement
-     / KEYWORD_nosuspend BlockExprStatement
-     / KEYWORD_comptime BlockExpr
-
-IfStatement
-    <- IfPrefix BlockExpr ( KEYWORD_else Payload? Statement )?
-     / IfPrefix !BlockExpr AssignExpr ( SEMICOLON / KEYWORD_else Payload? Statement )
-
-LabeledStatement <- BlockLabel? (Block / LoopStatement / SwitchExpr)
-
-LoopStatement <- KEYWORD_inline? (ForStatement / WhileStatement)
-
-ForStatement
-    <- ForPrefix BlockExpr ( KEYWORD_else Statement / !KEYWORD_else )
-     / ForPrefix !BlockExpr AssignExpr ( SEMICOLON / KEYWORD_else Statement )
-
-WhileStatement
-    <- WhilePrefix BlockExpr ( KEYWORD_else Payload? Statement )?
-     / WhilePrefix !BlockExpr AssignExpr ( SEMICOLON / KEYWORD_else Payload? Statement )
-
-BlockExprStatement
-    <- BlockExpr
-     / !BlockExpr AssignExpr SEMICOLON
-
-BlockExpr <- BlockLabel? Block
-
-# An assignment or a destructure whose LHS are all lvalue expressions or variable declarations.
-VarAssignStatement <- (VarDeclProto / Expr) (COMMA (VarDeclProto / Expr))* EQUAL Expr SEMICOLON
-
-# *** Expression Level ***
-
-# An assignment or a destructure whose LHS are all lvalue expressions.
-AssignExpr <- Expr (AssignOp Expr / (COMMA Expr)+ EQUAL Expr)?
-
-SingleAssignExpr <- Expr (AssignOp Expr)?
-
-Expr <- BoolOrExpr
-
-BoolOrExpr <- BoolAndExpr (KEYWORD_or BoolAndExpr)*
-
-BoolAndExpr <- CompareExpr (KEYWORD_and CompareExpr)*
-
-CompareExpr <- BitwiseExpr (CompareOp BitwiseExpr)?
-
-BitwiseExpr <- BitShiftExpr (BitwiseOp BitShiftExpr)*
-
-BitShiftExpr <- AdditionExpr (BitShiftOp AdditionExpr)*
-
-AdditionExpr <- MultiplyExpr (AdditionOp MultiplyExpr)*
-
-MultiplyExpr <- PrefixExpr (MultiplyOp PrefixExpr)*
-
-PrefixExpr <- PrefixOp* PrimaryExpr
-
-PrimaryExpr
-    <- AsmExpr
-     / IfExpr
-     / KEYWORD_break (BreakLabel / !BreakLabel) (Expr !ExprSuffix / !SinglePtrTypeStart)
-     / KEYWORD_comptime Expr !ExprSuffix
-     / KEYWORD_nosuspend Expr !ExprSuffix
-     / KEYWORD_continue (BreakLabel / !BreakLabel) (Expr !ExprSuffix / !SinglePtrTypeStart)
-     / KEYWORD_resume Expr !ExprSuffix
-     / KEYWORD_return (Expr !ExprSuffix / !SinglePtrTypeStart)
-     / BlockLabel? LoopExpr
-     / Block
-     / CurlySuffixExpr
-
-IfExpr <- IfPrefix Expr (KEYWORD_else Payload? Expr)? !ExprSuffix
-
-Block <- LBRACE BlockStatement* RBRACE
-
-LoopExpr <- KEYWORD_inline? (ForExpr / WhileExpr)
-
-ForExpr <- ForPrefix Expr (KEYWORD_else Expr / !KEYWORD_else) !ExprSuffix
-
-WhileExpr <- WhilePrefix Expr (KEYWORD_else Payload? Expr)? !ExprSuffix
-
-CurlySuffixExpr <- TypeExpr InitList?
-
-InitList
-    <- LBRACE FieldInit (COMMA FieldInit)* COMMA? RBRACE
-     / LBRACE Expr (COMMA Expr)* COMMA? RBRACE
-     / LBRACE RBRACE
-
-TypeExpr <- PrefixTypeOp* ErrorUnionExpr
-
-ErrorUnionExpr <- SuffixExpr (EXCLAMATIONMARK TypeExpr)?
-
-SuffixExpr
-    <- PrimaryTypeExpr (SuffixOp / FnCallArguments)*
-
-PrimaryTypeExpr
-    <- BUILTINIDENTIFIER FnCallArguments
-     / CHAR_LITERAL
-     / ContainerDecl
-     / DOT IDENTIFIER
-     / DOT InitList
-     / ErrorSetDecl
-     / FLOAT
-     / FnProto
-     / GroupedExpr
-     / LabeledTypeExpr
-     / IDENTIFIER !(COLON LabelableExpr)
-     / IfTypeExpr
-     / INTEGER
-     / KEYWORD_comptime TypeExpr !ExprSuffix
-     / KEYWORD_error DOT IDENTIFIER
-     / KEYWORD_anyframe
-     / KEYWORD_unreachable
-     / STRINGLITERAL
-
-ContainerDecl <- (KEYWORD_extern / KEYWORD_packed)? ContainerDeclAuto
-
-ErrorSetDecl <- KEYWORD_error LBRACE IdentifierList RBRACE
-
-GroupedExpr <- LPAREN Expr RPAREN
-
-IfTypeExpr <- IfPrefix TypeExpr (KEYWORD_else Payload? TypeExpr)? !ExprSuffix
-
-LabeledTypeExpr
-    <- BlockLabel Block
-     / BlockLabel? LoopTypeExpr
-     / BlockLabel? SwitchExpr
-
-LoopTypeExpr <- KEYWORD_inline? (ForTypeExpr / WhileTypeExpr)
-
-ForTypeExpr <- ForPrefix TypeExpr (KEYWORD_else TypeExpr / !KEYWORD_else) !ExprSuffix
-
-WhileTypeExpr <- WhilePrefix TypeExpr (KEYWORD_else Payload? TypeExpr)? !ExprSuffix
-
-SwitchExpr <- KEYWORD_switch LPAREN Expr RPAREN LBRACE SwitchProngList RBRACE
-
-# *** Assembly ***
-AsmExpr <- KEYWORD_asm KEYWORD_volatile? LPAREN Expr AsmOutput? RPAREN
-
-AsmOutput <- COLON AsmOutputList AsmInput?
-
-AsmOutputItem <- LBRACKET IDENTIFIER RBRACKET STRINGLITERALSINGLE LPAREN (MINUSRARROW TypeExpr / IDENTIFIER) RPAREN
-
-AsmInput <- COLON AsmInputList AsmClobbers?
-
-AsmInputItem <- LBRACKET IDENTIFIER RBRACKET STRINGLITERALSINGLE LPAREN Expr RPAREN
-
-AsmClobbers <- COLON Expr
-
-# *** Helper grammar ***
-BreakLabel <- COLON IDENTIFIER
-
-BlockLabel <- IDENTIFIER COLON
-
-FieldInit <- DOT IDENTIFIER EQUAL Expr
-
-WhileContinueExpr <- COLON LPAREN AssignExpr RPAREN
-
-LinkSection <- KEYWORD_linksection LPAREN Expr RPAREN
-
-AddrSpace <- KEYWORD_addrspace LPAREN Expr RPAREN
-
-# Fn specific
-CallConv <- KEYWORD_callconv LPAREN Expr RPAREN
-
-ParamDecl <- doc_comment? (KEYWORD_noalias / KEYWORD_comptime / !KEYWORD_comptime) (IDENTIFIER COLON / !(IDENTIFIER COLON)) ParamType
-
-ParamType
-    <- KEYWORD_anytype
-     / TypeExpr
-
-# Control flow prefixes
-IfPrefix <- KEYWORD_if LPAREN Expr RPAREN PtrPayload?
-
-WhilePrefix <- KEYWORD_while LPAREN Expr RPAREN PtrPayload? WhileContinueExpr?
-
-ForPrefix <- KEYWORD_for LPAREN ForArgumentsList RPAREN PtrListPayload
-
-# Payloads
-Payload <- PIPE IDENTIFIER PIPE
-
-PtrPayload <- PIPE ASTERISK? IDENTIFIER PIPE
-
-PtrIndexPayload <- PIPE ASTERISK? IDENTIFIER (COMMA IDENTIFIER)? PIPE
-
-PtrListPayload <- PIPE ASTERISK? IDENTIFIER (COMMA ASTERISK? IDENTIFIER)* COMMA? PIPE
-
-# Switch specific
-SwitchProng <- KEYWORD_inline? SwitchCase EQUALRARROW PtrIndexPayload? SingleAssignExpr
-
-SwitchCase
-    <- SwitchItem (COMMA SwitchItem)* COMMA?
-     / KEYWORD_else
-
-SwitchItem <- Expr (DOT3 Expr)?
-
-# For specific
-ForArgumentsList <- ForItem (COMMA ForItem)* COMMA?
-
-ForItem <- Expr (DOT2 Expr?)?
-
-# Operators
-AssignOp
-    <- ASTERISKEQUAL
-     / ASTERISKPIPEEQUAL
-     / SLASHEQUAL
-     / PERCENTEQUAL
-     / PLUSEQUAL
-     / PLUSPIPEEQUAL
-     / MINUSEQUAL
-     / MINUSPIPEEQUAL
-     / LARROW2EQUAL
-     / LARROW2PIPEEQUAL
-     / RARROW2EQUAL
-     / AMPERSANDEQUAL
-     / CARETEQUAL
-     / PIPEEQUAL
-     / ASTERISKPERCENTEQUAL
-     / PLUSPERCENTEQUAL
-     / MINUSPERCENTEQUAL
-     / EQUAL
-
-CompareOp
-    <- EQUALEQUAL
-     / EXCLAMATIONMARKEQUAL
-     / LARROW
-     / RARROW
-     / LARROWEQUAL
-     / RARROWEQUAL
-
-BitwiseOp
-    <- AMPERSAND
-     / CARET
-     / PIPE
-     / KEYWORD_orelse
-     / KEYWORD_catch Payload?
-
-BitShiftOp
-    <- LARROW2
-     / RARROW2
-     / LARROW2PIPE
-
-AdditionOp
-    <- PLUS
-     / MINUS
-     / PLUS2
-     / PLUSPERCENT
-     / MINUSPERCENT
-     / PLUSPIPE
-     / MINUSPIPE
-
-MultiplyOp
-    <- PIPE2
-     / ASTERISK
-     / SLASH
-     / PERCENT
-     / ASTERISKPERCENT
-     / ASTERISKPIPE
-
-PrefixOp
-    <- EXCLAMATIONMARK
-     / MINUS
-     / TILDE
-     / MINUSPERCENT
-     / AMPERSAND
-     / KEYWORD_try
-
-PrefixTypeOp
-    <- QUESTIONMARK
-     / KEYWORD_anyframe MINUSRARROW
-     / (ManyPtrTypeStart / SliceTypeStart) KEYWORD_allowzero? ByteAlign? AddrSpace? KEYWORD_const? KEYWORD_volatile?
-     / SinglePtrTypeStart KEYWORD_allowzero? BitAlign? AddrSpace? KEYWORD_const? KEYWORD_volatile?
-     / ArrayTypeStart
-
-SuffixOp
-    <- LBRACKET Expr (DOT2 Expr? (COLON Expr)?)? RBRACKET
-     / DOT IDENTIFIER
-     / DOTASTERISK
-     / DOTQUESTIONMARK
-
-FnCallArguments <- LPAREN ExprList RPAREN
-
-ExprSuffix
-    <- KEYWORD_or
-     / KEYWORD_and
-     / CompareOp
-     / BitwiseOp
-     / BitShiftOp
-     / AdditionOp
-     / MultiplyOp
-     / EXCLAMATIONMARK
-     / SuffixOp
-     / FnCallArguments
-
-LabelableExpr
-    <- Block
-     / SwitchExpr
-     / LoopExpr
-
-# Ptr specific
-SliceTypeStart <- LBRACKET (COLON Expr)? RBRACKET
-
-SinglePtrTypeStart <- ASTERISK
-
-ManyPtrTypeStart <- LBRACKET ASTERISK (LETTERC / COLON Expr)? RBRACKET
-
-ArrayTypeStart <- LBRACKET Expr !ASTERISK (COLON Expr)? RBRACKET
-
-# ContainerDecl specific
-ContainerDeclAuto <- ContainerDeclType LBRACE ContainerMembers RBRACE
-
-ContainerDeclType
-    <- KEYWORD_struct (LPAREN Expr RPAREN)?
-     / KEYWORD_opaque
-     / KEYWORD_enum (LPAREN Expr RPAREN)?
-     / KEYWORD_union (LPAREN (KEYWORD_enum (LPAREN Expr RPAREN)? / !KEYWORD_enum Expr) RPAREN)?
-
-# Alignment
-ByteAlign <- KEYWORD_align LPAREN Expr RPAREN
-
-BitAlign <- KEYWORD_align LPAREN Expr (COLON Expr COLON Expr)? RPAREN
-
-# Lists
-IdentifierList <- (doc_comment? IDENTIFIER COMMA)* (doc_comment? IDENTIFIER)?
-
-SwitchProngList <- (SwitchProng COMMA)* SwitchProng?
-
-AsmOutputList <- (AsmOutputItem COMMA)* AsmOutputItem?
-
-AsmInputList <- (AsmInputItem COMMA)* AsmInputItem?
-
-ParamDeclList <- (ParamDecl COMMA)* (ParamDecl / DOT3 COMMA?)?
-
-ExprList <- (Expr COMMA)* Expr?
-
-# *** Tokens ***
-eof <- !.
-bin <- [01]
-bin_ <- '_'? bin
-oct <- [0-7]
-oct_ <- '_'? oct
-hex <- [0-9a-fA-F]
-hex_ <- '_'? hex
-dec <- [0-9]
-dec_ <- '_'? dec
-
-bin_int <- bin bin_*
-oct_int <- oct oct_*
-dec_int <- dec dec_*
-hex_int <- hex hex_*
-
-ox80_oxBF <- [\200-\277]
-oxF4 <- '\364'
-ox80_ox8F <- [\200-\217]
-oxF1_oxF3 <- [\361-\363]
-oxF0 <- '\360'
-ox90_0xBF <- [\220-\277]
-oxEE_oxEF <- [\356-\357]
-oxED <- '\355'
-ox80_ox9F <- [\200-\237]
-oxE1_oxEC <- [\341-\354]
-oxE0 <- '\340'
-oxA0_oxBF <- [\240-\277]
-oxC2_oxDF <- [\302-\337]
-
-# From https://lemire.me/blog/2018/05/09/how-quickly-can-you-check-that-a-string-is-valid-unicode-utf-8/
-# First Byte      Second Byte     Third Byte      Fourth Byte
-# [0x00,0x7F]
-# [0xC2,0xDF]     [0x80,0xBF]
-#    0xE0         [0xA0,0xBF]     [0x80,0xBF]
-# [0xE1,0xEC]     [0x80,0xBF]     [0x80,0xBF]
-#    0xED         [0x80,0x9F]     [0x80,0xBF]
-# [0xEE,0xEF]     [0x80,0xBF]     [0x80,0xBF]
-#    0xF0         [0x90,0xBF]     [0x80,0xBF]     [0x80,0xBF]
-# [0xF1,0xF3]     [0x80,0xBF]     [0x80,0xBF]     [0x80,0xBF]
-#    0xF4         [0x80,0x8F]     [0x80,0xBF]     [0x80,0xBF]
-
-multibyte_utf8 <-
-       oxF4      ox80_ox8F ox80_oxBF ox80_oxBF
-     / oxF1_oxF3 ox80_oxBF ox80_oxBF ox80_oxBF
-     / oxF0      ox90_0xBF ox80_oxBF ox80_oxBF
-     / oxEE_oxEF ox80_oxBF ox80_oxBF
-     / oxED      ox80_ox9F ox80_oxBF
-     / oxE1_oxEC ox80_oxBF ox80_oxBF
-     / oxE0      oxA0_oxBF ox80_oxBF
-     / oxC2_oxDF ox80_oxBF
-
-non_control_ascii <- [\040-\176]
-non_control_utf8 <- [\040-\377]
-
-char_escape
-    <- "\\x" hex hex
-     / "\\u{" hex+ "}"
-     / "\\" [nr\\t'"]
-char_char
-    <- multibyte_utf8
-     / char_escape
-     / ![\\'\n] non_control_ascii
-
-string_char
-    <- multibyte_utf8
-     / char_escape
-     / ![\\"\n] non_control_ascii
-
-container_doc_comment <- ('//!' non_control_utf8* [ \n]* skip)+
-doc_comment <- ('///' non_control_utf8* [ \n]* skip)+
-line_comment <- '//' ![!/] non_control_utf8* / '////' non_control_utf8*
-line_string <- '\\\\' non_control_utf8* [ \n]*
-skip <- ([ \n] / line_comment)*
-
-CHAR_LITERAL <- ['] char_char ['] skip
-FLOAT
-    <- '0x' hex_int '.' hex_int ([pP] [-+]? dec_int)? skip
-     /      dec_int '.' dec_int ([eE] [-+]? dec_int)? skip
-     / '0x' hex_int [pP] [-+]? dec_int skip
-     /      dec_int [eE] [-+]? dec_int skip
-INTEGER
-    <- '0b' bin_int skip
-     / '0o' oct_int skip
-     / '0x' hex_int skip
-     /      dec_int   skip
-STRINGLITERALSINGLE <- ["] string_char* ["] skip
-STRINGLITERAL
-    <- STRINGLITERALSINGLE
-     / (line_string                 skip)+
-IDENTIFIER
-    <- !keyword [A-Za-z_] [A-Za-z0-9_]* skip
-     / '@' STRINGLITERALSINGLE
-BUILTINIDENTIFIER <- '@'[A-Za-z_][A-Za-z0-9_]* skip
-
-
-AMPERSAND            <- '&'      ![=]      skip
-AMPERSANDEQUAL       <- '&='               skip
-ASTERISK             <- '*'      ![%=|]    skip
-ASTERISKEQUAL        <- '*='               skip
-ASTERISKPERCENT      <- '*%'     ![=]      skip
-ASTERISKPERCENTEQUAL <- '*%='              skip
-ASTERISKPIPE         <- '*|'     ![=]      skip
-ASTERISKPIPEEQUAL    <- '*|='              skip
-CARET                <- '^'      ![=]      skip
-CARETEQUAL           <- '^='               skip
-COLON                <- ':'                skip
-COMMA                <- ','                skip
-DOT                  <- '.'      ![*.?]    skip
-DOT2                 <- '..'     ![.]      skip
-DOT3                 <- '...'              skip
-DOTASTERISK          <- '.*'               skip
-DOTQUESTIONMARK      <- '.?'               skip
-EQUAL                <- '='      ![>=]     skip
-EQUALEQUAL           <- '=='               skip
-EQUALRARROW          <- '=>'               skip
-EXCLAMATIONMARK      <- '!'      ![=]      skip
-EXCLAMATIONMARKEQUAL <- '!='               skip
-LARROW               <- '<'      ![<=]     skip
-LARROW2              <- '<<'     ![=|]     skip
-LARROW2EQUAL         <- '<<='              skip
-LARROW2PIPE          <- '<<|'    ![=]      skip
-LARROW2PIPEEQUAL     <- '<<|='             skip
-LARROWEQUAL          <- '<='               skip
-LBRACE               <- '{'                skip
-LBRACKET             <- '['                skip
-LPAREN               <- '('                skip
-MINUS                <- '-'      ![%=>|]   skip
-MINUSEQUAL           <- '-='               skip
-MINUSPERCENT         <- '-%'     ![=]      skip
-MINUSPERCENTEQUAL    <- '-%='              skip
-MINUSPIPE            <- '-|'     ![=]      skip
-MINUSPIPEEQUAL       <- '-|='              skip
-MINUSRARROW          <- '->'               skip
-PERCENT              <- '%'      ![=]      skip
-PERCENTEQUAL         <- '%='               skip
-PIPE                 <- '|'      ![|=]     skip
-PIPE2                <- '||'               skip
-PIPEEQUAL            <- '|='               skip
-PLUS                 <- '+'      ![%+=|]   skip
-PLUS2                <- '++'               skip
-PLUSEQUAL            <- '+='               skip
-PLUSPERCENT          <- '+%'     ![=]      skip
-PLUSPERCENTEQUAL     <- '+%='              skip
-PLUSPIPE             <- '+|'     ![=]      skip
-PLUSPIPEEQUAL        <- '+|='              skip
-LETTERC              <- 'c'                skip
-QUESTIONMARK         <- '?'                skip
-RARROW               <- '>'      ![>=]     skip
-RARROW2              <- '>>'     ![=]      skip
-RARROW2EQUAL         <- '>>='              skip
-RARROWEQUAL          <- '>='               skip
-RBRACE               <- '}'                skip
-RBRACKET             <- ']'                skip
-RPAREN               <- ')'                skip
-SEMICOLON            <- ';'                skip
-SLASH                <- '/'      ![=]      skip
-SLASHEQUAL           <- '/='               skip
-TILDE                <- '~'                skip
-
-end_of_word <- ![a-zA-Z0-9_] skip
-KEYWORD_addrspace   <- 'addrspace'   end_of_word
-KEYWORD_align       <- 'align'       end_of_word
-KEYWORD_allowzero   <- 'allowzero'   end_of_word
-KEYWORD_and         <- 'and'         end_of_word
-KEYWORD_anyframe    <- 'anyframe'    end_of_word
-KEYWORD_anytype     <- 'anytype'     end_of_word
-KEYWORD_asm         <- 'asm'         end_of_word
-KEYWORD_break       <- 'break'       end_of_word
-KEYWORD_callconv    <- 'callconv'    end_of_word
-KEYWORD_catch       <- 'catch'       end_of_word
-KEYWORD_comptime    <- 'comptime'    end_of_word
-KEYWORD_const       <- 'const'       end_of_word
-KEYWORD_continue    <- 'continue'    end_of_word
-KEYWORD_defer       <- 'defer'       end_of_word
-KEYWORD_else        <- 'else'        end_of_word
-KEYWORD_enum        <- 'enum'        end_of_word
-KEYWORD_errdefer    <- 'errdefer'    end_of_word
-KEYWORD_error       <- 'error'       end_of_word
-KEYWORD_export      <- 'export'      end_of_word
-KEYWORD_extern      <- 'extern'      end_of_word
-KEYWORD_fn          <- 'fn'          end_of_word
-KEYWORD_for         <- 'for'         end_of_word
-KEYWORD_if          <- 'if'          end_of_word
-KEYWORD_inline      <- 'inline'      end_of_word
-KEYWORD_noalias     <- 'noalias'     end_of_word
-KEYWORD_nosuspend   <- 'nosuspend'   end_of_word
-KEYWORD_noinline    <- 'noinline'    end_of_word
-KEYWORD_opaque      <- 'opaque'      end_of_word
-KEYWORD_or          <- 'or'          end_of_word
-KEYWORD_orelse      <- 'orelse'      end_of_word
-KEYWORD_packed      <- 'packed'      end_of_word
-KEYWORD_pub         <- 'pub'         end_of_word
-KEYWORD_resume      <- 'resume'      end_of_word
-KEYWORD_return      <- 'return'      end_of_word
-KEYWORD_linksection <- 'linksection' end_of_word
-KEYWORD_struct      <- 'struct'      end_of_word
-KEYWORD_suspend     <- 'suspend'     end_of_word
-KEYWORD_switch      <- 'switch'      end_of_word
-KEYWORD_test        <- 'test'        end_of_word
-KEYWORD_threadlocal <- 'threadlocal' end_of_word
-KEYWORD_try         <- 'try'         end_of_word
-KEYWORD_union       <- 'union'       end_of_word
-KEYWORD_unreachable <- 'unreachable' end_of_word
-KEYWORD_var         <- 'var'         end_of_word
-KEYWORD_volatile    <- 'volatile'    end_of_word
-KEYWORD_while       <- 'while'       end_of_word
-
-keyword <- KEYWORD_addrspace / KEYWORD_align / KEYWORD_allowzero / KEYWORD_and
-         / KEYWORD_anyframe / KEYWORD_anytype / KEYWORD_asm
-         / KEYWORD_break / KEYWORD_callconv / KEYWORD_catch
-         / KEYWORD_comptime / KEYWORD_const / KEYWORD_continue / KEYWORD_defer
-         / KEYWORD_else / KEYWORD_enum / KEYWORD_errdefer / KEYWORD_error / KEYWORD_export
-         / KEYWORD_extern / KEYWORD_fn / KEYWORD_for / KEYWORD_if
-         / KEYWORD_inline / KEYWORD_noalias / KEYWORD_nosuspend / KEYWORD_noinline
-         / KEYWORD_opaque / KEYWORD_or / KEYWORD_orelse / KEYWORD_packed
-         / KEYWORD_pub / KEYWORD_resume / KEYWORD_return / KEYWORD_linksection
-         / KEYWORD_struct / KEYWORD_suspend / KEYWORD_switch / KEYWORD_test
-         / KEYWORD_threadlocal / KEYWORD_try / KEYWORD_union / KEYWORD_unreachable
-         / KEYWORD_var / KEYWORD_volatile / KEYWORD_while
-      {#end_syntax_block#}
+      {#grammar#}
       {#header_close#}
       {#header_open|Zen#}
       <ul>
diff --git a/doc/langref/grammar.peg b/doc/langref/grammar.peg
new file mode 100644
index 0000000000000000000000000000000000000000..d56beb04243f42b2c0b9204207a1e0f7aa6c9672
--- /dev/null
+++ b/doc/langref/grammar.peg
@@ -0,0 +1,701 @@
+# This grammar is intended to be LL(k) at the token level.
+# In other words, whenever the parser is required to make a choice it must be
+# able to choose "correctly" with constant token lookahead. This means that the
+# handwritten recursive descent parser for this grammar can be implemented with
+# worst-case linear run time rather than worst-case exponential runtime.
+#
+# To ensure this property is upheld, care must be taken to avoid requiring
+# unbounded token lookahead in the grammar. To illustrate this, consider the
+# following examples requiring unbounded lookahead:
+#
+# This is rather subtle as it looks fine at first glance:
+#
+# SingleAssignExpr <- Expr (AssignOp Expr)?
+#
+# Consider the case where the AssignOp token matches but Expr after it does
+# not match. The parser would attempt to parse the Expr after the AssignOp,
+# fail, then backtrack and succeed the SingleAssignExpr rule matching only
+# the first Expr. This is an example of unbounded lookahead. The rule must
+# be rewritten so that if the AssignOp token is not followed by an Expr the
+# whole SingleAssignExpr rule fails to match:
+#
+# SingleAssignExpr <- Expr (AssignOp Expr / !AssignOp)
+#
+# The pattern is similar for e.g. the * operator. The following rule requires
+# unbounded lookahead:
+#
+# BoolOrExpr <- BoolAndExpr (OrOp BoolAndExpr)*
+#
+# and can be fixed to require only bounded lookahead by adding a !OrOp:
+#
+# BoolOrExpr <- BoolAndExpr (OrOp BoolAndExpr)* !OrOp
+#
+# Note also that the negative lookahead added with the ! operator must always be
+# for a constant maximum number of tokens.
+#
+# See this paper for analysis of how LL(k) grammars relate to PEGs:
+# https://arxiv.org/abs/1304.3177
+
+Root <- ContainerMembers skip eof
+
+# *** Top level ***
+ContainerMembers <- container_doc_comment? ContainerDecl* ContainerMembersRest
+ContainerMembersRest
+    <- !ContainerDeclPrefix ContainerField (COMMA ContainerMembersRest)?
+     / ContainerDecl*
+
+ContainerDecl <- TestDecl / ComptimeDecl / doc_comment? KEYWORD_pub? Decl
+
+ContainerDeclPrefix
+    <- KEYWORD_test
+     / KEYWORD_comptime LBRACE
+     / doc_comment? KEYWORD_pub? DeclPrefix
+
+TestDecl <- KEYWORD_test (STRINGLITERALSINGLE / IDENTIFIER)? Block
+
+ComptimeDecl <- KEYWORD_comptime Block
+
+Decl
+    <- (KEYWORD_export / KEYWORD_inline / KEYWORD_noinline)? FnProto (SEMICOLON / Block)
+     / KEYWORD_extern STRINGLITERALSINGLE? FnProto SEMICOLON
+     / (KEYWORD_export / KEYWORD_extern STRINGLITERALSINGLE?)? KEYWORD_threadlocal? GlobalVarDecl
+
+DeclPrefix
+    <- (KEYWORD_export / KEYWORD_inline / KEYWORD_noinline)? KEYWORD_fn
+     / KEYWORD_extern STRINGLITERALSINGLE? KEYWORD_fn
+     / (KEYWORD_export / KEYWORD_extern STRINGLITERALSINGLE?)? KEYWORD_threadlocal? (KEYWORD_const / KEYWORD_var)
+
+FnProto <- KEYWORD_fn IDENTIFIER? ParamDeclList ByteAlign? AddrSpace? LinkSection? CallConv? EXCLAMATIONMARK? TypeExpr
+
+VarDeclProto <- (KEYWORD_const / KEYWORD_var) IDENTIFIER (COLON TypeExpr)? ByteAlign? AddrSpace? LinkSection?
+
+GlobalVarDecl <- VarDeclProto (EQUAL Expr)? SEMICOLON
+
+ContainerField <- doc_comment? KEYWORD_comptime? (IDENTIFIER COLON)? TypeExpr ByteAlign? (EQUAL Expr)?
+
+# *** Block Level ***
+BlockStatement
+    <- Statement
+     / KEYWORD_defer BlockExprStatement
+     / KEYWORD_errdefer BlockExprStatement
+     / !StatementPrefix KEYWORD_comptime? VarAssignStatement
+
+Statement
+    <- IfStatement
+     / LabeledStatement
+     / KEYWORD_nosuspend BlockExprStatement
+     / KEYWORD_comptime BlockExpr
+     / KEYWORD_suspend BlockExprStatement
+     / !StatementPrefix KEYWORD_comptime? AssignExpr SEMICOLON
+
+StatementPrefix
+    <- KEYWORD_if
+     / BlockLabel? (LBRACE / KEYWORD_inline? (KEYWORD_for / KEYWORD_while) / KEYWORD_switch)
+     / KEYWORD_nosuspend
+     / KEYWORD_comptime BlockExprPrefix
+
+IfStatement
+    <- IfPrefix BlockExpr (KEYWORD_else Payload? Statement / !KEYWORD_else)
+     / IfPrefix !BlockExprPrefix AssignExpr (SEMICOLON / KEYWORD_else Payload? Statement)
+
+LabeledStatement <- BlockLabel? (Block / LoopStatement / SwitchExpr)
+
+LoopStatement <- KEYWORD_inline? (ForStatement / WhileStatement)
+
+ForStatement
+    <- ForPrefix BlockExpr (KEYWORD_else Statement / !KEYWORD_else)
+     / ForPrefix !BlockExprPrefix AssignExpr (SEMICOLON / KEYWORD_else Statement)
+
+WhileStatement
+    <- WhilePrefix BlockExpr (KEYWORD_else Payload? Statement / !KEYWORD_else)
+     / WhilePrefix !BlockExprPrefix AssignExpr (SEMICOLON / KEYWORD_else Payload? Statement)
+
+BlockExprStatement
+    <- BlockExpr
+     / !BlockExprPrefix AssignExpr SEMICOLON
+
+BlockExprPrefix <- BlockLabel? LBRACE
+BlockExpr <- BlockLabel? Block
+
+# An assignment or a destructure whose LHS are all lvalue expressions or variable declarations.
+VarAssignStatement <- (VarDeclProto / Expr) (COMMA (VarDeclProto / Expr))* EQUAL Expr SEMICOLON
+
+# *** Expression Level ***
+
+# An assignment or a destructure whose LHS are all lvalue expressions.
+AssignExpr <- Expr (AssignOp Expr / (COMMA Expr)+ EQUAL Expr / !AssignOp !COMMA)
+
+SingleAssignExpr <- Expr (AssignOp Expr / !AssignOp)
+
+Expr <- BoolOrExpr
+
+BoolOrExpr <- BoolAndExpr (OrOp BoolAndExpr)* !OrOp
+
+BoolAndExpr <- CompareExpr (AndOp CompareExpr)* !AndOp
+
+CompareExpr <- BitwiseExpr (CompareOp BitwiseExpr)? !CompareOp
+
+BitwiseExpr <- BitShiftExpr (BitwiseOp BitShiftExpr)* !BitwiseOp
+
+BitShiftExpr <- AdditionExpr (BitShiftOp AdditionExpr)* !BitShiftOp
+
+AdditionExpr <- MultiplyExpr (AdditionOp MultiplyExpr)* !AdditionOp
+
+MultiplyExpr <- PrefixExpr (MultiplyOp PrefixExpr)* !MultiplyOp
+
+PrefixExpr <- PrefixOp* !PrefixOp PrimaryExpr
+
+PrimaryExpr
+    <- AsmExpr
+     / IfExpr
+     / KEYWORD_break BreakLabel? (Expr / !ExprPrefix)
+     / KEYWORD_comptime Expr
+     / KEYWORD_nosuspend Expr
+     / KEYWORD_continue BreakLabel? (Expr / !ExprPrefix)
+     / KEYWORD_resume Expr
+     / KEYWORD_return (Expr / !ExprPrefix)
+     / BlockLabel? LoopExpr
+     / Block
+     / CurlySuffixExpr
+
+IfExpr <- IfPrefix Expr (KEYWORD_else Payload? Expr / !KEYWORD_else)
+
+Block <- LBRACE BlockStatement* RBRACE
+
+LoopExpr <- KEYWORD_inline? (ForExpr / WhileExpr)
+
+ForExpr <- ForPrefix Expr (KEYWORD_else Expr / !KEYWORD_else)
+
+WhileExpr <- WhilePrefix Expr (KEYWORD_else Payload? Expr)?
+
+CurlySuffixExpr <- TypeExpr (InitList / !LBRACE)
+
+InitList
+    <- LBRACE FieldInit (COMMA FieldInit)* COMMA? RBRACE
+     / LBRACE Expr (COMMA Expr)* COMMA? RBRACE
+     / LBRACE RBRACE
+
+TypeExpr <- PrefixTypeOp* !PrefixTypeOpPrefix ErrorUnionExpr
+
+ErrorUnionExpr <- SuffixExpr (EXCLAMATIONMARK TypeExpr / !EXCLAMATIONMARK)
+
+SuffixExpr <- PrimaryTypeExpr SuffixOp* !SuffixOpPrefix
+
+PrimaryTypeExpr
+    <- BUILTINIDENTIFIER FnCallArguments
+     / CHAR_LITERAL
+     / ContainerType
+     / DOT IDENTIFIER
+     / DOT InitList
+     / ErrorSetDecl
+     / FnProto
+     / GroupedExpr
+     / LabeledTypeExpr
+     / IDENTIFIER
+     / IfTypeExpr
+     / KEYWORD_comptime TypeExpr
+     / KEYWORD_error DOT IDENTIFIER
+     / KEYWORD_anyframe
+     / KEYWORD_unreachable
+     / NUMBERLITERAL
+     / STRINGLITERAL
+
+ContainerType <- (KEYWORD_extern / KEYWORD_packed)? ContainerTypeAuto
+
+ErrorSetDecl <- KEYWORD_error LBRACE IdentifierList RBRACE
+
+GroupedExpr <- LPAREN Expr RPAREN
+
+IfTypeExpr <- IfPrefix TypeExpr (KEYWORD_else Payload? TypeExpr / !KEYWORD_else)
+
+LabeledTypeExpr
+    <- BlockLabel Block
+     / BlockLabel? LoopTypeExpr
+     / BlockLabel? SwitchExpr
+
+LoopTypeExpr <- KEYWORD_inline? (ForTypeExpr / WhileTypeExpr)
+
+ForTypeExpr <- ForPrefix TypeExpr (KEYWORD_else TypeExpr / !KEYWORD_else)
+
+WhileTypeExpr <- WhilePrefix TypeExpr (KEYWORD_else Payload? TypeExpr / !KEYWORD_else)
+
+SwitchExpr <- KEYWORD_switch LPAREN Expr RPAREN LBRACE SwitchProngList RBRACE
+
+# *** Assembly ***
+AsmExpr <- KEYWORD_asm KEYWORD_volatile? LPAREN Expr AsmOutput? RPAREN
+
+AsmOutput <- COLON AsmOutputList AsmInput?
+
+AsmOutputItem <- LBRACKET IDENTIFIER RBRACKET STRINGLITERALSINGLE LPAREN (MINUSRARROW TypeExpr / IDENTIFIER) RPAREN
+
+AsmInput <- COLON AsmInputList AsmClobbers?
+
+AsmInputItem <- LBRACKET IDENTIFIER RBRACKET STRINGLITERALSINGLE LPAREN Expr RPAREN
+
+AsmClobbers <- COLON Expr
+
+# *** Helper grammar ***
+BreakLabel <- COLON IDENTIFIER
+
+BlockLabel <- IDENTIFIER COLON
+
+FieldInit <- DOT IDENTIFIER EQUAL Expr
+
+WhileContinueExpr <- COLON LPAREN AssignExpr RPAREN
+
+LinkSection <- KEYWORD_linksection LPAREN Expr RPAREN
+
+AddrSpace <- KEYWORD_addrspace LPAREN Expr RPAREN
+
+# Fn specific
+CallConv <- KEYWORD_callconv LPAREN Expr RPAREN
+
+ParamDecl <- doc_comment? (KEYWORD_noalias / KEYWORD_comptime?) (IDENTIFIER COLON)? ParamType
+
+ParamType
+    <- KEYWORD_anytype
+     / TypeExpr
+
+# Control flow prefixes
+IfPrefix <- KEYWORD_if LPAREN Expr RPAREN PtrPayload?
+
+WhilePrefix <- KEYWORD_while LPAREN Expr RPAREN PtrPayload? WhileContinueExpr?
+
+ForPrefix <- KEYWORD_for LPAREN ForArgumentsList RPAREN PtrListPayload
+
+# Payloads
+Payload <- PIPE IDENTIFIER PIPE
+
+PtrPayload <- PIPE ASTERISK? IDENTIFIER PIPE
+
+PtrIndexPayload <- PIPE ASTERISK? IDENTIFIER (COMMA IDENTIFIER)? PIPE
+
+PtrListPayload <- PIPE ASTERISK? IDENTIFIER (COMMA ASTERISK? IDENTIFIER)* COMMA? PIPE
+
+# Switch specific
+SwitchProng <- KEYWORD_inline? SwitchCase EQUALRARROW PtrIndexPayload? SingleAssignExpr
+
+SwitchCase
+    <- SwitchItem (COMMA SwitchItem)* COMMA?
+     / KEYWORD_else
+
+SwitchItem <- Expr (DOT3 Expr)?
+
+# For specific
+ForArgumentsList <- ForItem (COMMA ForItem)* COMMA?
+
+ForItem <- Expr (DOT2 (Expr / !ExprPrefix) / !DOT2)
+
+# Operators
+AssignOp
+    <- ASTERISKEQUAL
+     / ASTERISKPIPEEQUAL
+     / SLASHEQUAL
+     / PERCENTEQUAL
+     / PLUSEQUAL
+     / PLUSPIPEEQUAL
+     / MINUSEQUAL
+     / MINUSPIPEEQUAL
+     / LARROW2EQUAL
+     / LARROW2PIPEEQUAL
+     / RARROW2EQUAL
+     / AMPERSANDEQUAL
+     / CARETEQUAL
+     / PIPEEQUAL
+     / ASTERISKPERCENTEQUAL
+     / PLUSPERCENTEQUAL
+     / MINUSPERCENTEQUAL
+     / EQUAL
+
+OrOp <- pre_op_white KEYWORD_or post_op_white
+      / !pre_op_white KEYWORD_or !post_op_white
+
+AndOp <- pre_op_white KEYWORD_and post_op_white
+       / !pre_op_white KEYWORD_and !post_op_white
+
+CompareOp <- pre_op_white CompareOpTok post_op_white
+           / !pre_op_white CompareOpTok !post_op_white
+CompareOpTok
+    <- EQUALEQUAL
+     / EXCLAMATIONMARKEQUAL
+     / LARROW
+     / RARROW
+     / LARROWEQUAL
+     / RARROWEQUAL
+
+BitwiseOp <- pre_op_white BitwiseOpTok post_op_white
+           / !pre_op_white BitwiseOpTok !post_op_white
+           / pre_op_white KEYWORD_catch post_op_white Payload?
+           / !pre_op_white KEYWORD_catch !post_op_white Payload?
+BitwiseOpTok
+    <- AMPERSAND ![&]
+     / CARET
+     / PIPE
+     / KEYWORD_orelse
+
+BitShiftOp <- pre_op_white BitShiftOpTok post_op_white
+           / !pre_op_white BitShiftOpTok !post_op_white
+BitShiftOpTok
+    <- LARROW2
+     / RARROW2
+     / LARROW2PIPE
+
+AdditionOp <- pre_op_white AdditionOpTok post_op_white
+           / !pre_op_white AdditionOpTok !post_op_white
+AdditionOpTok
+    <- PLUS
+     / MINUS
+     / PLUS2
+     / PLUSPERCENT
+     / MINUSPERCENT
+     / PLUSPIPE
+     / MINUSPIPE
+
+MultiplyOp <- pre_op_white MultiplyOpTok post_op_white
+           / !pre_op_white MultiplyOpTok !post_op_white
+MultiplyOpTok
+    <- PIPE2
+     / ASTERISK
+     / SLASH
+     / PERCENT
+     / ASTERISKPERCENT
+     / ASTERISKPIPE
+
+PrefixOp
+    <- EXCLAMATIONMARK
+     / MINUS
+     / TILDE
+     / MINUSPERCENT
+     / AMPERSAND
+     / KEYWORD_try
+
+PrefixTypeOp
+    <- QUESTIONMARK
+     / KEYWORD_anyframe MINUSRARROW
+     / (ManyPtrTypeStart / SliceTypeStart) PtrMods
+     / SinglePtrTypeStart SinglePtrMods
+     / ArrayTypeStart
+
+# Forbid more than one align or addrspace pointer modifier since these
+# modifiers contain sub-expressions. This allows for a simpler AST data layout.
+# Allow duplicate single-token modifiers (allowzero/const/volatile) in the grammar
+# to avoid the combinatorial explosion of grammar rules necessary to forbid duplicates
+# while permitting arbitrary order. A compile error for duplicates single-token modifiers
+# is emitted during "AstGen" after parsing is complete.
+PtrMods
+   <- PtrMod* !KEYWORD_addrspace ByteAlign? PtrMod* AddrSpace? PtrMod*
+    / PtrMod* !KEYWORD_align AddrSpace? PtrMod* ByteAlign? PtrMod*
+
+SinglePtrMods
+   <- PtrMod* !KEYWORD_addrspace BitAlign? PtrMod* AddrSpace? PtrMod*
+    / PtrMod* !KEYWORD_align AddrSpace? PtrMod* BitAlign? PtrMod*
+
+PtrMod
+    <- KEYWORD_allowzero
+     / KEYWORD_const
+     / KEYWORD_volatile
+
+PrefixTypeOpPrefix
+    <- QUESTIONMARK
+     / KEYWORD_anyframe MINUSRARROW
+     / LBRACKET
+     / ASTERISK
+
+SuffixOp
+    <- LBRACKET Expr (DOT2 (Expr / !ExprPrefix) (COLON Expr)?)? RBRACKET
+     / DOT IDENTIFIER
+     / DOTASTERISK
+     / DOT QUESTIONMARK
+     / FnCallArguments
+
+SuffixOpPrefix
+    <- LBRACKET
+     / DOT IDENTIFIER
+     / DOTASTERISK
+     / DOT QUESTIONMARK
+     / LPAREN
+
+FnCallArguments <- LPAREN ExprList RPAREN
+
+# Ptr specific
+SliceTypeStart <- LBRACKET (COLON Expr)? RBRACKET
+
+SinglePtrTypeStart <- ASTERISK
+
+ManyPtrTypeStart <- LBRACKET ASTERISK (LETTERC / COLON Expr)? RBRACKET
+
+ArrayTypeStart <- LBRACKET !ASTERISK Expr (COLON Expr)? RBRACKET
+
+# ContainerType specific
+ContainerTypeAuto <- ContainerTypeKind LBRACE ContainerMembers RBRACE
+
+ContainerTypeKind
+    <- KEYWORD_struct (LPAREN Expr RPAREN)?
+     / KEYWORD_opaque
+     / KEYWORD_enum (LPAREN Expr RPAREN)?
+     / KEYWORD_union (LPAREN (KEYWORD_enum (LPAREN Expr RPAREN)? / Expr) RPAREN)?
+
+# Alignment
+ByteAlign <- KEYWORD_align LPAREN Expr RPAREN
+
+BitAlign <- KEYWORD_align LPAREN Expr (COLON Expr COLON Expr)? RPAREN
+
+# Lists
+IdentifierList <- (doc_comment? IDENTIFIER (COMMA IdentifierList)?)?
+
+SwitchProngList <- (SwitchProng (COMMA SwitchProngList)?)?
+
+AsmOutputList <- (AsmOutputItem (COMMA AsmOutputList)?)?
+
+AsmInputList <- (AsmInputItem (COMMA AsmInputList)?)?
+
+ParamDeclList <- LPAREN ParamDeclListRest
+ParamDeclListRest
+    <- RPAREN
+     / DOT3 COMMA? RPAREN
+     / ParamDecl (COMMA ParamDeclListRest / RPAREN)
+
+ExprList <- Expr (COMMA ExprList)? / !ExprPrefix
+
+ExprPrefix <- ASTERISK
+
+# *** Tokens ***
+
+# https://en.wikipedia.org/wiki/Byte_order_mark
+byte_order_mark <- '\357\273\277'
+
+# Unfortunately, there is not a standard way to match the start of the file in PEG.
+# This rule definition is compatible with the original peg(1) tool but is not
+# portable. It is however trivial to implement an equivalent rule in hand written
+# parsers and other PEG tooling should have similar mechanisms.
+sof <- &{ (yy->__pos == 0) } byte_order_mark?
+eof <- !.
+
+ox80_oxBF <- [\200-\277]
+oxF4 <- '\364'
+ox80_ox8F <- [\200-\217]
+oxF1_oxF3 <- [\361-\363]
+oxF0 <- '\360'
+ox90_0xBF <- [\220-\277]
+oxEE_oxEF <- [\356-\357]
+oxED <- '\355'
+ox80_ox9F <- [\200-\237]
+oxE1_oxEC <- [\341-\354]
+oxE0 <- '\340'
+oxA0_oxBF <- [\240-\277]
+oxC2_oxDF <- [\302-\337]
+
+# From https://lemire.me/blog/2018/05/09/how-quickly-can-you-check-that-a-string-is-valid-unicode-utf-8/
+# First Byte      Second Byte     Third Byte      Fourth Byte
+# [0x00,0x7F]
+# [0xC2,0xDF]     [0x80,0xBF]
+#    0xE0         [0xA0,0xBF]     [0x80,0xBF]
+# [0xE1,0xEC]     [0x80,0xBF]     [0x80,0xBF]
+#    0xED         [0x80,0x9F]     [0x80,0xBF]
+# [0xEE,0xEF]     [0x80,0xBF]     [0x80,0xBF]
+#    0xF0         [0x90,0xBF]     [0x80,0xBF]     [0x80,0xBF]
+# [0xF1,0xF3]     [0x80,0xBF]     [0x80,0xBF]     [0x80,0xBF]
+#    0xF4         [0x80,0x8F]     [0x80,0xBF]     [0x80,0xBF]
+
+multibyte_utf8 <-
+       oxF4      ox80_ox8F ox80_oxBF ox80_oxBF
+     / oxF1_oxF3 ox80_oxBF ox80_oxBF ox80_oxBF
+     / oxF0      ox90_0xBF ox80_oxBF ox80_oxBF
+     / oxEE_oxEF ox80_oxBF ox80_oxBF
+     / oxED      ox80_ox9F ox80_oxBF
+     / oxE1_oxEC ox80_oxBF ox80_oxBF
+     / oxE0      oxA0_oxBF ox80_oxBF
+     / oxC2_oxDF ox80_oxBF
+
+# Exclude \177 which is DEL
+non_control_ascii <- [\040-\176]
+non_control_utf8 <- [\040-\176\200-\377]
+
+# XXX: the Zig tokenizer doesn't yet perform UTF-8 validation
+# When the tokenizer is fixed, switch back to these definitions
+# that forbid invalid UTF-8:
+#
+# char_char
+#     <- multibyte_utf8
+#      / "\\\\"
+#      / "\\'"
+#      / !['] non_control_ascii
+# string_char
+#     <- multibyte_utf8
+#      / '\\\\'
+#      / '\\"'
+#      / !["] non_control_ascii
+
+char_char
+    <- "\\\\"
+     / "\\'"
+     / !['] non_control_utf8
+
+string_char
+    <- '\\\\'
+     / '\\"'
+     / !["] non_control_utf8
+
+
+container_doc_comment <- (skip '//!' non_control_utf8* newline)+
+# We forbid same-line doc comments to disambiguate the mapping to e.g. struct
+# fields for documentation generation tooling.
+doc_comment <- (sof / skip_require_newline) (skip '///' non_control_utf8* newline)+
+line_comment
+    <- '//' ![!/] non_control_utf8* newline
+     / '////' non_control_utf8* newline
+line_string <- '\\\\' non_control_utf8* newline
+
+# This uses a positive lookahead rather than consuming input to make e.g.
+# the newline terminating a multiline string literal or doc comment visible
+# to the pre_op_white non-terminal.
+newline <- &("\n" / "\r\n" / eof)
+skip <- sof? ([ \n\t\r] / line_comment)*
+skip_require_newline <- [ \t\r]* ([\n] / line_comment) skip
+pre_op_white <- ([ \n\t\r] / line_comment)+
+post_op_white <- [ \n\t\r] skip
+
+CHAR_LITERAL <- skip ['] char_char* [']
+
+digit <- [_0-9A-DF-OQ-Za-df-oq-z]
+digit_int <- digit / [eEpP]
+digit_float <- digit / [eEpP] [-+]?
+NUMBERLITERAL
+    <- skip [0-9] digit_int* '.' digit_float+
+     / skip [0-9] digit_float*
+
+
+string <- ["] string_char* ["]
+STRINGLITERALSINGLE <- skip string
+STRINGLITERAL
+    <- skip string
+     / (skip line_string)+
+IDENTIFIER
+    <- skip !keyword [A-Za-z_] [A-Za-z0-9_]*
+     / skip '@' string
+BUILTINIDENTIFIER <- skip '@'[A-Za-z_][A-Za-z0-9_]*
+
+
+AMPERSAND            <- skip '&'      ![=]
+AMPERSANDEQUAL       <- skip '&='
+ASTERISK             <- skip '*'      ![%=|]
+ASTERISKEQUAL        <- skip '*='
+ASTERISKPERCENT      <- skip '*%'     ![=]
+ASTERISKPERCENTEQUAL <- skip '*%='
+ASTERISKPIPE         <- skip '*|'     ![=]
+ASTERISKPIPEEQUAL    <- skip '*|='
+CARET                <- skip '^'      ![=]
+CARETEQUAL           <- skip '^='
+COLON                <- skip ':'
+COMMA                <- skip ','
+DOT                  <- skip '.'      ![*.]
+DOT2                 <- skip '..'     ![.]
+DOT3                 <- skip '...'
+DOTASTERISK          <- skip '.*'
+EQUAL                <- skip '='      ![>=]
+EQUALEQUAL           <- skip '=='
+EQUALRARROW          <- skip '=>'
+EXCLAMATIONMARK      <- skip '!'      ![=]
+EXCLAMATIONMARKEQUAL <- skip '!='
+LARROW               <- skip '<'      ![<=]
+LARROW2              <- skip '<<'     ![=|]
+LARROW2EQUAL         <- skip '<<='
+LARROW2PIPE          <- skip '<<|'    ![=]
+LARROW2PIPEEQUAL     <- skip '<<|='
+LARROWEQUAL          <- skip '<='
+LBRACE               <- skip '{'
+LBRACKET             <- skip '['
+LPAREN               <- skip '('
+MINUS                <- skip '-'      ![%=>|]
+MINUSEQUAL           <- skip '-='
+MINUSPERCENT         <- skip '-%'     ![=]
+MINUSPERCENTEQUAL    <- skip '-%='
+MINUSPIPE            <- skip '-|'     ![=]
+MINUSPIPEEQUAL       <- skip '-|='
+MINUSRARROW          <- skip '->'
+PERCENT              <- skip '%'      ![=]
+PERCENTEQUAL         <- skip '%='
+PIPE                 <- skip '|'      ![|=]
+PIPE2                <- skip '||'
+PIPEEQUAL            <- skip '|='
+PLUS                 <- skip '+'      ![%+=|]
+PLUS2                <- skip '++'
+PLUSEQUAL            <- skip '+='
+PLUSPERCENT          <- skip '+%'     ![=]
+PLUSPERCENTEQUAL     <- skip '+%='
+PLUSPIPE             <- skip '+|'     ![=]
+PLUSPIPEEQUAL        <- skip '+|='
+LETTERC              <- skip 'c'
+QUESTIONMARK         <- skip '?'
+RARROW               <- skip '>'      ![>=]
+RARROW2              <- skip '>>'     ![=]
+RARROW2EQUAL         <- skip '>>='
+RARROWEQUAL          <- skip '>='
+RBRACE               <- skip '}'
+RBRACKET             <- skip ']'
+RPAREN               <- skip ')'
+SEMICOLON            <- skip ';'
+SLASH                <- skip '/'      ![=/]
+SLASHEQUAL           <- skip '/='
+TILDE                <- skip '~'
+
+end_of_word <- ![a-zA-Z0-9_]
+KEYWORD_addrspace   <- skip 'addrspace'   end_of_word
+KEYWORD_align       <- skip 'align'       end_of_word
+KEYWORD_allowzero   <- skip 'allowzero'   end_of_word
+KEYWORD_and         <- skip 'and'         end_of_word
+KEYWORD_anyframe    <- skip 'anyframe'    end_of_word
+KEYWORD_anytype     <- skip 'anytype'     end_of_word
+KEYWORD_asm         <- skip 'asm'         end_of_word
+KEYWORD_break       <- skip 'break'       end_of_word
+KEYWORD_callconv    <- skip 'callconv'    end_of_word
+KEYWORD_catch       <- skip 'catch'       end_of_word
+KEYWORD_comptime    <- skip 'comptime'    end_of_word
+KEYWORD_const       <- skip 'const'       end_of_word
+KEYWORD_continue    <- skip 'continue'    end_of_word
+KEYWORD_defer       <- skip 'defer'       end_of_word
+KEYWORD_else        <- skip 'else'        end_of_word
+KEYWORD_enum        <- skip 'enum'        end_of_word
+KEYWORD_errdefer    <- skip 'errdefer'    end_of_word
+KEYWORD_error       <- skip 'error'       end_of_word
+KEYWORD_export      <- skip 'export'      end_of_word
+KEYWORD_extern      <- skip 'extern'      end_of_word
+KEYWORD_fn          <- skip 'fn'          end_of_word
+KEYWORD_for         <- skip 'for'         end_of_word
+KEYWORD_if          <- skip 'if'          end_of_word
+KEYWORD_inline      <- skip 'inline'      end_of_word
+KEYWORD_noalias     <- skip 'noalias'     end_of_word
+KEYWORD_nosuspend   <- skip 'nosuspend'   end_of_word
+KEYWORD_noinline    <- skip 'noinline'    end_of_word
+KEYWORD_opaque      <- skip 'opaque'      end_of_word
+KEYWORD_or          <- skip 'or'          end_of_word
+KEYWORD_orelse      <- skip 'orelse'      end_of_word
+KEYWORD_packed      <- skip 'packed'      end_of_word
+KEYWORD_pub         <- skip 'pub'         end_of_word
+KEYWORD_resume      <- skip 'resume'      end_of_word
+KEYWORD_return      <- skip 'return'      end_of_word
+KEYWORD_linksection <- skip 'linksection' end_of_word
+KEYWORD_struct      <- skip 'struct'      end_of_word
+KEYWORD_suspend     <- skip 'suspend'     end_of_word
+KEYWORD_switch      <- skip 'switch'      end_of_word
+KEYWORD_test        <- skip 'test'        end_of_word
+KEYWORD_threadlocal <- skip 'threadlocal' end_of_word
+KEYWORD_try         <- skip 'try'         end_of_word
+KEYWORD_union       <- skip 'union'       end_of_word
+KEYWORD_unreachable <- skip 'unreachable' end_of_word
+KEYWORD_var         <- skip 'var'         end_of_word
+KEYWORD_volatile    <- skip 'volatile'    end_of_word
+KEYWORD_while       <- skip 'while'       end_of_word
+
+keyword <- KEYWORD_addrspace / KEYWORD_align / KEYWORD_allowzero / KEYWORD_and
+         / KEYWORD_anyframe / KEYWORD_anytype / KEYWORD_asm
+         / KEYWORD_break / KEYWORD_callconv / KEYWORD_catch
+         / KEYWORD_comptime / KEYWORD_const / KEYWORD_continue / KEYWORD_defer
+         / KEYWORD_else / KEYWORD_enum / KEYWORD_errdefer / KEYWORD_error / KEYWORD_export
+         / KEYWORD_extern / KEYWORD_fn / KEYWORD_for / KEYWORD_if
+         / KEYWORD_inline / KEYWORD_noalias / KEYWORD_nosuspend / KEYWORD_noinline
+         / KEYWORD_opaque / KEYWORD_or / KEYWORD_orelse / KEYWORD_packed
+         / KEYWORD_pub / KEYWORD_resume / KEYWORD_return / KEYWORD_linksection
+         / KEYWORD_struct / KEYWORD_suspend / KEYWORD_switch / KEYWORD_test
+         / KEYWORD_threadlocal / KEYWORD_try / KEYWORD_union / KEYWORD_unreachable
+         / KEYWORD_var / KEYWORD_volatile / KEYWORD_while
diff --git a/lib/compiler/Maker.zig b/lib/compiler/Maker.zig
index ad73ac16272d6848bbe4234f88ba833bb4bbaa7e..7a16501777c835283b394664453fb2d214aeb0d8 100644
--- a/lib/compiler/Maker.zig
+++ b/lib/compiler/Maker.zig
@@ -3536,7 +3536,7 @@ fn loadManifest(
             else => |e| fatal("unable to load {s}: {t}", .{ Package.Manifest.basename, e }),
         };
     };
-    var ast = try std.zig.Ast.parse(gpa, manifest_bytes, .zon);
+    var ast = try std.zig.Ast.parse(gpa, manifest_bytes, .zon, .{});
     errdefer ast.deinit(gpa);
 
     if (ast.errors.len > 0) {
diff --git a/lib/compiler/Maker/Package/Manifest.zig b/lib/compiler/Maker/Package/Manifest.zig
index 849fc742ec5c7b5be02a2895f54f99fece02b2ff..cabcb9852549a3600919df36e5cbc7693bfeed3e 100644
--- a/lib/compiler/Maker/Package/Manifest.zig
+++ b/lib/compiler/Maker/Package/Manifest.zig
@@ -597,7 +597,7 @@ pub fn load(
         0,
     );
 
-    ast.* = try std.zig.Ast.parse(arena, manifest_bytes, .zon);
+    ast.* = try std.zig.Ast.parse(arena, manifest_bytes, .zon, .{});
 
     if (ast.errors.len > 0) {
         const file_path = try manifest_path.joinString(arena, "");
@@ -636,7 +636,7 @@ test "basic" {
         \\}
     ;
 
-    var ast = try Ast.parse(gpa, example, .zon);
+    var ast = try Ast.parse(gpa, example, .zon, .{});
     defer ast.deinit(gpa);
 
     try testing.expect(ast.errors.len == 0);
@@ -682,7 +682,7 @@ test "minimum_zig_version" {
         \\}
     ;
 
-    var ast = try Ast.parse(gpa, example, .zon);
+    var ast = try Ast.parse(gpa, example, .zon, .{});
     defer ast.deinit(gpa);
 
     try testing.expect(ast.errors.len == 0);
@@ -717,7 +717,7 @@ test "minimum_zig_version - invalid version" {
         \\}
     ;
 
-    var ast = try Ast.parse(gpa, example, .zon);
+    var ast = try Ast.parse(gpa, example, .zon, .{});
     defer ast.deinit(gpa);
 
     try testing.expect(ast.errors.len == 0);
diff --git a/lib/compiler/reduce.zig b/lib/compiler/reduce.zig
index 8d4f270a7946ca32ae04aa996df91a1decc22743..df4675ff47bdf42812c026a1f61cd1edc47b544b 100644
--- a/lib/compiler/reduce.zig
+++ b/lib/compiler/reduce.zig
@@ -188,7 +188,7 @@ pub fn main(init: std.process.Init) !void {
                 try astgen_input.writer.writeAll(rendered.written());
                 try astgen_input.writer.writeByte(0);
                 const source_with_null = astgen_input.written()[0..(astgen_input.written().len - 1) :0];
-                var astgen_tree = try Ast.parse(gpa, source_with_null, .zig);
+                var astgen_tree = try Ast.parse(gpa, source_with_null, .zig, .{});
                 defer astgen_tree.deinit(gpa);
                 if (astgen_tree.errors.len != 0) {
                     @panic("syntax errors occurred");
@@ -407,7 +407,7 @@ fn parse(gpa: Allocator, io: Io, file_path: []const u8) !Ast {
     };
     errdefer gpa.free(source_code);
 
-    var tree = try Ast.parse(gpa, source_code, .zig);
+    var tree = try Ast.parse(gpa, source_code, .zig, .{});
     errdefer tree.deinit(gpa);
 
     if (tree.errors.len != 0) {
diff --git a/lib/docs/wasm/Walk.zig b/lib/docs/wasm/Walk.zig
index 2d5a45d72f739abb1d763bea3d6804b3ee53859d..779ed163485a147338b5c1e4a44b252ee3071064 100644
--- a/lib/docs/wasm/Walk.zig
+++ b/lib/docs/wasm/Walk.zig
@@ -428,7 +428,7 @@ fn parse(file_name: []const u8, source: []u8) Oom!Ast {
         break :s source[0 .. source.len - 1 :0];
     };
 
-    var ast = try Ast.parse(gpa, adjusted_source, .zig);
+    var ast = try Ast.parse(gpa, adjusted_source, .zig, .{});
     if (ast.errors.len > 0) {
         defer ast.deinit(gpa);
 
@@ -446,7 +446,7 @@ fn parse(file_name: []const u8, source: []u8) Oom!Ast {
                 file_name, err_loc.line + 1, err_loc.column + 1, rendered_err.written(),
             });
         }
-        return Ast.parse(gpa, "", .zig);
+        return Ast.parse(gpa, "", .zig, .{});
     }
     return ast;
 }
@@ -1085,7 +1085,7 @@ pub fn isPrimitiveNonType(name: []const u8) bool {
 //
 //    // example test command:
 //    // zig test --dep input.zig -Mroot=src/Walk.zig -Minput.zig=/home/andy/dev/zig/lib/std/fs/File/zig
-//    var ast = try Ast.parse(gpa, @embedFile("input.zig"), .zig);
+//    var ast = try Ast.parse(gpa, @embedFile("input.zig"), .zig, .{});
 //    defer ast.deinit(gpa);
 //
 //    var w: Walk = .{
diff --git a/lib/std/zig.zig b/lib/std/zig.zig
index 64228b0de3ed9fa1a7cf921afdd300aab88fc344..3568ecf4d32886675b4b075112c285acbed84329 100644
--- a/lib/std/zig.zig
+++ b/lib/std/zig.zig
@@ -29,7 +29,6 @@ pub const primitives = @import("zig/primitives.zig");
 pub const isPrimitive = primitives.isPrimitive;
 pub const Ast = @import("zig/Ast.zig");
 pub const AstGen = @import("zig/AstGen.zig");
-pub const AstSmith = @import("zig/AstSmith.zig");
 pub const Zir = @import("zig/Zir.zig");
 pub const Zoir = @import("zig/Zoir.zig");
 pub const ZonGen = @import("zig/ZonGen.zig");
@@ -43,6 +42,8 @@ pub const PkgConfig = @import("zig/PkgConfig.zig");
 pub const target = @import("zig/target.zig");
 pub const llvm = @import("zig/llvm.zig");
 
+pub const parser_generated_oracle = @import("zig/parser_generated_oracle.zig");
+
 // Character literal parsing
 pub const ParsedCharLiteral = string_literal.ParsedCharLiteral;
 pub const parseCharLiteral = string_literal.parseCharLiteral;
@@ -1863,7 +1864,6 @@ fn readStreamAlloc(gpa: Allocator, io: Io, file: Io.File, limit: Io.Limit) ![]u8
 test {
     _ = Ast;
     _ = AstRlAnnotate;
-    _ = AstSmith;
     _ = BuiltinFn;
     _ = Client;
     _ = ErrorBundle;
@@ -1879,4 +1879,5 @@ test {
     _ = target;
     _ = c_translation;
     _ = llvm;
+    _ = @import("zig/parser_fuzz.zig");
 }
diff --git a/lib/std/zig/Ast.zig b/lib/std/zig/Ast.zig
index 372823324ee4205c31b15cf145d4c2b9b055fe42..9a09f027d91f70d077cde861148bb951d06877b8 100644
--- a/lib/std/zig/Ast.zig
+++ b/lib/std/zig/Ast.zig
@@ -139,10 +139,13 @@ pub fn deinit(tree: *Ast, gpa: Allocator) void {
 }
 
 pub const Mode = enum { zig, zon };
+pub const ParseOptions = struct {
+    recover: bool = true,
+};
 
 /// Result should be freed with tree.deinit() when there are
 /// no more references to any of the tokens or nodes.
-pub fn parse(gpa: Allocator, source: [:0]const u8, mode: Mode) Allocator.Error!Ast {
+pub fn parse(gpa: Allocator, source: [:0]const u8, mode: Mode, options: ParseOptions) Allocator.Error!Ast {
     var tokens = Ast.TokenList{};
     defer tokens.deinit(gpa);
 
@@ -162,7 +165,7 @@ pub fn parse(gpa: Allocator, source: [:0]const u8, mode: Mode) Allocator.Error!A
 
     var tokens_slice = tokens.toOwnedSlice();
     errdefer tokens_slice.deinit(gpa);
-    return parseTokens(gpa, source, tokens_slice, mode);
+    return parseTokens(gpa, source, tokens_slice, mode, options);
 }
 
 pub fn parseTokens(
@@ -170,6 +173,7 @@ pub fn parseTokens(
     source: [:0]const u8,
     tokens: Ast.TokenList.Slice,
     mode: Mode,
+    options: ParseOptions,
 ) Allocator.Error!Ast {
     var parser: Parse = .{
         .source = source,
@@ -180,6 +184,7 @@ pub fn parseTokens(
         .extra_data = .empty,
         .scratch = .empty,
         .tok_i = 0,
+        .recover = options.recover,
     };
     defer parser.errors.deinit(gpa);
     defer parser.nodes.deinit(gpa);
@@ -465,15 +470,6 @@ pub fn renderError(tree: Ast, parse_error: Error, w: *Writer) Writer.Error!void
         .extra_align_qualifier => {
             return w.writeAll("extra align qualifier");
         },
-        .extra_allowzero_qualifier => {
-            return w.writeAll("extra allowzero qualifier");
-        },
-        .extra_const_qualifier => {
-            return w.writeAll("extra const qualifier");
-        },
-        .extra_volatile_qualifier => {
-            return w.writeAll("extra volatile qualifier");
-        },
         .ptr_mod_on_array_child_type => {
             return w.print("pointer modifier '{s}' not allowed on array child type", .{
                 tree.tokenTag(parse_error.token).symbol(),
@@ -559,12 +555,6 @@ pub fn renderError(tree: Ast, parse_error: Error, w: *Writer) Writer.Error!void
         .var_const_decl => {
             return w.writeAll("use 'var' or 'const' to declare variable");
         },
-        .extra_for_capture => {
-            return w.writeAll("extra capture in for loop");
-        },
-        .for_input_not_captured => {
-            return w.writeAll("for input is not captured");
-        },
 
         .invalid_byte => {
             const tok_slice = tree.source[tree.tokens.items(.start)[parse_error.token]..];
@@ -2116,6 +2106,7 @@ fn fullPtrTypeComponents(tree: Ast, info: full.PtrType.Components) full.PtrType
         .allowzero_token = null,
         .const_token = null,
         .volatile_token = null,
+        .duplicate_token = null,
         .ast = info,
     };
     // We need to be careful that we don't iterate over any sub-expressions
@@ -2131,9 +2122,24 @@ fn fullPtrTypeComponents(tree: Ast, info: full.PtrType.Components) full.PtrType
     const end = tree.firstToken(info.child_type);
     while (i < end) : (i += 1) {
         switch (tree.tokenTag(i)) {
-            .keyword_allowzero => result.allowzero_token = i,
-            .keyword_const => result.const_token = i,
-            .keyword_volatile => result.volatile_token = i,
+            .keyword_allowzero => {
+                if (result.allowzero_token != null) {
+                    result.duplicate_token = i;
+                }
+                result.allowzero_token = i;
+            },
+            .keyword_const => {
+                if (result.const_token != null) {
+                    result.duplicate_token = i;
+                }
+                result.const_token = i;
+            },
+            .keyword_volatile => {
+                if (result.volatile_token != null) {
+                    result.duplicate_token = i;
+                }
+                result.volatile_token = i;
+            },
             .keyword_align => {
                 if (info.bit_range_end.unwrap()) |bit_range_end| {
                     assert(info.bit_range_start != .none);
@@ -2730,6 +2736,7 @@ pub const full = struct {
         allowzero_token: ?TokenIndex,
         const_token: ?TokenIndex,
         volatile_token: ?TokenIndex,
+        duplicate_token: ?TokenIndex,
         ast: Components,
 
         pub const Components = struct {
@@ -2863,9 +2870,6 @@ pub const Error = struct {
         extern_fn_body,
         extra_addrspace_qualifier,
         extra_align_qualifier,
-        extra_allowzero_qualifier,
-        extra_const_qualifier,
-        extra_volatile_qualifier,
         ptr_mod_on_array_child_type,
         invalid_bit_range,
         same_line_doc_comment,
@@ -2889,8 +2893,6 @@ pub const Error = struct {
         expected_var_const,
         wrong_equal_var_decl,
         var_const_decl,
-        extra_for_capture,
-        for_input_not_captured,
 
         zig_style_container,
         previous_field,
diff --git a/lib/std/zig/AstGen.zig b/lib/std/zig/AstGen.zig
index 46aa2fea1231792ad4c8ec64c6f167c9340a0fdd..19057918cea3abe07d8adc61a73062c88d853b14 100644
--- a/lib/std/zig/AstGen.zig
+++ b/lib/std/zig/AstGen.zig
@@ -3746,6 +3746,9 @@ fn ptrType(
     if (ptr_info.size == .c and ptr_info.allowzero_token != null) {
         return gz.astgen.failTok(ptr_info.allowzero_token.?, "C pointers always allow address zero", .{});
     }
+    if (ptr_info.duplicate_token) |duplicate| {
+        return gz.astgen.failTok(duplicate, "Extra pointer qualifier", .{});
+    }
 
     const source_offset = gz.astgen.source_offset;
     const source_line = gz.astgen.source_line;
@@ -6709,6 +6712,9 @@ fn forExpr(
         for (for_full.ast.inputs, indexables, lens) |input, *indexable_ref, *len_refs| {
             const capture_is_ref = tree.tokenTag(capture_token) == .asterisk;
             const ident_tok = capture_token + @intFromBool(capture_is_ref);
+            if (tree.tokenTag(ident_tok) != .identifier) {
+                return astgen.failNode(input, "for input is not captured", .{});
+            }
             const is_discard = mem.eql(u8, tree.tokenSlice(ident_tok), "_");
 
             if (is_discard and capture_is_ref) {
@@ -6751,6 +6757,10 @@ fn forExpr(
                 len_refs.* = .{ indexable, .none };
             }
         }
+        // There may or may not be a trailing comma after the final capture
+        if (tree.tokenTag(capture_token) != .pipe and tree.tokenTag(capture_token - 1) != .pipe) {
+            return astgen.failTok(capture_token, "extra capture in for loop", .{});
+        }
     }
 
     if (!any_len_checks) {
diff --git a/lib/std/zig/AstSmith.zig b/lib/std/zig/AstSmith.zig
deleted file mode 100644
index 87cfc0ccf25a19890d263c9dd8726ec9c209ed2a..0000000000000000000000000000000000000000
--- a/lib/std/zig/AstSmith.zig
+++ /dev/null
@@ -1,2595 +0,0 @@
-//! Generates a valid AST and corresponding source.
-//!
-//! This is based directly off grammer.peg
-
-const std = @import("../std.zig");
-const assert = std.debug.assert;
-const Token = std.zig.Token;
-const Smith = std.testing.Smith;
-const Weight = Smith.Weight;
-const AstSmith = @This();
-
-smith: *Smith,
-
-source_buf: [16384]u8,
-source_len: usize,
-
-token_tag_buf: [2048]Token.Tag,
-token_start_buf: [2048]std.zig.Ast.ByteOffset,
-tokens_len: usize,
-
-not_token: ?Token.Tag,
-not_token_comptime: bool,
-/// ExprSuffix
-///     <- KEYWORD_or
-///      / KEYWORD_and
-///      / CompareOp
-///      / BitwiseOp
-///      / BitShiftOp
-///      / AdditionOp
-///      / MultiplyOp
-///      / EXCLAMATIONMARK
-///      / SuffixOp
-///      / FnCallArguments
-not_expr_suffix: bool,
-/// LabelableExpr
-///   <- Block
-///    / SwitchExpr
-///    / LoopExpr
-not_labelable_expr: ?enum { colon, expr },
-not_label: bool,
-not_break_label: bool,
-not_block_expr: bool,
-not_expr_statement: bool,
-
-prev_ids_buf: [256]struct { start: u16, len: u16 },
-/// This may be larger than `prev_ids` in which case,
-///   x % prev_ids.len = next index
-///   @min(x, prev_ids) = length
-prev_ids_len: usize,
-
-/// `generate` must be called on the returned value before any other methods
-pub fn init(smith: *Smith) AstSmith {
-    return .{
-        .smith = smith,
-
-        .source_buf = undefined,
-        .source_len = 0,
-
-        .token_tag_buf = undefined,
-        .token_start_buf = undefined,
-        .tokens_len = 0,
-
-        .not_token = null,
-        .not_token_comptime = false,
-        .not_expr_suffix = false,
-        .not_labelable_expr = null,
-        .not_label = false,
-        .not_break_label = false,
-        .not_block_expr = false,
-        .not_expr_statement = false,
-
-        .prev_ids_buf = undefined,
-        .prev_ids_len = 0,
-    };
-}
-
-pub fn source(t: *AstSmith) [:0]u8 {
-    return t.source_buf[0..t.source_len :0];
-}
-
-/// The Slice is not backed by a MultiArrayList, so calling deinit or toMultiArrayList is illegal.
-pub fn tokens(t: *AstSmith) std.zig.Ast.TokenList.Slice {
-    var slice: std.zig.Ast.TokenList.Slice = .{
-        .ptrs = undefined,
-        .len = t.tokens_len,
-        .capacity = t.tokens_len,
-    };
-    comptime assert(slice.ptrs.len == 2);
-    slice.ptrs[@intFromEnum(std.zig.Ast.TokenList.Field.tag)] = @ptrCast(&t.token_tag_buf);
-    slice.ptrs[@intFromEnum(std.zig.Ast.TokenList.Field.start)] = @ptrCast(&t.token_start_buf);
-    return slice;
-}
-
-pub const Error = error{ OutOfMemory, SkipZigTest };
-const SourceError = error{SkipZigTest};
-
-pub fn generate(a: *AstSmith, gpa: std.mem.Allocator) Error!std.zig.Ast {
-    try a.generateSource();
-    const ast = try std.zig.Ast.parseTokens(gpa, a.source(), a.tokens(), .zig);
-    assert(ast.errors.len == 0);
-    return ast;
-}
-
-pub fn generateSource(a: *AstSmith) SourceError!void {
-    try a.pegRoot();
-    try a.ensureSourceCapacity(1);
-    a.source_buf[a.source_len] = 0;
-    try a.addTokenTag(.eof);
-}
-
-/// For choices which can introduce a variable number of expressions, this should be used to reduce
-/// unbounded recursion.
-//
-// `inline` to propogate caller's return address
-inline fn smithListItemBool(a: *AstSmith) bool {
-    return a.smith.boolWeighted(63, 1);
-}
-
-/// For choices which can introduce a variable number of expressions, this should be used to reduce
-/// unbounded recursion.
-//
-// `inline` to propogate caller's return address
-inline fn smithListItemEos(a: *AstSmith) bool {
-    return a.smith.eosWeightedSimple(1, 63);
-}
-
-fn sourceCapacity(a: *AstSmith) []u8 {
-    return a.source_buf[a.source_len..];
-}
-
-fn sourceCapacityLen(a: *AstSmith) usize {
-    return a.source_buf.len - a.source_len;
-}
-
-fn ensureSourceCapacity(a: *AstSmith, n: usize) SourceError!void {
-    if (a.sourceCapacityLen() < n) return error.SkipZigTest;
-}
-
-fn addSourceByte(a: *AstSmith, byte: u8) SourceError!void {
-    try a.ensureSourceCapacity(1);
-    a.addSourceByteAssumeCapacity(byte);
-}
-
-fn addSourceByteAssumeCapacity(a: *AstSmith, byte: u8) void {
-    a.sourceCapacity()[0] = byte;
-    a.source_len += 1;
-}
-
-fn addSource(a: *AstSmith, bytes: []const u8) SourceError!void {
-    try a.ensureSourceCapacity(bytes.len);
-    a.addSourceAssumeCapacity(bytes);
-}
-
-fn addSourceAssumeCapacity(a: *AstSmith, bytes: []const u8) void {
-    @memcpy(a.sourceCapacity()[0..bytes.len], bytes);
-    a.source_len += bytes.len;
-}
-
-fn addSourceAsSlice(a: *AstSmith, len: usize) SourceError![]u8 {
-    try a.ensureSourceCapacity(len);
-    return a.addSourceAsSliceAssumeCapacity(len);
-}
-
-fn addSourceAsSliceAssumeCapacity(a: *AstSmith, len: usize) []u8 {
-    const slice = a.sourceCapacity()[0..len];
-    a.source_len += len;
-    return slice;
-}
-
-fn tokenCapacityLen(a: *AstSmith) usize {
-    return a.token_tag_buf.len - a.tokens_len;
-}
-
-fn ensureTokenCapacity(a: *AstSmith, n: usize) SourceError!void {
-    if (a.tokenCapacityLen() < n) return error.SkipZigTest;
-}
-
-fn isAlphanumeric(c: u8) bool {
-    return switch (c) {
-        '_', 'a'...'z', 'A'...'Z', '0'...'9' => true,
-        else => false,
-    };
-}
-
-/// For tokens starting with alphanumerics, this ensures
-/// previous tokens followed by end_of_word aren't altered.
-///
-/// end_of_word <- ![a-zA-Z0-9_] skip
-fn preservePegEndOfWord(a: *AstSmith) SourceError!void {
-    if (a.source_len > 0 and isAlphanumeric(a.source_buf[a.source_len - 1])) {
-        try a.addSourceByte(' ');
-    }
-}
-
-/// Assumes the token has not been written yet
-fn addTokenTag(a: *AstSmith, tag: Token.Tag) SourceError!void {
-    assert(tag != a.not_token);
-    a.not_token = null;
-
-    if (a.not_token_comptime) assert(tag != .keyword_comptime);
-    a.not_token_comptime = false;
-
-    if (a.not_label and tag == .identifier) {
-        a.not_token = .colon;
-    }
-    a.not_label = false;
-
-    if (a.not_break_label and tag == .colon) {
-        a.not_token = .identifier;
-    }
-    a.not_break_label = false;
-
-    if (a.not_labelable_expr) |part| switch (part) {
-        .colon => a.not_labelable_expr = if (tag == .colon) .expr else null,
-        .expr => switch (tag) {
-            .l_brace => unreachable,
-            .keyword_inline => {},
-            .keyword_for => unreachable,
-            .keyword_while => unreachable,
-            .keyword_switch => unreachable,
-            else => a.not_labelable_expr = null,
-        },
-    };
-
-    a.not_expr_suffix = false;
-    a.not_block_expr = false;
-    a.not_expr_statement = false;
-
-    try a.ensureTokenCapacity(1);
-    a.token_tag_buf[a.tokens_len] = tag;
-    a.token_start_buf[a.tokens_len] = @intCast(a.source_len);
-    a.tokens_len += 1;
-}
-
-/// Asserts the token has a lexeme (those without have corresponding methods)
-fn pegToken(a: *AstSmith, tag: Token.Tag) SourceError!void {
-    const lexeme = tag.lexeme().?;
-
-    switch (lexeme[0]) {
-        '_', 'a'...'z', 'A'...'Z', '0'...'9' => try a.preservePegEndOfWord(),
-        '.' => if (a.tokens_len > 0 and switch (a.source_buf[a.source_len - 1]) {
-            '.' => true,
-            '0'...'9', 'a'...'z', 'A'...'Z' => a.token_tag_buf[a.tokens_len - 1] == .number_literal,
-            else => false,
-        }) {
-            try a.addSourceByte(' ');
-        },
-        '+', '-' => if (a.tokens_len > 0 and a.token_tag_buf[a.tokens_len - 1] == .number_literal and
-            switch (a.source_buf[a.source_len - 1]) {
-                'e', 'E', 'p', 'P' => true,
-                else => false,
-            })
-        {
-            // Would otherwise be tokenized as the sign of a float's exponent
-            //
-            // e.g. "0xFE" ++ "+" ++ "2" (number_literal, plus, number_literal)
-            try a.addSourceByte(' ');
-        },
-        else => {},
-    }
-
-    if (isAlphanumeric(lexeme[0])) try a.preservePegEndOfWord();
-
-    try a.addTokenTag(tag);
-    try a.addSource(lexeme);
-    try a.pegSkip();
-}
-
-/// Asserts `a.source_len != 0`
-fn pegTokenWhitespaceAround(a: *AstSmith, tag: Token.Tag) SourceError!void {
-    switch (a.source_buf[a.source_len - 1]) {
-        ' ', '\n' => {},
-        else => try a.addSourceByte(' '),
-    }
-    try a.addTokenTag(tag);
-    try a.addSource(tag.lexeme().?);
-    switch (a.smith.value(enum { space, line_break, cr_line_break })) {
-        // This is not the same as 'skip' since comments are not whitespace
-        .space => try a.addSourceByte(' '),
-        .line_break => try a.addSourceByte('\n'),
-        .cr_line_break => try a.addSource("\r\n"),
-    }
-    try a.pegSkip();
-}
-
-/// Root <- skip ContainerMembers eof
-fn pegRoot(a: *AstSmith) SourceError!void {
-    try a.pegSkip();
-    try a.pegContainerMembers();
-}
-
-/// ContainerMembers <- container_doc_comment? ContainerDeclaration* (ContainerField COMMA)*
-///                     (ContainerField / ContainerDeclaration*)
-fn pegContainerMembers(a: *AstSmith) SourceError!void {
-    if (a.smith.boolWeighted(63, 1)) {
-        try a.pegContainerDocComment();
-    }
-    while (!a.smithListItemEos()) {
-        try a.pegContainerDeclaration();
-    }
-    while (!a.smithListItemEos()) {
-        try a.pegContainerField();
-        try a.pegToken(.comma);
-    }
-    if (a.smithListItemBool()) {
-        if (a.smith.value(bool)) {
-            try a.pegContainerField();
-        } else while (true) {
-            try a.pegContainerDeclaration();
-            if (a.smithListItemEos()) break;
-        }
-    }
-}
-
-/// ContainerDeclaration <- TestDecl / ComptimeDecl / doc_comment? KEYWORD_pub? Decl
-fn pegContainerDeclaration(a: *AstSmith) SourceError!void {
-    switch (a.smith.value(enum { TestDecl, ComptimeDecl, Decl })) {
-        .TestDecl => try a.pegTestDecl(),
-        .ComptimeDecl => try a.pegComptimeDecl(),
-        .Decl => {
-            try a.pegMaybeDocComment();
-            if (a.smith.value(bool)) {
-                try a.pegToken(.keyword_pub);
-            }
-            try a.pegDecl();
-        },
-    }
-}
-
-/// KEYWORD_test (STRINGLITERALSINGLE / IDENTIFIER)? Block
-fn pegTestDecl(a: *AstSmith) SourceError!void {
-    try a.pegToken(.keyword_test);
-    switch (a.smith.value(enum { none, string, id })) {
-        .none => {},
-        .string => try a.pegStringLiteralSingle(),
-        .id => try a.pegIdentifier(),
-    }
-    try a.pegBlock();
-}
-
-/// ComptimeDecl <- KEYWORD_comptime Block
-fn pegComptimeDecl(a: *AstSmith) SourceError!void {
-    try a.pegToken(.keyword_comptime);
-    try a.pegBlock();
-}
-
-/// Decl
-///    <- (KEYWORD_export / KEYWORD_inline / KEYWORD_noinline)? FnProto (SEMICOLON / Block)
-///     / KEYWORD_extern STRINGLITERALSINGLE? FnProto SEMICOLON
-///     / (KEYWORD_export / KEYWORD_extern STRINGLITERALSINGLE?)? KEYWORD_threadlocal?
-///     GlobalVarDecl
-fn pegDecl(a: *AstSmith) SourceError!void {
-    const Modifier = enum(u8) {
-        none,
-        @"export",
-        @"extern",
-        extern_library,
-        @"inline",
-        @"noinline",
-    };
-    const is_fn = a.smith.value(bool);
-    const fn_modifiers = Smith.baselineWeights(Modifier);
-    const var_modifiers: []const Weight = &.{.rangeAtMost(Modifier, .none, .extern_library, 1)};
-    const modifier = a.smith.valueWeighted(Modifier, if (is_fn) fn_modifiers else var_modifiers);
-
-    switch (modifier) {
-        .none => {},
-        .@"export" => try a.pegToken(.keyword_export),
-        .@"extern" => try a.pegToken(.keyword_extern),
-        .extern_library => {
-            try a.pegToken(.keyword_extern);
-            try a.pegStringLiteralSingle();
-        },
-        .@"inline" => try a.pegToken(.keyword_inline),
-        .@"noinline" => try a.pegToken(.keyword_noinline),
-    }
-
-    if (is_fn) {
-        try a.pegFnProto();
-        if (modifier == .@"extern" or modifier == .extern_library or a.smith.value(bool)) {
-            try a.pegToken(.semicolon);
-        } else {
-            try a.pegBlock();
-        }
-    } else {
-        if (a.smith.value(bool)) try a.pegToken(.keyword_threadlocal);
-        try a.pegGlobalVarDecl();
-    }
-}
-
-/// FnProto <- KEYWORD_fn IDENTIFIER? LPAREN ParamDeclList RPAREN ByteAlign? AddrSpace?
-///          LinkSection? CallConv? EXCLAMATIONMARK? TypeExpr !ExprSuffix
-fn pegFnProto(a: *AstSmith) SourceError!void {
-    try a.pegToken(.keyword_fn);
-    if (a.smith.value(bool)) {
-        try a.pegIdentifier();
-    }
-    try a.pegToken(.l_paren);
-    try a.pegParamDeclList();
-    try a.pegToken(.r_paren);
-    if (a.smith.value(bool)) {
-        try a.pegByteAlign();
-    }
-    if (a.smith.value(bool)) {
-        try a.pegAddrSpace();
-    }
-    if (a.smith.value(bool)) {
-        try a.pegLinkSection();
-    }
-    if (a.smith.value(bool)) {
-        try a.pegCallConv();
-    }
-    if (a.smith.value(bool)) {
-        try a.pegToken(.bang);
-    }
-    try a.pegTypeExpr();
-    a.not_expr_suffix = true;
-}
-
-/// VarDeclProto <- (KEYWORD_const / KEYWORD_var) IDENTIFIER (COLON TypeExpr)? ByteAlign?
-///               AddrSpace? LinkSection?
-fn pegVarDeclProto(a: *AstSmith) SourceError!void {
-    try a.pegToken(if (a.smith.value(bool)) .keyword_var else .keyword_const);
-    try a.pegIdentifier();
-
-    if (a.smith.value(bool)) {
-        try a.pegToken(.colon);
-        try a.pegTypeExpr();
-    }
-
-    if (a.smith.value(bool)) {
-        try a.pegByteAlign();
-    }
-
-    if (a.smith.value(bool)) {
-        try a.pegAddrSpace();
-    }
-
-    if (a.smith.value(bool)) {
-        try a.pegLinkSection();
-    }
-}
-
-/// GlobalVarDecl <- VarDeclProto (EQUAL Expr)? SEMICOLON
-fn pegGlobalVarDecl(a: *AstSmith) SourceError!void {
-    try a.pegVarDeclProto();
-    if (a.smithListItemBool()) {
-        try a.pegToken(.equal);
-        try a.pegExpr();
-    }
-    try a.pegToken(.semicolon);
-}
-
-/// ContainerField <- doc_comment? (KEYWORD_comptime / !KEYWORD_comptime) !KEYWORD_fn
-///                 (IDENTIFIER COLON !(IDENTIFIER COLON)) TypeExpr ByteAlign? (EQUAL Expr)?
-fn pegContainerField(a: *AstSmith) SourceError!void {
-    try a.pegMaybeDocComment();
-    if (a.smith.value(bool)) {
-        try a.pegToken(.keyword_comptime);
-    }
-    if (a.smith.value(bool)) {
-        try a.pegIdentifier();
-        try a.pegToken(.colon);
-    } else {
-        a.not_token = .keyword_fn;
-        a.not_token_comptime = true;
-        a.not_label = true;
-    }
-    try a.pegTypeExpr();
-    if (a.smith.value(bool)) {
-        try a.pegByteAlign();
-    }
-    if (a.smith.value(bool)) {
-        try a.pegToken(.equal);
-        try a.pegExpr();
-    }
-}
-
-/// BlockStatement
-///     <- Statement
-///      / KEYWORD_defer BlockExprStatement
-///      / KEYWORD_errdefer BlockExprStatement
-///      / !ExprStatement (KEYWORD_comptime !BlockExpr)? VarAssignStatement
-fn pegBlockStatement(a: *AstSmith) SourceError!void {
-    const Kind = enum {
-        statement,
-        defer_statement,
-        errdefer_statement,
-        var_assign,
-        comptime_var_assign,
-    };
-    const weights = Smith.baselineWeights(Kind) ++ &[1]Weight{.value(Kind, .statement, 4)};
-    switch (a.smith.valueWeighted(Kind, weights)) {
-        .statement => try a.pegStatement(),
-        .defer_statement, .errdefer_statement => |kind| {
-            try a.pegToken(switch (kind) {
-                .defer_statement => .keyword_defer,
-                .errdefer_statement => .keyword_errdefer,
-                else => unreachable,
-            });
-            try a.pegBlockExprStatement();
-        },
-        .var_assign, .comptime_var_assign => |kind| {
-            a.not_expr_statement = true;
-            if (kind == .comptime_var_assign) {
-                try a.pegToken(.keyword_comptime);
-                a.not_block_expr = true;
-            }
-            try a.pegVarAssignStatement();
-        },
-    }
-}
-
-/// Statement
-///     <- ExprStatement
-///      / KEYWORD_suspend BlockExprStatement
-///      / !ExprStatement (KEYWORD_comptime !BlockExpr)? AssignExpr SEMICOLON
-///
-/// ExprStatement
-///     <- IfStatement
-///      / LabeledStatement
-///      / KEYWORD_nosuspend BlockExprStatement
-///      / KEYWORD_comptime BlockExpr
-fn pegStatement(a: *AstSmith) SourceError!void {
-    switch (a.smith.value(enum {
-        if_statement,
-        labeled_statement,
-        comptime_block_expr,
-
-        nosuspend_statement,
-        suspend_statement,
-        assign_expr,
-        comptime_assign_expr,
-    })) {
-        .if_statement => try a.pegIfStatement(),
-        .labeled_statement => try a.pegLabeledStatement(),
-        .comptime_block_expr => {
-            try a.pegToken(.keyword_comptime);
-            try a.pegBlockExpr();
-        },
-
-        .nosuspend_statement,
-        .suspend_statement,
-        => |kind| {
-            try a.pegToken(switch (kind) {
-                .nosuspend_statement => .keyword_nosuspend,
-                .suspend_statement => .keyword_suspend,
-                else => unreachable,
-            });
-            try a.pegBlockExprStatement();
-        },
-        .assign_expr, .comptime_assign_expr => |kind| {
-            a.not_expr_statement = true;
-            if (kind == .comptime_assign_expr) {
-                try a.pegToken(.keyword_comptime);
-                a.not_block_expr = true;
-            }
-            try a.pegAssignExpr();
-            try a.pegToken(.semicolon);
-        },
-    }
-}
-
-/// IfStatement
-///     <- IfPrefix BlockExpr ( KEYWORD_else Payload? Statement )?
-///      / IfPrefix !BlockExpr AssignExpr ( SEMICOLON / KEYWORD_else Payload? Statement )
-fn pegIfStatement(a: *AstSmith) SourceError!void {
-    try a.pegIfPrefix();
-    const is_assign = a.smith.value(bool);
-    if (!is_assign) {
-        try a.pegBlockExpr();
-    } else {
-        a.not_block_expr = true;
-        try a.pegAssignExpr();
-    }
-    if (a.not_token != .keyword_else and a.smithListItemBool()) {
-        try a.pegToken(.keyword_else);
-        if (a.smith.value(bool)) {
-            try a.pegPayload();
-        }
-        try a.pegStatement();
-    } else if (is_assign) {
-        try a.pegToken(.semicolon);
-    } else {
-        a.not_token = .keyword_else;
-    }
-}
-
-/// LabeledStatement <- BlockLabel? (Block / LoopStatement / SwitchExpr)
-fn pegLabeledStatement(a: *AstSmith) SourceError!void {
-    if (a.smith.value(bool)) {
-        try a.pegBlockLabel();
-    }
-    switch (a.smith.value(enum { block, loop_statement, switch_expr })) {
-        .block => try a.pegBlock(),
-        .loop_statement => try a.pegLoopStatement(),
-        .switch_expr => try a.pegSwitchExpr(),
-    }
-}
-
-/// LoopStatement <- KEYWORD_inline? (ForStatement / WhileStatement)
-fn pegLoopStatement(a: *AstSmith) SourceError!void {
-    if (a.smith.value(bool)) {
-        try a.pegToken(.keyword_inline);
-    }
-    if (a.smith.value(bool)) {
-        try a.pegForStatement();
-    } else {
-        try a.pegWhileStatement();
-    }
-}
-
-/// ForStatement
-///     <- ForPrefix BlockExpr ( KEYWORD_else Statement / !KEYWORD_else )
-///      / ForPrefix !BlockExpr AssignExpr ( SEMICOLON / KEYWORD_else Statement )
-fn pegForStatement(a: *AstSmith) SourceError!void {
-    try a.pegForPrefix();
-    const is_assign = a.smith.value(bool);
-    if (!is_assign) {
-        try a.pegBlockExpr();
-    } else {
-        a.not_block_expr = true;
-        try a.pegAssignExpr();
-    }
-    if (a.not_token != .keyword_else and a.smithListItemBool()) {
-        try a.pegToken(.keyword_else);
-        try a.pegStatement();
-    } else if (is_assign) {
-        try a.pegToken(.semicolon);
-    } else {
-        a.not_token = .keyword_else;
-    }
-}
-
-/// WhileStatement
-///     <- WhilePrefix BlockExpr ( KEYWORD_else Payload? Statement )?
-///      / WhilePrefix !BlockExpr AssignExpr ( SEMICOLON / KEYWORD_else Payload? Statement )
-fn pegWhileStatement(a: *AstSmith) SourceError!void {
-    try a.pegWhilePrefix();
-    const is_assign = a.smith.value(bool);
-    if (!is_assign) {
-        try a.pegBlockExpr();
-    } else {
-        a.not_block_expr = true;
-        try a.pegAssignExpr();
-    }
-    if (a.not_token != .keyword_else and a.smithListItemBool()) {
-        try a.pegToken(.keyword_else);
-        if (a.smith.value(bool)) {
-            try a.pegPayload();
-        }
-        try a.pegStatement();
-    } else if (is_assign) {
-        try a.pegToken(.semicolon);
-    } else {
-        a.not_token = .keyword_else;
-    }
-}
-
-/// BlockExprStatement
-///     <- BlockExpr
-///      / !BlockExpr AssignExpr SEMICOLON
-fn pegBlockExprStatement(a: *AstSmith) SourceError!void {
-    if (a.smith.value(bool)) {
-        try a.pegBlockExpr();
-    } else {
-        a.not_block_expr = true;
-        try a.pegAssignExpr();
-        try a.pegToken(.semicolon);
-    }
-}
-
-/// BlockExpr <- BlockLabel? Block
-fn pegBlockExpr(a: *AstSmith) SourceError!void {
-    if (a.smith.value(bool)) {
-        try a.pegBlockLabel();
-    }
-    try a.pegBlock();
-}
-
-/// VarAssignStatement <- (Expr / VarDeclProto) (COMMA (Expr / VarDeclProto))* EQUAL Expr SEMICOLON
-fn pegVarAssignStatement(a: *AstSmith) SourceError!void {
-    while (true) {
-        if (a.smith.value(bool)) {
-            try a.pegVarDeclProto();
-        } else {
-            try a.pegExpr();
-        }
-
-        if (a.smithListItemEos()) {
-            break;
-        } else {
-            try a.pegToken(.comma);
-        }
-    }
-
-    try a.pegToken(.equal);
-    try a.pegExpr();
-    try a.pegToken(.semicolon);
-}
-
-/// AssignExpr <- Expr (AssignOp Expr / (COMMA Expr)+ EQUAL Expr)?
-fn pegAssignExpr(a: *AstSmith) SourceError!void {
-    try a.pegExpr();
-    if (a.smith.value(bool)) {
-        if (!a.smithListItemBool()) {
-            try a.pegAssignOp();
-        } else {
-            while (true) {
-                try a.pegToken(.comma);
-                try a.pegExpr();
-                if (a.smithListItemEos()) break;
-            }
-            try a.pegToken(.equal);
-        }
-        try a.pegExpr();
-    }
-}
-
-/// SingleAssignExpr <- Expr (AssignOp Expr)?
-fn pegSingleAssignExpr(a: *AstSmith) SourceError!void {
-    try a.pegExpr();
-    if (a.smith.value(bool)) {
-        try a.pegAssignOp();
-        try a.pegExpr();
-    }
-}
-
-/// Expr <- BoolOrExpr
-const pegExpr = pegBoolOrExpr;
-
-/// BoolOrExpr <- BoolAndExpr (KEYWORD_or BoolAndExpr)*
-fn pegBoolOrExpr(a: *AstSmith) SourceError!void {
-    try a.pegBoolAndExpr();
-    while (!a.not_expr_suffix and !a.smithListItemEos()) {
-        try a.pegTokenWhitespaceAround(.keyword_or);
-        try a.pegBoolAndExpr();
-    }
-}
-
-/// BoolAndExpr <- CompareExpr (KEYWORD_and CompareExpr)*
-fn pegBoolAndExpr(a: *AstSmith) SourceError!void {
-    try a.pegCompareExpr();
-    while (!a.not_expr_suffix and !a.smithListItemEos()) {
-        try a.pegTokenWhitespaceAround(.keyword_and);
-        try a.pegCompareExpr();
-    }
-}
-
-/// CompareExpr <- BitwiseExpr (CompareOp BitwiseExpr)?
-fn pegCompareExpr(a: *AstSmith) SourceError!void {
-    try a.pegBitwiseExpr();
-    if (!a.not_expr_suffix and a.smithListItemBool()) {
-        try a.pegCompareOp();
-        try a.pegBitwiseExpr();
-    }
-}
-
-/// BitwiseExpr <- BitShiftExpr (BitwiseOp BitShiftExpr)*
-fn pegBitwiseExpr(a: *AstSmith) SourceError!void {
-    try a.pegBitShiftExpr();
-    while (!a.not_expr_suffix and !a.smithListItemEos()) {
-        try a.pegBitwiseOp();
-        try a.pegBitShiftExpr();
-    }
-}
-
-/// BitShiftExpr <- AdditionExpr (BitShiftOp AdditionExpr)*
-fn pegBitShiftExpr(a: *AstSmith) SourceError!void {
-    try a.pegAdditionExpr();
-    while (!a.not_expr_suffix and !a.smithListItemEos()) {
-        try a.pegBitShiftOp();
-        try a.pegAdditionExpr();
-    }
-}
-
-/// AdditionExpr <- MultiplyExpr (AdditionOp MultiplyExpr)*
-fn pegAdditionExpr(a: *AstSmith) SourceError!void {
-    try a.pegMultiplyExpr();
-    while (!a.not_expr_suffix and !a.smithListItemEos()) {
-        try a.pegAdditionOp();
-        try a.pegMultiplyExpr();
-    }
-}
-
-/// MultiplyExpr <- PrefixExpr (MultiplyOp PrefixExpr)*
-fn pegMultiplyExpr(a: *AstSmith) SourceError!void {
-    try a.pegPrefixExpr();
-    while (!a.not_expr_suffix and !a.smithListItemEos()) {
-        try a.pegMultiplyOp();
-        try a.pegPrefixExpr();
-    }
-}
-
-/// PrefixExpr <- PrefixOp* PrimaryExpr
-fn pegPrefixExpr(a: *AstSmith) SourceError!void {
-    while (!a.smithListItemEos()) {
-        try a.pegPrefixOp();
-    }
-    try a.pegPrimaryExpr();
-}
-
-/// PrimaryExpr
-///     <- AsmExpr
-///      / IfExpr
-///      / KEYWORD_break (BreakLabel / !BreakLabel) (Expr !ExprSuffix / !SinglePtrTypeStart)
-///      / KEYWORD_comptime Expr !ExprSuffix
-///      / KEYWORD_nosuspend Expr !ExprSuffix
-///      / KEYWORD_continue (BreakLabel / !BreakLabel) (Expr !ExprSuffix / !SinglePtrTypeStart)
-///      / KEYWORD_resume Expr !ExprSuffix
-///      / KEYWORD_return (Expr !ExprSuffix / !SinglePtrTypeStart)
-///      / BlockLabel? LoopExpr
-///      / Block
-///      / CurlySuffixExpr
-fn pegPrimaryExpr(a: *AstSmith) SourceError!void {
-    const Kind = enum(u8) {
-        curly_suffix_expr,
-        @"return",
-        @"continue",
-        @"break",
-        block,
-        asm_expr,
-        // Always contain more expressions
-        if_expr,
-        loop_expr,
-        @"resume",
-        @"comptime",
-        @"nosuspend",
-    };
-
-    switch (a.smith.valueWeighted(Kind, &.{
-        .value(Kind, .curly_suffix_expr, 75),
-        .rangeAtMost(Kind, .@"return", .asm_expr, 4),
-        .rangeAtMost(Kind, .if_expr, .@"nosuspend", 1),
-    })) {
-        .curly_suffix_expr => try a.pegCurlySuffixExpr(),
-
-        .block => if (a.not_labelable_expr != .expr and !a.not_block_expr and !a.not_expr_statement) {
-            try a.pegBlock();
-        } else {
-            // Group
-            try a.pegToken(.l_paren);
-            try a.pegBlock();
-            try a.pegToken(.r_paren);
-        },
-        .asm_expr => try a.pegAsmExpr(),
-        .if_expr => if (!a.not_expr_statement) {
-            try a.pegIfExpr();
-        } else {
-            // Group
-            try a.pegToken(.l_paren);
-            try a.pegIfExpr();
-            try a.pegToken(.r_paren);
-        },
-        .loop_expr => {
-            const group = a.not_labelable_expr == .expr or a.not_expr_statement;
-            if (group) try a.pegToken(.l_paren);
-            if (!a.not_label and a.not_token != .identifier and a.smith.value(bool)) {
-                try a.pegBlockLabel();
-            }
-            try a.pegLoopExpr();
-            if (group) try a.pegToken(.r_paren);
-        },
-
-        .@"return",
-        .@"comptime",
-        .@"nosuspend",
-        .@"resume",
-        .@"break",
-        .@"continue",
-        => |t| {
-            const group = a.not_expr_statement and (t == .@"nosuspend" or t == .@"comptime");
-            if (group) try a.pegToken(.l_paren);
-
-            const kw: Token.Tag, const label, const expr = switch (t) {
-                .@"return" => .{ .keyword_return, false, a.smithListItemBool() },
-                .@"comptime" => .{ .keyword_comptime, false, true },
-                .@"nosuspend" => .{ .keyword_nosuspend, false, true },
-                .@"resume" => .{ .keyword_resume, false, true },
-                .@"break" => .{ .keyword_break, a.smith.value(bool), a.smithListItemBool() },
-                .@"continue" => .{ .keyword_continue, a.smith.value(bool), a.smithListItemBool() },
-                else => unreachable,
-            };
-            try a.pegToken(kw);
-            if (label) {
-                try a.pegBreakLabel();
-            } else {
-                a.not_break_label = true;
-            }
-            if (expr) {
-                try a.pegExpr();
-                a.not_expr_suffix = true;
-            } else {
-                a.not_token = .asterisk;
-            }
-
-            if (group) try a.pegToken(.r_paren);
-        },
-    }
-}
-
-/// IfExpr <- IfPrefix Expr (KEYWORD_else Payload? Expr)? !ExprSuffix
-fn pegIfExpr(a: *AstSmith) SourceError!void {
-    try a.pegIfPrefix();
-    try a.pegExpr();
-    const Else = enum { none, @"else", else_payload };
-    switch (if (a.not_token != .keyword_else) a.smith.value(Else) else .none) {
-        .none => a.not_token = .keyword_else,
-        .@"else" => {
-            try a.pegToken(.keyword_else);
-            try a.pegExpr();
-        },
-        .else_payload => {
-            try a.pegToken(.keyword_else);
-            try a.pegPayload();
-            try a.pegExpr();
-        },
-    }
-    a.not_expr_suffix = true;
-}
-
-/// Block <- LBRACE Statement* RBRACE
-fn pegBlock(a: *AstSmith) SourceError!void {
-    try a.pegToken(.l_brace);
-    while (!a.smithListItemEos()) {
-        try a.pegBlockStatement();
-    }
-    try a.pegToken(.r_brace);
-}
-
-/// LoopExpr <- KEYWORD_inline? (ForExpr / WhileExpr)
-fn pegLoopExpr(a: *AstSmith) SourceError!void {
-    if (a.smith.value(bool)) {
-        try a.pegToken(.keyword_inline);
-    }
-
-    if (a.smith.value(bool)) {
-        try a.pegForExpr();
-    } else {
-        try a.pegWhileExpr();
-    }
-}
-
-/// ForExpr <- ForPrefix Expr (KEYWORD_else Expr / !KEYWORD_else) !ExprSuffix
-fn pegForExpr(a: *AstSmith) SourceError!void {
-    try a.pegForPrefix();
-    try a.pegExpr();
-    if (a.not_token != .keyword_else and a.smith.value(bool)) {
-        try a.pegToken(.keyword_else);
-        try a.pegExpr();
-    } else {
-        a.not_token = .keyword_else;
-    }
-    a.not_expr_suffix = true;
-}
-
-/// WhileExpr <- WhilePrefix Expr (KEYWORD_else Payload? Expr)? !ExprSuffix
-fn pegWhileExpr(a: *AstSmith) SourceError!void {
-    try a.pegWhilePrefix();
-    try a.pegExpr();
-    const Else = enum { none, @"else", else_payload };
-    switch (if (a.not_token != .keyword_else) a.smith.value(Else) else .none) {
-        .none => a.not_token = .keyword_else,
-        .@"else" => {
-            try a.pegToken(.keyword_else);
-            try a.pegExpr();
-        },
-        .else_payload => {
-            try a.pegToken(.keyword_else);
-            try a.pegPayload();
-            try a.pegExpr();
-        },
-    }
-    a.not_expr_suffix = true;
-}
-
-/// CurlySuffixExpr <- TypeExpr InitList?
-fn pegCurlySuffixExpr(a: *AstSmith) SourceError!void {
-    try a.pegTypeExpr();
-    if (!a.not_expr_suffix and a.smith.value(bool)) {
-        try a.pegInitList();
-    }
-}
-
-/// InitList
-///     <- LBRACE FieldInit (COMMA FieldInit)* COMMA? RBRACE
-///      / LBRACE Expr (COMMA Expr)* COMMA? RBRACE
-///      / LBRACE RBRACE
-fn pegInitList(a: *AstSmith) SourceError!void {
-    try a.pegToken(.l_brace);
-    if (a.smithListItemBool()) {
-        if (a.smith.value(bool)) {
-            try a.pegFieldInit();
-            while (!a.smithListItemEos()) {
-                try a.pegToken(.comma);
-                try a.pegFieldInit();
-            }
-        } else {
-            try a.pegExpr();
-            while (!a.smithListItemEos()) {
-                try a.pegToken(.comma);
-                try a.pegExpr();
-            }
-        }
-        if (a.smith.value(bool)) {
-            try a.pegToken(.comma);
-        }
-    }
-    try a.pegToken(.r_brace);
-}
-
-/// PrefixTypeOp* ErrorUnionExpr
-fn pegTypeExpr(a: *AstSmith) SourceError!void {
-    while (!a.smithListItemEos()) {
-        try a.pegPrefixTypeOp();
-    }
-    try a.pegErrorUnionExpr();
-}
-
-/// ErrorUnionExpr <- SuffixExpr (EXCLAMATIONMARK TypeExpr)?
-fn pegErrorUnionExpr(a: *AstSmith) SourceError!void {
-    try a.pegSuffixExpr();
-    if (!a.not_expr_suffix and a.smithListItemBool()) {
-        try a.pegToken(.bang);
-        try a.pegTypeExpr();
-    }
-}
-
-/// SuffixExpr
-///    <- PrimaryTypeExpr (SuffixOp / FnCallArguments)*
-fn pegSuffixExpr(a: *AstSmith) SourceError!void {
-    try a.pegPrimaryTypeExpr();
-    while (!a.not_expr_suffix and !a.smithListItemEos()) {
-        if (a.smith.value(bool)) {
-            try a.pegSuffixOp();
-        } else {
-            try a.pegFnCallArguments();
-        }
-    }
-}
-
-/// PrimaryTypeExpr
-///     <- BUILTINIDENTIFIER FnCallArguments
-///      / CHAR_LITERAL
-///      / ContainerDecl
-///      / DOT IDENTIFIER
-///      / DOT InitList
-///      / ErrorSetDecl
-///      / FLOAT
-///      / FnProto
-///      / GroupedExpr
-///      / LabeledTypeExpr
-///      / IDENTIFIER !(COLON LabelableExpr)
-///      / IfTypeExpr
-///      / INTEGER
-///      / KEYWORD_comptime TypeExpr !ExprSuffix
-///      / KEYWORD_error DOT IDENTIFIER
-///      / KEYWORD_anyframe
-///      / KEYWORD_unreachable
-///      / STRINGLITERAL
-fn pegPrimaryTypeExpr(a: *AstSmith) SourceError!void {
-    const Kind = enum(u8) {
-        identifier,
-        float,
-        integer,
-        char_literal,
-        string_literal,
-        enum_literal,
-        error_literal,
-        unreachable_type,
-        anyframe_type,
-
-        // Containing zero or more expressions
-        builtin_call,
-        array_literal,
-        container_decl,
-        fn_proto,
-        error_set,
-
-        // Containing one or more epressions
-        grouped,
-        labeled_type_expr,
-        if_type_expr,
-        comptime_expr,
-    };
-
-    switch (a.smith.valueWeighted(Kind, &.{
-        .rangeAtMost(Kind, .identifier, .anyframe_type, 5),
-        .rangeAtMost(Kind, .builtin_call, .error_set, 2),
-        .rangeAtMost(Kind, .grouped, .comptime_expr, 1),
-    })) {
-        .identifier => if (a.not_token != .identifier) {
-            try a.pegIdentifier();
-            a.not_labelable_expr = .colon;
-        } else {
-            // Group
-            try a.pegToken(.l_paren);
-            try a.pegIdentifier();
-            try a.pegToken(.r_paren);
-        },
-        .float => try a.pegFloat(),
-        .integer => try a.pegInteger(),
-        .char_literal => try a.pegCharLiteral(),
-        .string_literal => try a.pegStringLiteral(),
-        .enum_literal => {
-            try a.pegToken(.period);
-            try a.pegIdentifier();
-        },
-        .error_literal => {
-            try a.pegToken(.keyword_error);
-            try a.pegToken(.period);
-            try a.pegIdentifier();
-        },
-        .unreachable_type => try a.pegToken(.keyword_unreachable),
-        .anyframe_type => try a.pegToken(.keyword_anyframe),
-
-        .builtin_call => {
-            try a.pegBuiltinIdentifier();
-            try a.pegFnCallArguments();
-        },
-        .array_literal => {
-            try a.pegToken(.period);
-            try a.pegInitList();
-        },
-        .container_decl => try a.pegContainerDecl(),
-        .fn_proto => if (a.not_token != .keyword_fn) {
-            try a.pegFnProto();
-        } else {
-            // Group
-            try a.pegToken(.l_paren);
-            try a.pegFnProto();
-            try a.pegToken(.r_paren);
-        },
-        .error_set => try a.pegErrorSetDecl(),
-
-        .grouped => try a.pegGroupedExpr(),
-        .labeled_type_expr => try a.pegLabeledTypeExpr(),
-        .if_type_expr => if (!a.not_expr_statement) {
-            try a.pegIfTypeExpr();
-        } else {
-            // Group
-            try a.pegToken(.l_paren);
-            try a.pegIfTypeExpr();
-            try a.pegToken(.r_paren);
-        },
-        .comptime_expr => if (!a.not_token_comptime and !a.not_expr_statement) {
-            try a.pegToken(.keyword_comptime);
-            try a.pegTypeExpr();
-        } else {
-            // Group
-            try a.pegToken(.l_paren);
-            try a.pegToken(.keyword_comptime);
-            try a.pegTypeExpr();
-            try a.pegToken(.r_paren);
-        },
-    }
-}
-
-/// ContainerDecl <- (KEYWORD_extern / KEYWORD_packed)? ContainerDeclAuto
-fn pegContainerDecl(a: *AstSmith) SourceError!void {
-    switch (a.smith.value(enum { auto, @"extern", @"packed" })) {
-        .auto => {},
-        .@"extern" => try a.pegToken(.keyword_extern),
-        .@"packed" => try a.pegToken(.keyword_packed),
-    }
-    try a.pegContainerDeclAuto();
-}
-
-/// ErrorSetDecl <- KEYWORD_error LBRACE IdentifierList RBRACE
-fn pegErrorSetDecl(a: *AstSmith) SourceError!void {
-    try a.pegToken(.keyword_error);
-    try a.pegToken(.l_brace);
-    try a.pegIdentifierList();
-    try a.pegToken(.r_brace);
-}
-
-/// GroupedExpr <- LPAREN Expr RPAREN
-fn pegGroupedExpr(a: *AstSmith) SourceError!void {
-    try a.pegToken(.l_paren);
-    try a.pegExpr();
-    try a.pegToken(.r_paren);
-}
-
-/// IfTypeExpr <- IfPrefix TypeExpr (KEYWORD_else Payload? TypeExpr)? !ExprSuffix
-fn pegIfTypeExpr(a: *AstSmith) SourceError!void {
-    try a.pegIfPrefix();
-    try a.pegTypeExpr();
-    const Else = enum { none, @"else", else_payload };
-    switch (if (a.not_token != .keyword_else) a.smith.value(Else) else .none) {
-        .none => a.not_token = .keyword_else,
-        .@"else" => {
-            try a.pegToken(.keyword_else);
-            try a.pegTypeExpr();
-        },
-        .else_payload => {
-            try a.pegToken(.keyword_else);
-            try a.pegPayload();
-            try a.pegTypeExpr();
-        },
-    }
-    a.not_expr_suffix = true;
-}
-
-/// LabeledTypeExpr
-///     <- BlockLabel Block
-///      / BlockLabel? LoopTypeExpr
-///      / BlockLabel? SwitchExpr
-fn pegLabeledTypeExpr(a: *AstSmith) SourceError!void {
-    const kind = a.smith.value(enum { block, loop, @"switch" });
-    const not_any = a.not_labelable_expr == .expr or a.not_expr_statement;
-    const no_label = a.not_label or a.not_token == .identifier;
-    const no_block = no_label or a.not_block_expr;
-    const group = not_any or (kind == .block and no_block);
-    if (group) try a.pegToken(.l_paren);
-
-    switch (kind) {
-        .block => {
-            try a.pegBlockLabel();
-            try a.pegBlock();
-        },
-        .loop => {
-            if (!no_label and a.smith.value(bool)) {
-                try a.pegBlockLabel();
-            }
-            try a.pegLoopTypeExpr();
-        },
-        .@"switch" => {
-            if (!no_label and a.smith.value(bool)) {
-                try a.pegBlockLabel();
-            }
-            try a.pegSwitchExpr();
-        },
-    }
-
-    if (group) try a.pegToken(.r_paren);
-}
-
-/// LoopTypeExpr <- KEYWORD_inline? (ForTypeExpr / WhileTypeExpr)
-fn pegLoopTypeExpr(a: *AstSmith) SourceError!void {
-    if (a.smith.value(bool)) {
-        try a.pegToken(.keyword_inline);
-    }
-
-    if (a.smith.value(bool)) {
-        try a.pegForTypeExpr();
-    } else {
-        try a.pegWhileTypeExpr();
-    }
-}
-
-/// ForTypeExpr <- ForPrefix TypeExpr (KEYWORD_else TypeExpr / !KEYWORD_else) !ExprSuffix
-fn pegForTypeExpr(a: *AstSmith) SourceError!void {
-    try a.pegForPrefix();
-    try a.pegTypeExpr();
-    if (a.not_token != .keyword_else and a.smith.value(bool)) {
-        try a.pegToken(.keyword_else);
-        try a.pegTypeExpr();
-    } else {
-        a.not_token = .keyword_else;
-    }
-    a.not_expr_suffix = true;
-}
-
-/// WhileTypeExpr <- WhilePrefix TypeExpr (KEYWORD_else Payload? TypeExpr)? !ExprSuffix
-fn pegWhileTypeExpr(a: *AstSmith) SourceError!void {
-    try a.pegWhilePrefix();
-    try a.pegTypeExpr();
-    const Else = enum { none, @"else", else_payload };
-    switch (if (a.not_token != .keyword_else) a.smith.value(Else) else .none) {
-        .none => a.not_token = .keyword_else,
-        .@"else" => {
-            try a.pegToken(.keyword_else);
-            try a.pegTypeExpr();
-        },
-        .else_payload => {
-            try a.pegToken(.keyword_else);
-            try a.pegPayload();
-            try a.pegTypeExpr();
-        },
-    }
-    a.not_expr_suffix = true;
-}
-
-/// SwitchExpr <- KEYWORD_switch LPAREN Expr RPAREN LBRACE SwitchProngList RBRACE
-fn pegSwitchExpr(a: *AstSmith) SourceError!void {
-    try a.pegToken(.keyword_switch);
-    try a.pegToken(.l_paren);
-    try a.pegExpr();
-    try a.pegToken(.r_paren);
-
-    try a.pegToken(.l_brace);
-    try a.pegSwitchProngList();
-    try a.pegToken(.r_brace);
-}
-
-/// AsmExpr <- KEYWORD_asm KEYWORD_volatile? LPAREN Expr AsmOutput? RPAREN
-fn pegAsmExpr(a: *AstSmith) SourceError!void {
-    try a.pegToken(.keyword_asm);
-    if (a.smith.value(bool)) {
-        try a.pegToken(.keyword_volatile);
-    }
-    try a.pegToken(.l_paren);
-    try a.pegExpr();
-    if (a.smith.value(bool)) {
-        try a.pegAsmOutput();
-    }
-    try a.pegToken(.r_paren);
-}
-
-/// AsmOutput <- COLON AsmOutputList AsmInput?
-fn pegAsmOutput(a: *AstSmith) SourceError!void {
-    try a.pegToken(.colon);
-    try a.pegAsmOutputList();
-    if (a.smith.value(bool)) {
-        try a.pegAsmInput();
-    }
-}
-
-/// AsmOutputItem <- LBRACKET IDENTIFIER RBRACKET STRINGLITERALSINGLE LPAREN (MINUSRARROW TypeExpr / IDENTIFIER) RPAREN
-fn pegAsmOutputItem(a: *AstSmith) SourceError!void {
-    try a.pegToken(.l_bracket);
-    try a.pegIdentifier();
-    try a.pegToken(.r_bracket);
-    try a.pegStringLiteralSingle();
-    try a.pegToken(.l_paren);
-    if (a.smith.value(bool)) {
-        try a.pegToken(.arrow);
-        try a.pegTypeExpr();
-    } else {
-        try a.pegIdentifier();
-    }
-    try a.pegToken(.r_paren);
-}
-
-/// AsmInput <- COLON AsmInputList AsmClobbers?
-fn pegAsmInput(a: *AstSmith) SourceError!void {
-    try a.pegToken(.colon);
-    try a.pegAsmInputList();
-    if (a.smith.value(bool)) {
-        try a.pegAsmClobbers();
-    }
-}
-
-/// AsmInputItem <- LBRACKET IDENTIFIER RBRACKET STRINGLITERALSINGLE LPAREN Expr RPAREN
-fn pegAsmInputItem(a: *AstSmith) SourceError!void {
-    try a.pegToken(.l_bracket);
-    try a.pegIdentifier();
-    try a.pegToken(.r_bracket);
-    try a.pegStringLiteralSingle();
-    try a.pegToken(.l_paren);
-    try a.pegExpr();
-    try a.pegToken(.r_paren);
-}
-
-/// AsmClobbers <- COLON Expr
-fn pegAsmClobbers(a: *AstSmith) SourceError!void {
-    try a.pegToken(.colon);
-    try a.pegExpr();
-}
-
-/// BreakLabel <- COLON IDENTIFIER
-fn pegBreakLabel(a: *AstSmith) SourceError!void {
-    try a.pegToken(.colon);
-    try a.pegIdentifier();
-}
-
-/// BlockLabel <- IDENTIFIER COLON
-fn pegBlockLabel(a: *AstSmith) SourceError!void {
-    try a.pegIdentifier();
-    try a.pegToken(.colon);
-}
-
-/// FieldInit <- DOT IDENTIFIER EQUAL Expr
-fn pegFieldInit(a: *AstSmith) SourceError!void {
-    try a.pegToken(.period);
-    try a.pegIdentifier();
-    try a.pegToken(.equal);
-    try a.pegExpr();
-}
-
-/// WhileContinueExpr <- COLON LPAREN AssignExpr RPAREN
-fn pegWhileContinueExpr(a: *AstSmith) SourceError!void {
-    try a.pegToken(.colon);
-    try a.pegToken(.l_paren);
-    try a.pegAssignExpr();
-    try a.pegToken(.r_paren);
-}
-
-/// LinkSection <- KEYWORD_linksection LPAREN Expr RPAREN
-fn pegLinkSection(a: *AstSmith) SourceError!void {
-    try a.pegToken(.keyword_linksection);
-    try a.pegToken(.l_paren);
-    try a.pegExpr();
-    try a.pegToken(.r_paren);
-}
-
-/// AddrSpace <- KEYWORD_addrspace LPAREN Expr RPAREN
-fn pegAddrSpace(a: *AstSmith) SourceError!void {
-    try a.pegToken(.keyword_addrspace);
-    try a.pegToken(.l_paren);
-    try a.pegExpr();
-    try a.pegToken(.r_paren);
-}
-
-/// CallConv <- KEYWORD_callconv LPAREN Expr RPAREN
-fn pegCallConv(a: *AstSmith) SourceError!void {
-    try a.pegToken(.keyword_callconv);
-    try a.pegToken(.l_paren);
-    try a.pegExpr();
-    try a.pegToken(.r_paren);
-}
-
-/// ParamDecl <- doc_comment? (KEYWORD_noalias / KEYWORD_comptime)?
-///            ((IDENTIFIER COLON) / !KEYWORD_comptime !(IDENTIFIER COLON))
-///            ParamType
-fn pegParamDecl(a: *AstSmith) SourceError!void {
-    try a.pegMaybeDocComment();
-    const modifier = a.smith.value(enum { none, @"noalias", @"comptime" });
-    switch (modifier) {
-        .none => a.not_token_comptime = true,
-        .@"noalias" => try a.pegToken(.keyword_noalias),
-        .@"comptime" => try a.pegToken(.keyword_comptime),
-    }
-    if (a.smith.value(bool)) {
-        try a.pegIdentifier();
-        try a.pegToken(.colon);
-    } else {
-        a.not_label = true;
-    }
-    try a.pegParamType();
-}
-
-/// ParamType
-///     <- KEYWORD_anytype
-///      / TypeExpr
-fn pegParamType(a: *AstSmith) SourceError!void {
-    if (a.smith.value(bool)) {
-        try a.pegToken(.keyword_anytype);
-    } else {
-        try a.pegTypeExpr();
-    }
-}
-
-/// IfPrefix <- KEYWORD_if LPAREN Expr RPAREN PtrPayload?
-fn pegIfPrefix(a: *AstSmith) SourceError!void {
-    try a.pegToken(.keyword_if);
-    try a.pegToken(.l_paren);
-    try a.pegExpr();
-    try a.pegToken(.r_paren);
-    try a.pegPtrPayload();
-}
-
-/// WhilePrefix <- KEYWORD_while LPAREN Expr RPAREN PtrPayload? WhileContinueExpr?
-fn pegWhilePrefix(a: *AstSmith) SourceError!void {
-    try a.pegToken(.keyword_while);
-    try a.pegToken(.l_paren);
-    try a.pegExpr();
-    try a.pegToken(.r_paren);
-
-    if (a.smith.value(bool)) {
-        try a.pegPtrPayload();
-    }
-
-    if (a.smith.value(bool)) {
-        try a.pegWhileContinueExpr();
-    }
-}
-
-/// ForPrefix <- KEYWORD_for LPAREN ForArgumentsList RPAREN PtrListPayload
-///
-/// An additional requirement checked in the Parser is that the number of
-/// arguments and payload elements are the same.
-fn pegForPrefix(a: *AstSmith) SourceError!void {
-    try a.pegToken(.keyword_for);
-    try a.pegToken(.l_paren);
-    const n = try a.pegForArgumentsList();
-    try a.pegToken(.r_paren);
-    try a.pegPtrListPayload(n);
-}
-
-/// Payload <- PIPE IDENTIFIER PIPE
-fn pegPayload(a: *AstSmith) SourceError!void {
-    try a.pegToken(.pipe);
-    try a.pegIdentifier();
-    try a.pegToken(.pipe);
-}
-
-/// PtrPayload <- PIPE ASTERISK? IDENTIFIER PIPE
-fn pegPtrPayload(a: *AstSmith) SourceError!void {
-    try a.pegToken(.pipe);
-    if (a.smith.value(bool)) {
-        try a.pegToken(.asterisk);
-    }
-    try a.pegIdentifier();
-    try a.pegToken(.pipe);
-}
-
-/// PtrIndexPayload <- PIPE ASTERISK? IDENTIFIER (COMMA IDENTIFIER)? PIPE
-fn pegPtrIndexPayload(a: *AstSmith) SourceError!void {
-    try a.pegToken(.pipe);
-    if (a.smith.value(bool)) {
-        try a.pegToken(.asterisk);
-    }
-    try a.pegIdentifier();
-    if (a.smith.value(bool)) {
-        try a.pegToken(.comma);
-        try a.pegIdentifier();
-    }
-    try a.pegToken(.pipe);
-}
-
-/// PtrListPayload <- PIPE ASTERISK? IDENTIFIER (COMMA ASTERISK? IDENTIFIER)* COMMA? PIPE
-fn pegPtrListPayload(a: *AstSmith, n: usize) SourceError!void {
-    try a.pegToken(.pipe);
-    if (a.smith.value(bool)) {
-        try a.pegToken(.asterisk);
-    }
-    try a.pegIdentifier();
-
-    for (1..n) |_| {
-        try a.pegToken(.comma);
-        if (a.smith.value(bool)) {
-            try a.pegToken(.asterisk);
-        }
-        try a.pegIdentifier();
-    }
-
-    if (a.smith.value(bool)) {
-        try a.pegToken(.comma);
-    }
-    try a.pegToken(.pipe);
-}
-
-/// SwitchProng <- KEYWORD_inline? SwitchCase EQUALRARROW PtrIndexPayload? SingleAssignExpr
-fn pegSwitchProng(a: *AstSmith) SourceError!void {
-    if (a.smith.value(bool)) {
-        try a.pegToken(.keyword_inline);
-    }
-    try a.pegSwitchCase();
-    try a.pegToken(.equal_angle_bracket_right);
-    if (a.smith.value(bool)) {
-        try a.pegPtrIndexPayload();
-    }
-    try a.pegSingleAssignExpr();
-}
-
-/// SwitchCase
-///     <- SwitchItem (COMMA SwitchItem)* COMMA?
-///      / KEYWORD_else
-fn pegSwitchCase(a: *AstSmith) SourceError!void {
-    if (a.smith.value(bool)) {
-        try a.pegSwitchItem();
-        while (!a.smithListItemEos()) {
-            try a.pegToken(.comma);
-            try a.pegSwitchItem();
-        }
-        if (a.smith.value(bool)) {
-            try a.pegToken(.comma);
-        }
-    } else {
-        try a.pegToken(.keyword_else);
-    }
-}
-
-/// SwitchItem <- Expr (DOT3 Expr)?
-fn pegSwitchItem(a: *AstSmith) SourceError!void {
-    try a.pegExpr();
-    if (a.smith.value(bool)) {
-        try a.pegToken(.ellipsis3);
-        try a.pegExpr();
-    }
-}
-
-/// ForArgumentsList <- ForItem (COMMA ForItem)* COMMA?
-fn pegForArgumentsList(a: *AstSmith) SourceError!usize {
-    try a.pegForItem();
-    var n: usize = 1;
-    while (!a.smithListItemEos()) {
-        try a.pegToken(.comma);
-        try a.pegForItem();
-        n += 1;
-    }
-    if (a.smith.value(bool)) {
-        try a.pegToken(.comma);
-    }
-    return n;
-}
-
-/// ForItem <- Expr (DOT2 Expr?)?
-fn pegForItem(a: *AstSmith) SourceError!void {
-    try a.pegExpr();
-    const components = a.smith.valueRangeAtMost(u2, 0, 2);
-    if (components >= 1) try a.pegToken(.ellipsis2);
-    if (components >= 2) try a.pegExpr();
-}
-
-/// AssignOp
-///     <- ASTERISKEQUAL
-///      / ASTERISKPIPEEQUAL
-///      / SLASHEQUAL
-///      / PERCENTEQUAL
-///      / PLUSEQUAL
-///      / PLUSPIPEEQUAL
-///      / MINUSEQUAL
-///      / MINUSPIPEEQUAL
-///      / LARROW2EQUAL
-///      / LARROW2PIPEEQUAL
-///      / RARROW2EQUAL
-///      / AMPERSANDEQUAL
-///      / CARETEQUAL
-///      / PIPEEQUAL
-///      / ASTERISKPERCENTEQUAL
-///      / PLUSPERCENTEQUAL
-///      / MINUSPERCENTEQUAL
-///      / EQUAL
-fn pegAssignOp(a: *AstSmith) SourceError!void {
-    const tags = [_]Token.Tag{
-        .asterisk_equal,
-        .asterisk_pipe_equal,
-        .slash_equal,
-        .percent_equal,
-        .plus_equal,
-        .plus_pipe_equal,
-        .minus_equal,
-        .minus_pipe_equal,
-        .angle_bracket_angle_bracket_left_equal,
-        .angle_bracket_angle_bracket_left_pipe_equal,
-        .angle_bracket_angle_bracket_right_equal,
-        .ampersand_equal,
-        .caret_equal,
-        .pipe_equal,
-        .asterisk_percent_equal,
-        .plus_percent_equal,
-        .minus_percent_equal,
-        .equal,
-    };
-    try a.pegToken(tags[a.smith.index(tags.len)]);
-}
-
-/// CompareOp
-///     <- EQUALEQUAL
-///      / EXCLAMATIONMARKEQUAL
-///      / LARROW
-///      / RARROW
-///      / LARROWEQUAL
-///      / RARROWEQUAL
-fn pegCompareOp(a: *AstSmith) SourceError!void {
-    const tags = [_]Token.Tag{
-        .equal_equal,
-        .bang_equal,
-        .angle_bracket_left,
-        .angle_bracket_right,
-        .angle_bracket_left_equal,
-        .angle_bracket_right_equal,
-    };
-    try a.pegTokenWhitespaceAround(tags[a.smith.index(tags.len)]);
-}
-
-/// BitwiseOp
-///     <- AMPERSAND
-///      / CARET
-///      / PIPE
-///      / KEYWORD_orelse
-///      / KEYWORD_catch Payload?
-fn pegBitwiseOp(a: *AstSmith) SourceError!void {
-    const tags = [_]Token.Tag{
-        .ampersand,
-        .caret,
-        .pipe,
-        .keyword_orelse,
-        .keyword_catch,
-    };
-    const tag = tags[a.smith.index(tags.len)];
-    try a.pegTokenWhitespaceAround(tag);
-    if (tag == .keyword_catch and a.smith.value(bool)) {
-        try a.pegPayload();
-    }
-}
-
-/// BitShiftOp
-///     <- LARROW2
-///      / RARROW2
-///      / LARROW2PIPE
-fn pegBitShiftOp(a: *AstSmith) SourceError!void {
-    const tags = [_]Token.Tag{
-        .angle_bracket_angle_bracket_left,
-        .angle_bracket_angle_bracket_right,
-        .angle_bracket_angle_bracket_left_pipe,
-    };
-    try a.pegTokenWhitespaceAround(tags[a.smith.index(tags.len)]);
-}
-
-/// AdditionOp
-///     <- PLUS
-///      / MINUS
-///      / PLUS2
-///      / PLUSPERCENT
-///      / MINUSPERCENT
-///      / PLUSPIPE
-///      / MINUSPIPE
-fn pegAdditionOp(a: *AstSmith) SourceError!void {
-    const tags = [_]Token.Tag{
-        .plus,
-        .minus,
-        .plus_plus,
-        .plus_percent,
-        .minus_percent,
-        .plus_pipe,
-        .minus_pipe,
-    };
-    try a.pegTokenWhitespaceAround(tags[a.smith.index(tags.len)]);
-}
-
-/// MultiplyOp
-///     <- PIPE2
-///      / ASTERISK
-///      / SLASH
-///      / PERCENT
-///      / ASTERISKPERCENT
-///      / ASTERISKPIPE
-fn pegMultiplyOp(a: *AstSmith) SourceError!void {
-    const tags = [_]Token.Tag{
-        .asterisk,
-        .pipe_pipe,
-        .slash,
-        .percent,
-        .asterisk_percent,
-        .asterisk_pipe,
-    };
-    const start = @as(u8, 2) * @intFromBool(a.not_token == .asterisk);
-    try a.pegTokenWhitespaceAround(tags[a.smith.valueRangeLessThan(u8, start, tags.len)]);
-}
-
-/// PrefixOp
-///     <- EXCLAMATIONMARK
-///      / MINUS
-///      / TILDE
-///      / MINUSPERCENT
-///      / AMPERSAND
-///      / KEYWORD_try
-fn pegPrefixOp(a: *AstSmith) SourceError!void {
-    const tags = [_]Token.Tag{
-        .bang,
-        .minus,
-        .tilde,
-        .minus_percent,
-        .ampersand,
-        .keyword_try,
-    };
-    try a.pegToken(tags[a.smith.index(tags.len)]);
-}
-
-/// PrefixTypeOp
-///     <- QUESTIONMARK
-///      / KEYWORD_anyframe MINUSRARROW
-///      / (ManyPtrTypeStart / SliceTypeStart) KEYWORD_allowzero? ByteAlign? AddrSpace?
-///      KEYWORD_const? KEYWORD_volatile?
-///      / SinglePtrTypeStart KEYWORD_allowzero? BitAlign? AddrSpace?
-///      KEYWORD_const? KEYWORD_volatile?
-///      / ArrayTypeStart
-fn pegPrefixTypeOp(a: *AstSmith) SourceError!void {
-    switch (a.smith.value(enum {
-        optional,
-        anyframe_arrow,
-        array,
-        single_pointer,
-        many_pointer,
-        slice,
-    })) {
-        .optional => try a.pegToken(.question_mark),
-        .anyframe_arrow => {
-            try a.pegToken(.keyword_anyframe);
-            try a.pegToken(.arrow);
-        },
-        .array => try a.pegArrayTypeStart(),
-        .single_pointer, .many_pointer, .slice => |kind| {
-            const is_single = kind == .single_pointer and a.not_token != .asterisk;
-            if (is_single) {
-                try a.pegSinglePtrTypeStart();
-            } else if (kind == .many_pointer) {
-                try a.pegManyPtrTypeStart();
-            } else {
-                try a.pegSliceTypeStart();
-            }
-
-            if (a.smith.value(bool)) {
-                try a.pegToken(.keyword_allowzero);
-            }
-            if (a.smith.value(bool)) {
-                if (is_single) {
-                    try a.pegBitAlign();
-                } else {
-                    try a.pegByteAlign();
-                }
-            }
-            if (a.smith.value(bool)) {
-                try a.pegAddrSpace();
-            }
-            if (a.smith.value(bool)) {
-                try a.pegToken(.keyword_const);
-            }
-            if (a.smith.value(bool)) {
-                try a.pegToken(.keyword_volatile);
-            }
-        },
-    }
-}
-
-/// SuffixOp
-///     <- LBRACKET Expr (DOT2 Expr? (COLON Expr)?)? RBRACKET
-///      / DOT IDENTIFIER
-///      / DOTASTERISK
-///      / DOTQUESTIONMARK
-fn pegSuffixOp(a: *AstSmith) SourceError!void {
-    switch (a.smith.value(enum { slice, field, deref, unwrap })) {
-        .slice => {
-            try a.pegToken(.l_bracket);
-            try a.pegExpr();
-
-            if (a.smith.value(bool)) {
-                try a.pegToken(.ellipsis2);
-                if (a.smith.value(bool))
-                    try a.pegExpr();
-                if (a.smith.value(bool)) {
-                    try a.pegToken(.colon);
-                    try a.pegExpr();
-                }
-            }
-
-            try a.pegToken(.r_bracket);
-        },
-        .field => {
-            try a.pegToken(.period);
-            try a.pegIdentifier();
-        },
-        .deref => try a.pegToken(.period_asterisk),
-        .unwrap => {
-            try a.pegToken(.period);
-            try a.pegToken(.question_mark);
-        },
-    }
-}
-
-/// FnCallArguments <- LPAREN ExprList RPAREN
-fn pegFnCallArguments(a: *AstSmith) SourceError!void {
-    try a.pegToken(.l_paren);
-    try a.pegExprList();
-    try a.pegToken(.r_paren);
-}
-
-/// SliceTypeStart <- LBRACKET (COLON Expr)? RBRACKET
-fn pegSliceTypeStart(a: *AstSmith) SourceError!void {
-    try a.pegToken(.l_bracket);
-    if (a.smith.value(bool)) {
-        try a.pegToken(.colon);
-        try a.pegExpr();
-    }
-    try a.pegToken(.r_bracket);
-}
-
-/// SinglePtrTypeStart <- ASTERISK
-fn pegSinglePtrTypeStart(a: *AstSmith) SourceError!void {
-    try a.pegToken(.asterisk);
-}
-
-/// ManyPtrTypeStart <- LBRACKET ASTERISK (LETTERC / COLON Expr)? RBRACKET
-fn pegManyPtrTypeStart(a: *AstSmith) SourceError!void {
-    try a.pegToken(.l_bracket);
-    try a.pegToken(.asterisk);
-    switch (a.smith.value(enum { many, many_c, many_sentinel })) {
-        .many => {},
-        .many_c => {
-            // No need for `preservePegEndOfWord` because the previous token is an asterisk
-            try a.addTokenTag(.identifier);
-            try a.addSourceByte('c');
-        },
-        .many_sentinel => {
-            try a.pegToken(.colon);
-            try a.pegExpr();
-        },
-    }
-    try a.pegToken(.r_bracket);
-}
-
-/// ArrayTypeStart <- LBRACKET !ASTERISK Expr (COLON Expr)? RBRACKET
-fn pegArrayTypeStart(a: *AstSmith) SourceError!void {
-    try a.pegToken(.l_bracket);
-    a.not_token = .asterisk;
-    try a.pegExpr();
-    if (a.smith.value(bool)) {
-        try a.pegToken(.colon);
-        try a.pegExpr();
-    }
-    try a.pegToken(.r_bracket);
-}
-
-/// ContainerDeclAuto <- ContainerDeclType LBRACE ContainerMembers RBRACE
-fn pegContainerDeclAuto(a: *AstSmith) SourceError!void {
-    try a.pegContainerDeclType();
-    try a.pegToken(.l_brace);
-    try a.pegContainerMembers();
-    try a.pegToken(.r_brace);
-}
-
-/// ContainerDeclType
-///     <- KEYWORD_struct (LPAREN Expr RPAREN)?
-///      / KEYWORD_opaque
-///      / KEYWORD_enum (LPAREN Expr RPAREN)?
-///      / KEYWORD_union (LPAREN (KEYWORD_enum (LPAREN Expr RPAREN)? / !KEYWORD_enum Expr) RPAREN)?
-fn pegContainerDeclType(a: *AstSmith) SourceError!void {
-    switch (a.smith.value(enum { @"struct", @"opaque", @"enum", @"union" })) {
-        .@"struct", .@"enum" => |c| {
-            const is_struct = c == .@"struct" or a.not_token == .keyword_enum;
-            try a.pegToken(if (is_struct) .keyword_struct else .keyword_enum);
-            if (a.smith.value(bool)) {
-                try a.pegToken(.l_paren);
-                try a.pegExpr();
-                try a.pegToken(.r_paren);
-            }
-        },
-        .@"opaque" => try a.pegToken(.keyword_opaque),
-        .@"union" => {
-            try a.pegToken(.keyword_union);
-            switch (a.smith.value(enum { no_tag, expr_tag, enum_tag, enum_expr_tag })) {
-                .no_tag => {},
-                .expr_tag => {
-                    try a.pegToken(.l_paren);
-                    a.not_token = .keyword_enum;
-                    try a.pegExpr();
-                    try a.pegToken(.r_paren);
-                },
-                .enum_tag => {
-                    try a.pegToken(.l_paren);
-                    try a.pegToken(.keyword_enum);
-                    try a.pegToken(.r_paren);
-                },
-                .enum_expr_tag => {
-                    try a.pegToken(.l_paren);
-                    try a.pegToken(.keyword_enum);
-                    try a.pegToken(.l_paren);
-                    try a.pegExpr();
-                    try a.pegToken(.r_paren);
-                    try a.pegToken(.r_paren);
-                },
-            }
-        },
-    }
-}
-
-/// ByteAlign <- KEYWORD_align LPAREN Expr RPAREN
-fn pegByteAlign(a: *AstSmith) SourceError!void {
-    try a.pegToken(.keyword_align);
-    try a.pegToken(.l_paren);
-    try a.pegExpr();
-    try a.pegToken(.r_paren);
-}
-
-/// BitAlign <- KEYWORD_align LPAREN Expr (COLON Expr COLON Expr)? RPAREN
-fn pegBitAlign(a: *AstSmith) SourceError!void {
-    try a.pegToken(.keyword_align);
-    try a.pegToken(.l_paren);
-    try a.pegExpr();
-    if (a.smith.value(bool)) {
-        try a.pegToken(.colon);
-        try a.pegExpr();
-        try a.pegToken(.colon);
-        try a.pegExpr();
-    }
-    try a.pegToken(.r_paren);
-}
-
-/// IdentifierList <- (doc_comment? IDENTIFIER COMMA)* (doc_comment? IDENTIFIER)?
-fn pegIdentifierList(a: *AstSmith) SourceError!void {
-    while (!a.smith.eos()) {
-        try a.pegMaybeDocComment();
-        try a.pegIdentifier();
-        try a.pegToken(.comma);
-    }
-    if (a.smith.value(bool)) {
-        try a.pegMaybeDocComment();
-        try a.pegIdentifier();
-    }
-}
-
-/// SwitchProngList <- (SwitchProng COMMA)* SwitchProng?
-fn pegSwitchProngList(a: *AstSmith) SourceError!void {
-    while (!a.smithListItemEos()) {
-        try a.pegSwitchProng();
-        try a.pegToken(.comma);
-    }
-    if (a.smithListItemBool()) {
-        try a.pegSwitchProng();
-    }
-}
-
-/// AsmOutputList <- (AsmOutputItem COMMA)* AsmOutputItem?
-fn pegAsmOutputList(a: *AstSmith) SourceError!void {
-    while (!a.smithListItemEos()) {
-        try a.pegAsmOutputItem();
-        try a.pegToken(.comma);
-    }
-    if (a.smithListItemBool()) {
-        try a.pegAsmOutputItem();
-    }
-}
-
-/// AsmInputList <- (AsmInputItem COMMA)* AsmInputItem?
-fn pegAsmInputList(a: *AstSmith) SourceError!void {
-    while (!a.smithListItemEos()) {
-        try a.pegAsmInputItem();
-        try a.pegToken(.comma);
-    }
-    if (a.smithListItemBool()) {
-        try a.pegAsmInputItem();
-    }
-}
-
-/// ParamDeclList <- (ParamDecl COMMA)* (ParamDecl / DOT3 COMMA?)?
-fn pegParamDeclList(a: *AstSmith) SourceError!void {
-    while (!a.smithListItemEos()) {
-        try a.pegParamDecl();
-        try a.pegToken(.comma);
-    }
-    const Final = enum { none, dot3, dot3_comma, param };
-    switch (a.smith.valueWeighted(Final, &.{
-        .rangeLessThan(Final, .none, .param, 2),
-        .value(Final, .param, 1),
-    })) {
-        .none => {},
-        .dot3 => try a.pegToken(.ellipsis3),
-        .dot3_comma => {
-            try a.pegToken(.ellipsis3);
-            try a.pegToken(.comma);
-        },
-        .param => try a.pegParamDecl(),
-    }
-}
-
-/// ExprList <- (Expr COMMA)* Expr?
-fn pegExprList(a: *AstSmith) SourceError!void {
-    while (!a.smithListItemEos()) {
-        try a.pegExpr();
-        try a.pegToken(.comma);
-    }
-    if (a.smithListItemBool()) {
-        try a.pegExpr();
-    }
-}
-
-/// container_doc_comment <- ('//!' non_control_utf8* [ \n]* skip)+
-fn pegContainerDocComment(a: *AstSmith) SourceError!void {
-    while (true) {
-        try a.addTokenTag(.container_doc_comment);
-        try a.pegGenericLine("//!", .any);
-        try a.pegSkip();
-        if (a.smith.eos()) break;
-    }
-}
-
-/// doc_comment?
-fn pegMaybeDocComment(a: *AstSmith) SourceError!void {
-    // A specific hash is provided here since this function is likely to be inlined,
-    // however having all doc comments with the same uid is beneficial.
-    if (a.smith.boolWeightedWithHash(63, 1, 0x39b94392)) {
-        try a.pegDocComment();
-    }
-}
-
-/// doc_comment <- ('///' non_control_utf8* [ \n]* skip)+
-fn pegDocComment(a: *AstSmith) SourceError!void {
-    if (a.source_len > 0 and a.source_buf[a.source_len - 1] != '\n') {
-        try a.addSourceByte('\n');
-    }
-    while (true) {
-        try a.addTokenTag(.doc_comment);
-        try a.pegGenericLine("///", .doc_comment);
-        try a.pegSkip();
-        if (a.smith.eosWeightedSimple(1, 3)) break;
-    }
-}
-
-/// line_comment <- '//' ![!/] non_control_utf8* / '////' non_control_utf8*
-fn pegLineComment(a: *AstSmith) SourceError!void {
-    return a.pegGenericLine("//", .line_comment);
-}
-
-/// line_string <- '\\\\' non_control_utf8* [ \n]*
-fn pegLineString(a: *AstSmith) SourceError!void {
-    try a.addTokenTag(.multiline_string_literal_line);
-    return a.pegGenericLine("\\\\", .any);
-}
-
-/// non_control_utf8 <- [\040-\377]
-///
-/// Used for line, doc, and container comments as well as
-/// multiline string literal lines.
-fn pegGenericLine(
-    a: *AstSmith,
-    prefix: []const u8,
-    /// Adds constraints to what the line contains
-    prefix_kind: enum { any, line_comment, doc_comment },
-) SourceError!void {
-    const cr = a.smith.value(bool);
-    const newline_len = @intFromBool(cr) + @as(usize, 1);
-
-    try a.ensureSourceCapacity(prefix.len + newline_len);
-    a.addSourceAssumeCapacity(prefix);
-
-    const line = a.variableChar(newline_len, 0, &.{
-        .rangeAtMost(u8, ' ', 0x7f - 1, 1),
-        .rangeAtMost(u8, 0x7f + 1, 0xff, 1),
-    });
-    if (line.len >= 1) switch (prefix_kind) {
-        .any => {},
-        .line_comment => {
-            // Convert doc comments to quadruple slashes when possible;
-            // Otherwise, and for container doc comments, erase the '/' or '!'
-            if (line[0] == '/' and line.len >= 2) {
-                line[1] = '/';
-            } else if (line[0] == '/' or line[0] == '!') {
-                line[0] = ' ';
-            }
-        },
-        .doc_comment => {
-            // Avoid quadruple slashes
-            if (line[0] == '/') {
-                line[0] = ' ';
-            }
-        },
-    };
-
-    if (cr) a.addSourceByteAssumeCapacity('\r');
-    a.addSourceByteAssumeCapacity('\n');
-}
-
-/// skip <- ([ \n] / line_comment)*
-fn pegSkip(a: *AstSmith) SourceError!void {
-    if (a.smith.boolWeighted(63, 1)) {
-        while (true) {
-            const Kind = enum {
-                space,
-                line_break,
-                cr_line_break,
-                line_comment,
-                line_comment_zig_fmt_off,
-                line_comment_zig_fmt_on,
-            };
-
-            const weights = Smith.baselineWeights(Kind) ++
-                [_]Weight{.value(Kind, .space, 11)};
-            switch (a.smith.valueWeighted(Kind, weights)) {
-                .space => try a.addSourceByte(' '),
-                .line_break => try a.addSourceByte('\n'),
-                .cr_line_break => try a.addSource("\r\n"),
-                .line_comment => try a.pegLineComment(),
-                .line_comment_zig_fmt_off => try a.addSource("//zig fmt: off\n"),
-                .line_comment_zig_fmt_on => try a.addSource("//zig fmt: on\n"),
-            }
-
-            if (a.smith.eos()) break;
-        }
-    }
-}
-
-const bin_weights: []const Weight = &.{.rangeAtMost(u8, '0', '1', 1)};
-const oct_weights: []const Weight = &.{.rangeAtMost(u8, '0', '7', 1)};
-const dec_weights: []const Weight = &.{.rangeAtMost(u8, '0', '9', 1)};
-const hex_weights: []const Weight = &.{
-    .rangeAtMost(u8, '0', '9', 1),
-    .rangeAtMost(u8, 'a', 'f', 1),
-    .rangeAtMost(u8, 'A', 'F', 1),
-};
-
-/// Asserts enough capacity for at `min + reserved_capacity`
-fn variableChar(
-    a: *AstSmith,
-    reserved_capacity: usize,
-    min: usize,
-    weights: []const Weight,
-) []u8 {
-    const capacity = a.sourceCapacity();
-    const max_out = capacity.len - reserved_capacity;
-
-    const len_weights: [3]Weight = .{
-        .rangeAtMost(u32, @intCast(min), @min(2, max_out), 32678),
-        // For the below `.rangeAtMost` is not used because max may be less than min.
-        // In this case, the weights are omitted.
-        .{ .min = 3, .max = @min(16, max_out), .weight = 512 },
-        // Still allow much longer sequences to test parsing overflows
-        .{ .min = 17, .max = @min(256, max_out), .weight = 1 },
-    };
-    const n_weights = @as(usize, 1) + @intFromBool(max_out >= 3) + @intFromBool(max_out >= 17);
-
-    const len = a.smith.sliceWeighted(capacity, len_weights[0..n_weights], weights);
-    a.source_len += len;
-    return capacity[0..len];
-}
-
-/// char_escape
-///     <- "\\x" hex hex
-///      / "\\u{" hex+ "}"
-///      / "\\" [nr\\t'"]
-/// char_char
-///     <- multibyte_utf8
-///      / char_escape
-///      / ![\\'\n] non_control_ascii
-///
-/// string_char
-///     <- multibyte_utf8
-///      / char_escape
-///      / ![\\"\n] non_control_ascii
-fn pegChar(a: *AstSmith, quote: u8) SourceError!void {
-    const Char = enum(u8) {
-        ascii,
-        unicode_2,
-        unicode_3,
-        unicode_4,
-        hex_escape,
-        unicode_escape,
-        char_escape,
-    };
-    const weights = Smith.baselineWeights(Char) ++ &[_]Weight{.value(Char, .ascii, 32)};
-    switch (a.smith.valueWeighted(Char, weights)) {
-        .ascii => try a.addSourceByte(a.smith.valueWeighted(u8, &.{
-            .rangeAtMost(u8, ' ', quote - 1, 1),
-            .rangeAtMost(u8, quote + 1, '\\' - 1, 1),
-            .rangeAtMost(u8, '\\' + 1, 0x7e, 1),
-        })),
-        .unicode_2 => assert(2 == std.unicode.wtf8Encode(
-            a.smith.valueRangeLessThan(u21, 0x80, 0x800),
-            try a.addSourceAsSlice(2),
-        ) catch unreachable),
-        .unicode_3 => assert(3 == std.unicode.wtf8Encode(
-            a.smith.valueRangeLessThan(u21, 0x800, 0x10000),
-            try a.addSourceAsSlice(3),
-        ) catch unreachable),
-        .unicode_4 => assert(4 == std.unicode.wtf8Encode(
-            a.smith.valueRangeLessThan(u21, 0x10000, 0x110000),
-            try a.addSourceAsSlice(4),
-        ) catch unreachable),
-        .hex_escape => {
-            try a.ensureSourceCapacity(4);
-            a.addSourceAssumeCapacity("\\x");
-            a.smith.bytesWeighted(a.addSourceAsSliceAssumeCapacity(2), hex_weights);
-        },
-        .unicode_escape => {
-            try a.ensureSourceCapacity(5);
-            a.addSourceAssumeCapacity("\\u{");
-            _ = a.variableChar(1, 1, hex_weights);
-            a.addSourceByteAssumeCapacity('}');
-        },
-        .char_escape => {
-            try a.ensureSourceCapacity(2);
-            a.addSourceByteAssumeCapacity('\\');
-            a.addSourceByteAssumeCapacity(a.smith.valueWeighted(u8, &.{
-                .value(u8, 'n', 1),
-                .value(u8, 'r', 1),
-                .value(u8, 't', 1),
-                .value(u8, '\\', 1),
-                .value(u8, '\'', 1),
-                .value(u8, '"', 1),
-            }));
-        },
-    }
-}
-
-/// CHAR_LITERAL <- ['] char_char ['] skip
-fn pegCharLiteral(a: *AstSmith) SourceError!void {
-    try a.addTokenTag(.char_literal);
-    try a.addSourceByte('\'');
-    try a.pegChar('\'');
-    try a.addSourceByte('\'');
-    try a.pegSkip();
-}
-
-///FLOAT
-///    <- '0x' hex_int '.' hex_int ([pP] [-+]? dec_int)? skip
-///     /      dec_int '.' dec_int ([eE] [-+]? dec_int)? skip
-///     / '0x' hex_int [pP] [-+]? dec_int skip
-///     /      dec_int [eE] [-+]? dec_int skip
-fn pegFloat(a: *AstSmith) SourceError!void {
-    try a.preservePegEndOfWord();
-    try a.addTokenTag(.number_literal);
-
-    const hex = a.smith.value(bool);
-    const exp = a.smith.value(packed struct(u3) {
-        kind: enum(u2) { none, no_sign, minus, plus },
-        upper: bool,
-    });
-    const dot = exp.kind == .none or a.smith.value(bool);
-
-    var reserved: usize = @intFromBool(hex) * "0x".len + "0".len + @intFromBool(dot) * ".0".len +
-        switch (exp.kind) {
-            .none => 0,
-            .no_sign => "e0".len,
-            .minus => "e-0".len,
-            .plus => "e+0".len,
-        };
-    try a.ensureSourceCapacity(reserved);
-
-    if (hex) {
-        reserved -= 2;
-        a.addSourceAssumeCapacity("0x");
-    }
-    const digits = if (hex) hex_weights else dec_weights;
-
-    reserved -= 1;
-    _ = a.variableChar(reserved, 1, digits);
-
-    if (dot) {
-        reserved -= 2;
-        a.addSourceByteAssumeCapacity('.');
-        _ = a.variableChar(reserved, 1, digits);
-    }
-
-    if (exp.kind != .none) {
-        reserved -= 1;
-        const case_diff = @as(u8, 'a' - 'A') * @intFromBool(exp.upper);
-        a.addSourceByteAssumeCapacity(@as(u8, if (hex) 'p' else 'e') - case_diff);
-
-        if (exp.kind != .no_sign) {
-            reserved -= 1;
-            a.addSourceByteAssumeCapacity(if (exp.kind == .plus) '+' else '-');
-        }
-
-        reserved -= 1;
-        assert(reserved == 0);
-        _ = a.variableChar(reserved, 1, dec_weights);
-    }
-}
-
-///INTEGER
-///    <- '0b' bin_int skip
-///     / '0o' oct_int skip
-///     / '0x' hex_int skip
-///     /      dec_int skip
-fn pegInteger(a: *AstSmith) SourceError!void {
-    try a.preservePegEndOfWord();
-    try a.addTokenTag(.number_literal);
-    const Base = enum { bin, dec, oct, hex };
-    const base_weights: []const Weight = Smith.baselineWeights(Base) ++
-        &[_]Weight{ .value(Base, .dec, 6), .value(Base, .hex, 2) };
-    const digits, const prefix = switch (a.smith.valueWeighted(Base, base_weights)) {
-        .bin => .{ bin_weights, "0b" },
-        .oct => .{ oct_weights, "0o" },
-        .dec => .{ dec_weights, "" },
-        .hex => .{ hex_weights, "0x" },
-    };
-    try a.ensureSourceCapacity(prefix.len + 1);
-    if (prefix.len != 0) a.addSourceAssumeCapacity(prefix);
-    _ = a.variableChar(0, 1, digits);
-}
-
-/// Does not include 'skip'. Does not add any token tag.
-fn stringLiteralSingleInner(a: *AstSmith) SourceError!void {
-    try a.addSourceByte('"');
-    while (!a.smith.eosWeightedSimple(3, 1)) {
-        try a.pegChar('"');
-    }
-    try a.addSourceByte('"');
-}
-
-/// STRINGLITERALSINGLE <- ["] string_char* ["] skip
-fn pegStringLiteralSingle(a: *AstSmith) SourceError!void {
-    try a.addTokenTag(.string_literal);
-    try a.stringLiteralSingleInner();
-    try a.pegSkip();
-}
-
-/// STRINGLITERAL
-///     <- STRINGLITERALSINGLE
-///      / (line_string skip)+
-fn pegStringLiteral(a: *AstSmith) SourceError!void {
-    if (a.smith.value(bool)) {
-        try a.pegStringLiteralSingle();
-    } else {
-        while (true) {
-            try a.pegLineString();
-            try a.pegSkip();
-            if (a.smith.eos()) break;
-        }
-    }
-}
-
-const alphanumeric_weights: [4]Weight = .{
-    .rangeAtMost(u8, '0', '9', 1),
-    .rangeAtMost(u8, 'A', 'Z', 1),
-    .rangeAtMost(u8, 'a', 'z', 1),
-    .value(u8, '_', 1),
-};
-
-/// IDENTIFIER
-///     <- !keyword [A-Za-z_] [A-Za-z0-9_]* skip
-///      / '@' STRINGLITERALSINGLE
-fn pegIdentifier(a: *AstSmith) SourceError!void {
-    const Kind = enum(u2) { underscore, regular_identifier, quoted_identifier, copy_identifier };
-    const kind_weights: [4]Weight = .{
-        .value(Kind, .underscore, 6),
-        .value(Kind, .regular_identifier, 3),
-        .value(Kind, .quoted_identifier, 1),
-        .value(Kind, .copy_identifier, 6),
-    };
-    const n_weights = @as(usize, kind_weights.len) - @intFromBool(a.prev_ids_len == 0);
-    const kind = a.smith.valueWeighted(Kind, kind_weights[0..n_weights]);
-
-    switch (kind) {
-        .underscore => {
-            try a.preservePegEndOfWord();
-            try a.addTokenTag(.identifier);
-            try a.addSourceByte('_');
-        },
-        .regular_identifier => {
-            try a.preservePegEndOfWord();
-            try a.addTokenTag(.identifier);
-
-            const start = a.source_len;
-            try a.addSourceByte(a.smith.valueWeighted(u8, alphanumeric_weights[1..]));
-            _ = a.variableChar(0, 0, &alphanumeric_weights);
-
-            if (Token.getKeyword(a.source_buf[start..a.source_len]) != null) {
-                a.source_buf[start] = '_'; // No keywords start with '_'
-            }
-        },
-        .quoted_identifier => {
-            try a.addTokenTag(.identifier);
-            try a.addSourceByte('@');
-            try a.stringLiteralSingleInner();
-        },
-        .copy_identifier => {
-            const n_prev = @min(a.prev_ids_len, a.prev_ids_buf.len);
-            const prev_i = a.smith.valueRangeLessThan(u16, 0, n_prev);
-            const prev = a.prev_ids_buf[prev_i];
-
-            if (a.source_buf[prev.start] != '@') try a.preservePegEndOfWord();
-            try a.addTokenTag(.identifier);
-            try a.addSource(a.source_buf[prev.start..][0..prev.len]);
-        },
-    }
-    try a.pegSkip();
-    if (kind != .copy_identifier) {
-        const start = a.token_start_buf[a.tokens_len - 1];
-        a.prev_ids_buf[a.prev_ids_len % a.prev_ids_buf.len] = .{
-            .start = @intCast(start),
-            .len = @intCast(a.source_len - start),
-        };
-        a.prev_ids_len += 1;
-    }
-}
-
-/// BUILTINIDENTIFIER <- '@'[A-Za-z_][A-Za-z0-9_]* skip
-fn pegBuiltinIdentifier(a: *AstSmith) SourceError!void {
-    try a.addTokenTag(.builtin);
-    if (a.smith.boolWeighted(1, 31)) {
-        if (a.smith.boolWeighted(1, 8)) {
-            // Pointer cast (reordable with zig fmt)
-            const ids = [_][]const u8{
-                "@ptrCast",
-                "@addrspaceCast",
-                "@alignCast",
-                "@constCast",
-                "@volatileCast",
-            };
-            try a.addSource(ids[a.smith.index(ids.len)]);
-        } else {
-            const ids = std.zig.BuiltinFn.list.keys();
-            try a.addSource(ids[a.smith.index(ids.len)]);
-        }
-    } else {
-        try a.ensureSourceCapacity(2);
-        a.addSourceByteAssumeCapacity('@');
-        a.addSourceByteAssumeCapacity(a.smith.valueWeighted(u8, alphanumeric_weights[1..]));
-        _ = a.variableChar(0, 0, &alphanumeric_weights);
-    }
-    try a.pegSkip();
-}
-
-test AstSmith {
-    try std.testing.fuzz({}, checkGenerated, .{});
-}
-
-fn checkGenerated(_: void, smith: *Smith) !void {
-    var a: AstSmith = .init(smith);
-    try a.generateSource();
-
-    { // Check tokenization matches source
-        errdefer a.logBadSource(null);
-
-        const token_tags = a.token_tag_buf[0..a.tokens_len];
-        const token_starts = a.token_start_buf[0..a.tokens_len];
-        try std.testing.expectEqual(Token.Tag.eof, token_tags[token_tags.len - 1]);
-
-        var tokenizer: std.zig.Tokenizer = .init(a.source());
-        for (token_tags, token_starts) |tag, start| {
-            const tok = tokenizer.next();
-            try std.testing.expectEqual(tok.tag, tag);
-            try std.testing.expectEqual(tok.loc.start, start);
-            if (tag == .invalid) return error.InvalidToken;
-        }
-    }
-
-    var fba_buf: [1 << 18]u8 = undefined;
-    var fba: std.heap.FixedBufferAllocator = .init(&fba_buf);
-    const ast = std.zig.Ast.parseTokens(fba.allocator(), a.source(), a.tokens(), .zig) catch
-        return error.SkipZigTest;
-
-    errdefer a.logBadSource(ast);
-    try std.testing.expectEqual(0, ast.errors.len);
-}
-
-fn logBadSource(a: *AstSmith, ast: ?std.zig.Ast) void {
-    var buf: [256]u8 = undefined;
-    const ls = std.debug.lockStderr(&buf);
-    defer std.debug.unlockStderr();
-    a.logBadSourceInner(ls.terminal(), ast) catch {};
-}
-
-fn logBadSourceInner(a: *AstSmith, t: std.Io.Terminal, ast: ?std.zig.Ast) std.Io.Writer.Error!void {
-    try a.logSourceInner(t);
-    const w = t.writer;
-
-    if (ast) |bad_ast| {
-        try w.writeAll("=== Parse Errors ===\n");
-        for (bad_ast.errors) |err| {
-            const loc = bad_ast.tokenLocation(0, err.token);
-            try w.print("{}:{}: ", .{ loc.line + 1, loc.column + 1 });
-            try bad_ast.renderError(err, w);
-            try w.writeByte('\n');
-        }
-    } else {
-        t.setColor(.dim) catch {};
-        try w.writeAll("=== Tokens ===\n");
-        t.setColor(.reset) catch {};
-        for (
-            0..,
-            a.token_tag_buf[0..a.tokens_len],
-            a.token_start_buf[0..a.tokens_len],
-        ) |i, tag, start| {
-            try w.print("#{} @{}: {t}\n", .{ i, start, tag });
-        }
-
-        t.setColor(.dim) catch {};
-        try w.writeAll("\n=== Expected Tokens ===\n");
-        t.setColor(.reset) catch {};
-
-        var tokenizer: std.zig.Tokenizer = .init(a.source());
-        var i: usize = 0;
-        while (true) {
-            const tok = tokenizer.next();
-            try w.print("#{} @{}-{}: {t}\n", .{ i, tok.loc.start, tok.loc.end, tok.tag });
-            i += 1;
-            if (tok.tag == .invalid or tok.tag == .eof) break;
-        }
-    }
-}
-
-pub fn logSource(a: *AstSmith) void {
-    var buf: [256]u8 = undefined;
-    const ls = std.debug.lockStderr(&buf);
-    defer std.debug.unlockStderr();
-    a.logSourceInner(ls.terminal()) catch {};
-}
-
-fn logSourceInner(a: *AstSmith, t: std.Io.Terminal) std.Io.Writer.Error!void {
-    const w = t.writer;
-
-    t.setColor(.dim) catch {};
-    try w.writeAll("=== Source ===\n");
-    t.setColor(.reset) catch {};
-
-    var line: usize = 1;
-    try w.print("{: >5} ", .{line});
-    for (a.source()) |c| switch (c) {
-        ' '...0x7e => try w.writeByte(c),
-        '\n' => {
-            line += 1;
-            try w.print("\n{: >5} ", .{line});
-        },
-        '\r' => {
-            t.setColor(.cyan) catch {};
-            try w.writeAll("\\r");
-            t.setColor(.reset) catch {};
-        },
-        '\t' => {
-            t.setColor(.cyan) catch {};
-            try w.writeAll("\\t");
-            t.setColor(.reset) catch {};
-        },
-        else => {
-            t.setColor(.cyan) catch {};
-            try w.print("\\x{x:0>2}", .{c});
-            t.setColor(.reset) catch {};
-        },
-    };
-    try w.writeByte('\n');
-}
diff --git a/lib/std/zig/Parse.zig b/lib/std/zig/Parse.zig
index d4c6015131d4c612633e3b87f8da61f0faeaf6a4..3d9883269d261d9437805d4b74e9a7b36d78b92a 100644
--- a/lib/std/zig/Parse.zig
+++ b/lib/std/zig/Parse.zig
@@ -1,5 +1,18 @@
 //! Represents in-progress parsing, will be converted to an Ast after completion.
 
+// This recursive descent parser must be "predictive," using only constant
+// token lookahead and never backtracking.
+//
+// This means that whenever the parser encounters a choice it is allowed to look
+// at the next k tokens in order to make that choice, where k is a fixed constant.
+//
+// Once the parser has made the choice, it must either succeed at parsing that sub
+// expression or fail entirely and present an error to the user. The parser is never
+// allowed to backtrack and make a different choice to see if that one succeeds.
+//
+// This ensures worst-case linear runtime rather than worst-case exponential runtime
+// and requires the Zig grammar to be LL(k).
+
 pub const Error = error{ParseError} || Allocator.Error;
 
 gpa: Allocator,
@@ -10,6 +23,7 @@ errors: std.ArrayList(AstError),
 nodes: Ast.NodeList,
 extra_data: std.ArrayList(u32),
 scratch: std.ArrayList(Node.Index),
+recover: bool,
 
 fn tokenTag(p: *const Parse, token_index: TokenIndex) Token.Tag {
     return p.tokens.items(.tag)[token_index];
@@ -108,7 +122,7 @@ fn addExtra(p: *Parse, extra: anytype) Allocator.Error!ExtraIndex {
     return result;
 }
 
-fn warnExpected(p: *Parse, expected_token: Token.Tag) error{OutOfMemory}!void {
+fn warnExpected(p: *Parse, expected_token: Token.Tag) Error!void {
     @branchHint(.cold);
     try p.warnMsg(.{
         .tag = .expected_token,
@@ -117,12 +131,12 @@ fn warnExpected(p: *Parse, expected_token: Token.Tag) error{OutOfMemory}!void {
     });
 }
 
-fn warn(p: *Parse, error_tag: AstError.Tag) error{OutOfMemory}!void {
+fn warn(p: *Parse, error_tag: AstError.Tag) Error!void {
     @branchHint(.cold);
     try p.warnMsg(.{ .tag = error_tag, .token = p.tok_i });
 }
 
-fn warnMsg(p: *Parse, msg: Ast.Error) error{OutOfMemory}!void {
+fn warnMsg(p: *Parse, msg: Ast.Error) Error!void {
     @branchHint(.cold);
     switch (msg.tag) {
         .expected_semi_after_decl,
@@ -161,11 +175,13 @@ fn warnMsg(p: *Parse, msg: Ast.Error) error{OutOfMemory}!void {
             var copy = msg;
             copy.token_is_prev = true;
             copy.token -= 1;
-            return p.errors.append(p.gpa, copy);
+            try p.errors.append(p.gpa, copy);
+        } else {
+            try p.errors.append(p.gpa, msg);
         },
-        else => {},
+        else => try p.errors.append(p.gpa, msg),
     }
-    try p.errors.append(p.gpa, msg);
+    if (!p.recover) return error.ParseError;
 }
 
 fn fail(p: *Parse, tag: Ast.Error.Tag) error{ ParseError, OutOfMemory } {
@@ -189,17 +205,29 @@ fn failMsg(p: *Parse, msg: Ast.Error) error{ ParseError, OutOfMemory } {
 }
 
 /// Root <- skip ContainerMembers eof
-pub fn parseRoot(p: *Parse) !void {
+pub fn parseRoot(p: *Parse) Allocator.Error!void {
     // Root node must be index 0.
     p.nodes.appendAssumeCapacity(.{
         .tag = .root,
         .main_token = 0,
         .data = undefined,
     });
-    const root_members = try p.parseContainerMembers();
+    const root_members = p.parseContainerMembers() catch |err| switch (err) {
+        error.OutOfMemory => |e| return e,
+        error.ParseError => {
+            assert(p.errors.items.len > 0);
+            return;
+        },
+    };
     const root_decls = try root_members.toSpan(p);
     if (p.tokenTag(p.tok_i) != .eof) {
-        try p.warnExpected(.eof);
+        p.warnExpected(.eof) catch |err| switch (err) {
+            error.OutOfMemory => |e| return e,
+            error.ParseError => {
+                assert(p.errors.items.len > 0);
+                return;
+            },
+        };
     }
     p.nodes.items(.data)[0] = .{ .extra_range = root_decls };
 }
@@ -207,7 +235,7 @@ pub fn parseRoot(p: *Parse) !void {
 /// Parse in ZON mode. Subset of the language.
 /// TODO: set a flag in Parse struct, and honor that flag
 /// by emitting compilation errors when non-zon nodes are encountered.
-pub fn parseZon(p: *Parse) !void {
+pub fn parseZon(p: *Parse) Allocator.Error!void {
     // We must use index 0 so that 0 can be used as null elsewhere.
     p.nodes.appendAssumeCapacity(.{
         .tag = .root,
@@ -222,7 +250,13 @@ pub fn parseZon(p: *Parse) !void {
         else => |e| return e,
     };
     if (p.tokenTag(p.tok_i) != .eof) {
-        try p.warnExpected(.eof);
+        p.warnExpected(.eof) catch |err| switch (err) {
+            error.OutOfMemory => |e| return e,
+            error.ParseError => {
+                assert(p.errors.items.len > 0);
+                return;
+            },
+        };
     }
     p.nodes.items(.data)[0] = .{ .node = node_index };
 }
@@ -232,7 +266,7 @@ pub fn parseZon(p: *Parse) !void {
 /// ContainerDeclaration <- TestDecl / ComptimeDecl / doc_comment? KEYWORD_pub? Decl
 ///
 /// ComptimeDecl <- KEYWORD_comptime Block
-fn parseContainerMembers(p: *Parse) Allocator.Error!Members {
+fn parseContainerMembers(p: *Parse) Error!Members {
     const scratch_top = p.scratch.items.len;
     defer p.scratch.shrinkRetainingCapacity(scratch_top);
 
@@ -300,13 +334,6 @@ fn parseContainerMembers(p: *Parse) Allocator.Error!Members {
                 else => {
                     const identifier = p.tok_i;
                     defer last_field = identifier;
-                    const container_field = p.expectContainerField() catch |err| switch (err) {
-                        error.OutOfMemory => |e| return e,
-                        error.ParseError => {
-                            p.findNextContainerMember();
-                            continue;
-                        },
-                    };
                     switch (field_state) {
                         .none => field_state = .seen,
                         .err, .seen => {},
@@ -329,6 +356,13 @@ fn parseContainerMembers(p: *Parse) Allocator.Error!Members {
                             field_state = .err;
                         },
                     }
+                    const container_field = p.expectContainerField() catch |err| switch (err) {
+                        error.OutOfMemory => |e| return e,
+                        error.ParseError => {
+                            p.findNextContainerMember();
+                            continue;
+                        },
+                    };
                     try p.scratch.append(p.gpa, container_field);
                     switch (p.tokenTag(p.tok_i)) {
                         .comma => {
@@ -405,13 +439,6 @@ fn parseContainerMembers(p: *Parse) Allocator.Error!Members {
 
                 const identifier = p.tok_i;
                 defer last_field = identifier;
-                const container_field = p.expectContainerField() catch |err| switch (err) {
-                    error.OutOfMemory => |e| return e,
-                    error.ParseError => {
-                        p.findNextContainerMember();
-                        continue;
-                    },
-                };
                 switch (field_state) {
                     .none => field_state = .seen,
                     .err, .seen => {},
@@ -434,6 +461,13 @@ fn parseContainerMembers(p: *Parse) Allocator.Error!Members {
                         field_state = .err;
                     },
                 }
+                const container_field = p.expectContainerField() catch |err| switch (err) {
+                    error.OutOfMemory => |e| return e,
+                    error.ParseError => {
+                        p.findNextContainerMember();
+                        continue;
+                    },
+                };
                 try p.scratch.append(p.gpa, container_field);
                 switch (p.tokenTag(p.tok_i)) {
                     .comma => {
@@ -484,6 +518,12 @@ fn parseContainerMembers(p: *Parse) Allocator.Error!Members {
 
 /// Attempts to find next container member by searching for certain tokens
 fn findNextContainerMember(p: *Parse) void {
+    if (!p.recover) {
+        while (p.tokenTag(p.tok_i) != .eof) {
+            p.tok_i += 1;
+        }
+        return;
+    }
     var level: u32 = 0;
     while (true) {
         const tok = p.nextToken();
@@ -541,6 +581,12 @@ fn findNextContainerMember(p: *Parse) void {
 
 /// Attempts to find the next statement by searching for a semicolon
 fn findNextStmt(p: *Parse) void {
+    if (!p.recover) {
+        while (p.tokenTag(p.tok_i) != .eof) {
+            p.tok_i += 1;
+        }
+        return;
+    }
     var level: u32 = 0;
     while (true) {
         const tok = p.nextToken();
@@ -864,7 +910,7 @@ fn parseGlobalVarDecl(p: *Parse) !?Node.Index {
     return var_decl;
 }
 
-/// ContainerField <- doc_comment? (KEYWORD_comptime / !KEYWORD_comptime) !KEYWORD_fn (IDENTIFIER COLON / !(IDENTIFIER COLON))? TypeExpr ByteAlign? (EQUAL Expr)?
+// ContainerField <- doc_comment? KEYWORD_comptime? (IDENTIFIER COLON)? TypeExpr ByteAlign? (EQUAL Expr)?
 fn expectContainerField(p: *Parse) !Node.Index {
     _ = p.eatToken(.keyword_comptime);
     const main_token = p.tok_i;
@@ -910,18 +956,21 @@ fn expectContainerField(p: *Parse) !Node.Index {
 ///     <- Statement
 ///      / KEYWORD_defer BlockExprStatement
 ///      / KEYWORD_errdefer BlockExprStatement
-///      / !ExprStatement (KEYWORD_comptime !BlockExpr)? VarAssignStatement
+///      / !StatementPrefix KEYWORD_comptime? VarAssignStatement
 ///
 /// Statement
-///     <- ExprStatement
-///      / KEYWORD_suspend BlockExprStatement
-///      / !ExprStatement (KEYWORD_comptime !BlockExpr)? AssignExpr SEMICOLON
-///
-/// ExprStatement
 ///     <- IfStatement
 ///      / LabeledStatement
 ///      / KEYWORD_nosuspend BlockExprStatement
 ///      / KEYWORD_comptime BlockExpr
+///      / KEYWORD_suspend BlockExprStatement
+///      / !StatementPrefix KEYWORD_comptime? AssignExpr SEMICOLON
+///
+/// StatementPrefix
+///     <- KEYWORD_if
+///      / BlockLabel? (LBRACE / KEYWORD_inline? (KEYWORD_for / KEYWORD_while) / KEYWORD_switch)
+///      / KEYWORD_nosuspend
+///      / KEYWORD_comptime BlockExprPrefix
 fn expectStatement(p: *Parse, is_block_level: bool) Error!Node.Index {
     if (p.eatToken(.keyword_comptime)) |comptime_token| {
         const opt_block_expr = try p.parseBlockExpr();
@@ -934,7 +983,7 @@ fn expectStatement(p: *Parse, is_block_level: bool) Error!Node.Index {
         }
 
         if (is_block_level) {
-            return p.expectVarDeclExprStatement(comptime_token);
+            return p.expectVarAssignStatement(comptime_token);
         } else {
             const assign = try p.expectAssignExpr();
             try p.expectSemicolon(.expected_semi_after_stmt, true);
@@ -995,7 +1044,7 @@ fn expectStatement(p: *Parse, is_block_level: bool) Error!Node.Index {
     if (try p.parseLabeledStatement()) |labeled_statement| return labeled_statement;
 
     if (is_block_level) {
-        return p.expectVarDeclExprStatement(null);
+        return p.expectVarAssignStatement(null);
     } else {
         const assign = try p.expectAssignExpr();
         try p.expectSemicolon(.expected_semi_after_stmt, true);
@@ -1003,30 +1052,8 @@ fn expectStatement(p: *Parse, is_block_level: bool) Error!Node.Index {
     }
 }
 
-/// ComptimeStatement
-///     <- BlockExpr
-///      / VarDeclExprStatement
-fn expectComptimeStatement(p: *Parse, comptime_token: TokenIndex) !Node.Index {
-    const maybe_block_expr = try p.parseBlockExpr();
-    if (maybe_block_expr) |block_expr| {
-        return p.addNode(.{
-            .tag = .@"comptime",
-            .main_token = comptime_token,
-            .data = .{
-                .lhs = .{ .node = block_expr },
-                .rhs = undefined,
-            },
-        });
-    }
-    return p.expectVarDeclExprStatement(comptime_token);
-}
-
-/// VarDeclExprStatement
-///    <- Expr
-///     / VarAssignStatement
-///
 /// VarAssignStatement <- (VarDeclProto / Expr) (COMMA (VarDeclProto / Expr))* EQUAL Expr SEMICOLON
-fn expectVarDeclExprStatement(p: *Parse, comptime_token: ?TokenIndex) !Node.Index {
+fn expectVarAssignStatement(p: *Parse, comptime_token: ?TokenIndex) !Node.Index {
     const scratch_top = p.scratch.items.len;
     defer p.scratch.shrinkRetainingCapacity(scratch_top);
 
@@ -1138,7 +1165,7 @@ fn expectVarDeclExprStatement(p: *Parse, comptime_token: ?TokenIndex) !Node.Inde
 
 /// If a parse error occurs, reports an error, but then finds the next statement
 /// and returns that one instead. If a parse error occurs but there is no following
-/// statement, returns 0.
+/// statement, returns null.
 fn expectStatementRecoverable(p: *Parse) Error!?Node.Index {
     while (true) {
         return p.expectStatement(true) catch |err| switch (err) {
@@ -1156,8 +1183,10 @@ fn expectStatementRecoverable(p: *Parse) Error!?Node.Index {
 }
 
 /// IfStatement
-///     <- IfPrefix BlockExpr ( KEYWORD_else Payload? Statement )?
-///      / IfPrefix !BlockExpr AssignExpr ( SEMICOLON / KEYWORD_else Payload? Statement )
+///     <- IfPrefix BlockExpr (KEYWORD_else Payload? Statement / !KEYWORD_else)
+///      / IfPrefix !BlockExprPrefix AssignExpr (SEMICOLON / KEYWORD_else Payload? Statement)
+///
+/// IfPrefix <- KEYWORD_if LPAREN Expr RPAREN PtrPayload?
 fn expectIfStatement(p: *Parse) !Node.Index {
     const if_token = p.assertToken(.keyword_if);
     _ = try p.expectToken(.l_paren);
@@ -1226,13 +1255,17 @@ fn parseLabeledStatement(p: *Parse) !?Node.Index {
     const label_token = opt_label_token orelse return null;
 
     const after_colon = p.tok_i;
-    if (try p.parseTypeExpr()) |_| {
-        const a = try p.parseByteAlign();
-        const b = try p.parseAddrSpace();
-        const c = try p.parseLinkSection();
-        const d = if (p.eatToken(.equal) == null) null else try p.expectExpr();
-        if (a != null or b != null or c != null or d != null) {
-            return p.failMsg(.{ .tag = .expected_var_const, .token = label_token });
+    // Don't bother trying to give a better error message if recovery is disabled.
+    // This avoids a possible stack overflow in e.g. parseTypeExpr() when fuzzing.
+    if (p.recover) {
+        if (try p.parseTypeExpr()) |_| {
+            const a = try p.parseByteAlign();
+            const b = try p.parseAddrSpace();
+            const c = try p.parseLinkSection();
+            const d = if (p.eatToken(.equal) == null) null else try p.expectExpr();
+            if (a != null or b != null or c != null or d != null) {
+                return p.failMsg(.{ .tag = .expected_var_const, .token = label_token });
+            }
         }
     }
     return p.failMsg(.{ .tag = .expected_labelable, .token = after_colon });
@@ -1252,8 +1285,8 @@ fn parseLoopStatement(p: *Parse) !?Node.Index {
 }
 
 /// ForStatement
-///     <- ForPrefix BlockExpr ( KEYWORD_else Statement / !KEYWORD_else )
-///      / ForPrefix !BlockExpr AssignExpr ( SEMICOLON / KEYWORD_else Statement )
+///     <- ForPrefix BlockExpr (KEYWORD_else Statement / !KEYWORD_else)
+///      / ForPrefix !BlockExprPrefix AssignExpr (SEMICOLON / KEYWORD_else Statement)
 fn parseForStatement(p: *Parse) !?Node.Index {
     const for_token = p.eatToken(.keyword_for) orelse return null;
 
@@ -1309,8 +1342,8 @@ fn parseForStatement(p: *Parse) !?Node.Index {
 /// WhilePrefix <- KEYWORD_while LPAREN Expr RPAREN PtrPayload? WhileContinueExpr?
 ///
 /// WhileStatement
-///     <- WhilePrefix BlockExpr ( KEYWORD_else Payload? Statement )?
-///      / WhilePrefix !BlockExpr AssignExpr ( SEMICOLON / KEYWORD_else Payload? Statement )
+///     <- WhilePrefix BlockExpr (KEYWORD_else Payload? Statement / !KEYWORD_else)
+///      / WhilePrefix !BlockExprPrefix AssignExpr (SEMICOLON / KEYWORD_else Payload? Statement)
 fn parseWhileStatement(p: *Parse) !?Node.Index {
     const while_token = p.eatToken(.keyword_while) orelse return null;
     _ = try p.expectToken(.l_paren);
@@ -1400,7 +1433,7 @@ fn parseWhileStatement(p: *Parse) !?Node.Index {
 
 /// BlockExprStatement
 ///     <- BlockExpr
-///      / !BlockExpr AssignExpr SEMICOLON
+///      / !BlockExprPrefix AssignExpr SEMICOLON
 fn parseBlockExprStatement(p: *Parse) !?Node.Index {
     const block_expr = try p.parseBlockExpr();
     if (block_expr) |expr| return expr;
@@ -1434,7 +1467,7 @@ fn parseBlockExpr(p: *Parse) Error!?Node.Index {
     }
 }
 
-/// AssignExpr <- Expr (AssignOp Expr / (COMMA Expr)+ EQUAL Expr)?
+/// AssignExpr <- Expr (AssignOp Expr / (COMMA Expr)+ EQUAL Expr / !AssignOp !COMMA)
 ///
 /// AssignOp
 ///     <- ASTERISKEQUAL
@@ -1460,7 +1493,7 @@ fn parseAssignExpr(p: *Parse) !?Node.Index {
     return try p.finishAssignExpr(expr);
 }
 
-/// SingleAssignExpr <- Expr (AssignOp Expr)?
+/// SingleAssignExpr <- Expr (AssignOp Expr / !AssignOp)
 fn parseSingleAssignExpr(p: *Parse) !?Node.Index {
     const lhs = try p.parseExpr() orelse return null;
     const tag = assignOpNode(p.tokenTag(p.tok_i)) orelse return lhs;
@@ -1634,13 +1667,17 @@ fn parseExprPrecedence(p: *Parse, min_prec: i32) Error!?Node.Index {
         if (tok_tag == .keyword_catch) {
             _ = try p.parsePayload();
         }
-        const rhs = try p.parseExprPrecedence(info.prec + 1) orelse {
-            try p.warn(.expected_expr);
-            return node;
-        };
 
+        // Check for whitespace error before parsing the rhs to facilitate fuzzing.
+        // Consider the case where there is a mismatched whitespace error but the rhs
+        // expression triggers stack overflow when parsing is attempted. In this case
+        // we want to return with an error rather than crashing on stack overflow.
         {
             const tok_len = tok_tag.lexeme().?.len;
+            if (p.tokenStart(oper_token) + tok_len >= p.source.len) {
+                try p.warn(.expected_expr);
+                return node;
+            }
             const char_before = p.source[p.tokenStart(oper_token) - 1];
             const char_after = p.source[p.tokenStart(oper_token) + tok_len];
             if (tok_tag == .ampersand and char_after == '&') {
@@ -1652,6 +1689,11 @@ fn parseExprPrecedence(p: *Parse, min_prec: i32) Error!?Node.Index {
             }
         }
 
+        const rhs = try p.parseExprPrecedence(info.prec + 1) orelse {
+            try p.warn(.expected_expr);
+            return node;
+        };
+
         node = try p.addNode(.{
             .tag = info.tag,
             .main_token = oper_token,
@@ -1666,7 +1708,7 @@ fn parseExprPrecedence(p: *Parse, min_prec: i32) Error!?Node.Index {
     return node;
 }
 
-/// PrefixExpr <- PrefixOp* PrimaryExpr
+/// PrefixExpr <- PrefixOp* PrimaryExpr / !PrefixOp
 ///
 /// PrefixOp
 ///     <- EXCLAMATIONMARK
@@ -1696,25 +1738,28 @@ fn expectPrefixExpr(p: *Parse) Error!Node.Index {
     return try p.parsePrefixExpr() orelse return p.fail(.expected_prefix_expr);
 }
 
-/// TypeExpr <- PrefixTypeOp* ErrorUnionExpr
+/// TypeExpr <- PrefixTypeOp* !PrefixTypeOpPrefix ErrorUnionExpr
 ///
 /// PrefixTypeOp
 ///     <- QUESTIONMARK
 ///      / KEYWORD_anyframe MINUSRARROW
-///      / (ManyPtrTypeStart / SliceTypeStart) KEYWORD_allowzero? ByteAlign? AddrSpace? KEYWORD_const? KEYWORD_volatile?
-///      / SinglePtrTypeStart KEYWORD_allowzero? BitAlign? AddrSpace? KEYWORD_const? KEYWORD_volatile?
-///      / PtrTypeStart (AddrSpace / KEYWORD_align LPAREN Expr (COLON Expr COLON Expr)? RPAREN / KEYWORD_const / KEYWORD_volatile / KEYWORD_allowzero)*
+///      / (ManyPtrTypeStart / SliceTypeStart) PtrMods
+///      / SinglePtrTypeStart SinglePtrMods
 ///      / ArrayTypeStart
 ///
+/// PrefixTypeOpPrefix
+///     <- QUESTIONMARK
+///      / KEYWORD_anyframe MINUSRARROW
+///      / LBRACKET
+///      / ASTERISK
+///
 /// SliceTypeStart <- LBRACKET (COLON Expr)? RBRACKET
 ///
 /// SinglePtrTypeStart <- ASTERISK
 ///
 /// ManyPtrTypeStart <- LBRACKET ASTERISK (LETTERC / COLON Expr)? RBRACKET
 ///
-/// ArrayTypeStart <- LBRACKET Expr !ASTERISK (COLON Expr)? RBRACKET
-///
-/// BitAlign <- KEYWORD_align LPAREN Expr (COLON Expr COLON Expr)? RPAREN
+/// ArrayTypeStart <- LBRACKET !ASTERISK Expr (COLON Expr)? RBRACKET
 fn parseTypeExpr(p: *Parse) Error!?Node.Index {
     switch (p.tokenTag(p.tok_i)) {
         .question_mark => return try p.addNode(.{
@@ -1735,7 +1780,7 @@ fn parseTypeExpr(p: *Parse) Error!?Node.Index {
         },
         .asterisk => {
             const asterisk = p.nextToken();
-            const mods = try p.parsePtrModifiers();
+            const mods = try p.parsePtrModifiers(.bit_align);
             const elem_type = try p.expectTypeExpr();
             if (mods.bit_range_start != .none) {
                 return try p.addNode(.{
@@ -1790,14 +1835,8 @@ fn parseTypeExpr(p: *Parse) Error!?Node.Index {
                     sentinel = try p.expectExpr();
                 }
                 _ = try p.expectToken(.r_bracket);
-                const mods = try p.parsePtrModifiers();
+                const mods = try p.parsePtrModifiers(.byte_align);
                 const elem_type = try p.expectTypeExpr();
-                if (mods.bit_range_start.unwrap()) |bit_range_start| {
-                    try p.warnMsg(.{
-                        .tag = .invalid_bit_range,
-                        .token = p.nodeMainToken(bit_range_start),
-                    });
-                }
                 if (sentinel == null and mods.addrspace_node == .none) {
                     return try p.addNode(.{
                         .tag = .ptr_type_aligned,
@@ -1840,14 +1879,8 @@ fn parseTypeExpr(p: *Parse) Error!?Node.Index {
                     null;
                 _ = try p.expectToken(.r_bracket);
                 if (len_expr == null) {
-                    const mods = try p.parsePtrModifiers();
+                    const mods = try p.parsePtrModifiers(.byte_align);
                     const elem_type = try p.expectTypeExpr();
-                    if (mods.bit_range_start.unwrap()) |bit_range_start| {
-                        try p.warnMsg(.{
-                            .tag = .invalid_bit_range,
-                            .token = p.nodeMainToken(bit_range_start),
-                        });
-                    }
                     if (sentinel == null and mods.addrspace_node == .none) {
                         return try p.addNode(.{
                             .tag = .ptr_type_aligned,
@@ -1927,19 +1960,19 @@ fn expectTypeExpr(p: *Parse) Error!Node.Index {
 /// PrimaryExpr
 ///     <- AsmExpr
 ///      / IfExpr
-///      / KEYWORD_break (BreakLabel / !BreakLabel) (Expr !ExprSuffix / !SinglePtrTypeStart)
-///      / KEYWORD_comptime Expr !ExprSuffix
-///      / KEYWORD_nosuspend Expr !ExprSuffix
-///      / KEYWORD_continue (BreakLabel / !BreakLabel) (Expr !ExprSuffix / !SinglePtrTypeStart)
-///      / KEYWORD_resume Expr !ExprSuffix
-///      / KEYWORD_return (Expr !ExprSuffix / !SinglePtrTypeStart)
+///      / KEYWORD_break BreakLabel? Expr?
+///      / KEYWORD_comptime Expr
+///      / KEYWORD_nosuspend Expr
+///      / KEYWORD_continue BreakLabel? Expr?
+///      / KEYWORD_resume Expr
+///      / KEYWORD_return Expr?
 ///      / BlockLabel? LoopExpr
 ///      / Block
 ///      / CurlySuffixExpr
 fn parsePrimaryExpr(p: *Parse) !?Node.Index {
     switch (p.tokenTag(p.tok_i)) {
         .keyword_asm => return try p.expectAsmExpr(),
-        .keyword_if => return try p.parseIfExpr(),
+        .keyword_if => return try p.expectIf(expectExpr),
         .keyword_break => {
             return try p.addNode(.{
                 .tag = .@"break",
@@ -1994,18 +2027,18 @@ fn parsePrimaryExpr(p: *Parse) !?Node.Index {
                     .keyword_inline => {
                         p.tok_i += 3;
                         switch (p.tokenTag(p.tok_i)) {
-                            .keyword_for => return try p.parseFor(expectExpr),
-                            .keyword_while => return try p.parseWhileExpr(),
+                            .keyword_for => return try p.expectFor(expectExpr),
+                            .keyword_while => return try p.expectWhileExpr(),
                             else => return p.fail(.expected_inlinable),
                         }
                     },
                     .keyword_for => {
                         p.tok_i += 2;
-                        return try p.parseFor(expectExpr);
+                        return try p.expectFor(expectExpr);
                     },
                     .keyword_while => {
                         p.tok_i += 2;
-                        return try p.parseWhileExpr();
+                        return try p.expectWhileExpr();
                     },
                     else => return try p.parseCurlySuffixExpr(),
                 }
@@ -2016,23 +2049,18 @@ fn parsePrimaryExpr(p: *Parse) !?Node.Index {
         .keyword_inline => {
             p.tok_i += 1;
             switch (p.tokenTag(p.tok_i)) {
-                .keyword_for => return try p.parseFor(expectExpr),
-                .keyword_while => return try p.parseWhileExpr(),
+                .keyword_for => return try p.expectFor(expectExpr),
+                .keyword_while => return try p.expectWhileExpr(),
                 else => return p.fail(.expected_inlinable),
             }
         },
-        .keyword_for => return try p.parseFor(expectExpr),
-        .keyword_while => return try p.parseWhileExpr(),
+        .keyword_for => return try p.expectFor(expectExpr),
+        .keyword_while => return try p.expectWhileExpr(),
         .l_brace => return try p.parseBlock(),
         else => return try p.parseCurlySuffixExpr(),
     }
 }
 
-/// IfExpr <- IfPrefix Expr (KEYWORD_else Payload? Expr)? !ExprSuffix
-fn parseIfExpr(p: *Parse) !?Node.Index {
-    return try p.parseIf(expectExpr);
-}
-
 /// Block <- LBRACE BlockStatement* RBRACE
 fn parseBlock(p: *Parse) !?Node.Index {
     const lbrace = p.eatToken(.l_brace) orelse return null;
@@ -2106,16 +2134,9 @@ fn forPrefix(p: *Parse) Error!usize {
         return inputs;
     };
 
-    var warned_excess = false;
-    var captures: u32 = 0;
     while (true) {
         _ = p.eatToken(.asterisk);
-        const identifier = try p.expectToken(.identifier);
-        captures += 1;
-        if (captures > inputs and !warned_excess) {
-            try p.warnMsg(.{ .tag = .extra_for_capture, .token = identifier });
-            warned_excess = true;
-        }
+        _ = try p.expectToken(.identifier);
         switch (p.tokenTag(p.tok_i)) {
             .comma => p.tok_i += 1,
             .pipe => {
@@ -2128,19 +2149,14 @@ fn forPrefix(p: *Parse) Error!usize {
         if (p.eatToken(.pipe)) |_| break;
     }
 
-    if (captures < inputs) {
-        const index = p.scratch.items.len - captures;
-        const input = p.nodeMainToken(p.scratch.items[index]);
-        try p.warnMsg(.{ .tag = .for_input_not_captured, .token = input });
-    }
     return inputs;
 }
 
 /// WhilePrefix <- KEYWORD_while LPAREN Expr RPAREN PtrPayload? WhileContinueExpr?
 ///
 /// WhileExpr <- WhilePrefix Expr (KEYWORD_else Payload? Expr)? !ExprSuffi
-fn parseWhileExpr(p: *Parse) !?Node.Index {
-    const while_token = p.eatToken(.keyword_while) orelse return null;
+fn expectWhileExpr(p: *Parse) !Node.Index {
+    const while_token = p.assertToken(.keyword_while);
     _ = try p.expectToken(.l_paren);
     const condition = try p.expectExpr();
     _ = try p.expectToken(.r_paren);
@@ -2188,7 +2204,7 @@ fn parseWhileExpr(p: *Parse) !?Node.Index {
     });
 }
 
-/// CurlySuffixExpr <- TypeExpr InitList?
+/// CurlySuffixExpr <- TypeExpr (InitList / !LBRACE)
 ///
 /// InitList
 ///     <- LBRACE FieldInit (COMMA FieldInit)* COMMA? RBRACE
@@ -2290,7 +2306,7 @@ fn parseCurlySuffixExpr(p: *Parse) !?Node.Index {
     }
 }
 
-/// ErrorUnionExpr <- SuffixExpr (EXCLAMATIONMARK TypeExpr)?
+/// ErrorUnionExpr <- SuffixExpr (EXCLAMATIONMARK TypeExpr / !EXCLAMATIONMARK)
 fn parseErrorUnionExpr(p: *Parse) !?Node.Index {
     const suffix_expr = try p.parseSuffixExpr() orelse return null;
     const bang = p.eatToken(.bang) orelse return suffix_expr;
@@ -2304,59 +2320,13 @@ fn parseErrorUnionExpr(p: *Parse) !?Node.Index {
     });
 }
 
-/// SuffixExpr
-///     <- PrimaryTypeExpr (SuffixOp / FnCallArguments)*
-///
-/// FnCallArguments <- LPAREN ExprList RPAREN
-///
-/// ExprList <- (Expr COMMA)* Expr?
+/// SuffixExpr <- PrimaryTypeExpr SuffixOp* !SuffixOpPrefix
 fn parseSuffixExpr(p: *Parse) !?Node.Index {
     var res = try p.parsePrimaryTypeExpr() orelse return null;
-    while (true) {
-        const opt_suffix_op = try p.parseSuffixOp(res);
-        if (opt_suffix_op) |suffix_op| {
-            res = suffix_op;
-            continue;
-        }
-        const lparen = p.eatToken(.l_paren) orelse return res;
-        const scratch_top = p.scratch.items.len;
-        defer p.scratch.shrinkRetainingCapacity(scratch_top);
-        while (true) {
-            if (p.eatToken(.r_paren)) |_| break;
-            const param = try p.expectExpr();
-            try p.scratch.append(p.gpa, param);
-            switch (p.tokenTag(p.tok_i)) {
-                .comma => p.tok_i += 1,
-                .r_paren => {
-                    p.tok_i += 1;
-                    break;
-                },
-                .colon, .r_brace, .r_bracket => return p.failExpected(.r_paren),
-                // Likely just a missing comma; give error but continue parsing.
-                else => try p.warn(.expected_comma_after_arg),
-            }
-        }
-        const comma = (p.tokenTag(p.tok_i - 2)) == .comma;
-        const params = p.scratch.items[scratch_top..];
-        res = switch (params.len) {
-            0, 1 => try p.addNode(.{
-                .tag = if (comma) .call_one_comma else .call_one,
-                .main_token = lparen,
-                .data = .{ .node_and_opt_node = .{
-                    res,
-                    if (params.len >= 1) .fromOptional(params[0]) else .none,
-                } },
-            }),
-            else => try p.addNode(.{
-                .tag = if (comma) .call_comma else .call,
-                .main_token = lparen,
-                .data = .{ .node_and_extra = .{
-                    res,
-                    try p.addExtra(try p.listToSpan(params)),
-                } },
-            }),
-        };
+    while (try p.parseSuffixOp(res)) |suffix_op| {
+        res = suffix_op;
     }
+    return res;
 }
 
 /// PrimaryTypeExpr
@@ -2366,17 +2336,16 @@ fn parseSuffixExpr(p: *Parse) !?Node.Index {
 ///      / DOT IDENTIFIER
 ///      / DOT InitList
 ///      / ErrorSetDecl
-///      / FLOAT
 ///      / FnProto
 ///      / GroupedExpr
 ///      / LabeledTypeExpr
-///      / IDENTIFIER !(COLON LabelableExpr)
+///      / IDENTIFIER
 ///      / IfTypeExpr
-///      / INTEGER
-///      / KEYWORD_comptime TypeExpr !ExprSuffix
+///      / KEYWORD_comptime TypeExpr
 ///      / KEYWORD_error DOT IDENTIFIER
 ///      / KEYWORD_anyframe
 ///      / KEYWORD_unreachable
+///      / NUMBERLITERAL
 ///      / STRINGLITERAL
 ///
 /// ContainerDecl <- (KEYWORD_extern / KEYWORD_packed)? ContainerDeclAuto
@@ -2431,23 +2400,23 @@ fn parsePrimaryTypeExpr(p: *Parse) !?Node.Index {
             });
         },
 
-        .builtin => return try p.parseBuiltinCall(),
-        .keyword_fn => return try p.parseFnProto(),
-        .keyword_if => return try p.parseIf(expectTypeExpr),
+        .builtin => return try p.expectBuiltinCall(),
+        .keyword_fn => return (try p.parseFnProto()).?,
+        .keyword_if => return try p.expectIf(expectTypeExpr),
         .keyword_switch => return try p.expectSwitchExpr(false),
 
         .keyword_extern,
         .keyword_packed,
         => {
             p.tok_i += 1;
-            return try p.parseContainerDeclAuto();
+            return try p.expectContainerDeclAuto();
         },
 
         .keyword_struct,
         .keyword_opaque,
         .keyword_enum,
         .keyword_union,
-        => return try p.parseContainerDeclAuto(),
+        => return try p.expectContainerDeclAuto(),
 
         .keyword_comptime => return try p.addNode(.{
             .tag = .@"comptime",
@@ -2473,18 +2442,18 @@ fn parsePrimaryTypeExpr(p: *Parse) !?Node.Index {
                 .keyword_inline => {
                     p.tok_i += 3;
                     switch (p.tokenTag(p.tok_i)) {
-                        .keyword_for => return try p.parseFor(expectTypeExpr),
-                        .keyword_while => return try p.parseWhileTypeExpr(),
+                        .keyword_for => return try p.expectFor(expectTypeExpr),
+                        .keyword_while => return try p.expectWhileTypeExpr(),
                         else => return p.fail(.expected_inlinable),
                     }
                 },
                 .keyword_for => {
                     p.tok_i += 2;
-                    return try p.parseFor(expectTypeExpr);
+                    return try p.expectFor(expectTypeExpr);
                 },
                 .keyword_while => {
                     p.tok_i += 2;
-                    return try p.parseWhileTypeExpr();
+                    return try p.expectWhileTypeExpr();
                 },
                 .keyword_switch => {
                     p.tok_i += 2;
@@ -2492,7 +2461,7 @@ fn parsePrimaryTypeExpr(p: *Parse) !?Node.Index {
                 },
                 .l_brace => {
                     p.tok_i += 2;
-                    return try p.parseBlock();
+                    return (try p.parseBlock()).?;
                 },
                 else => return try p.addNode(.{
                     .tag = .identifier,
@@ -2509,13 +2478,13 @@ fn parsePrimaryTypeExpr(p: *Parse) !?Node.Index {
         .keyword_inline => {
             p.tok_i += 1;
             switch (p.tokenTag(p.tok_i)) {
-                .keyword_for => return try p.parseFor(expectTypeExpr),
-                .keyword_while => return try p.parseWhileTypeExpr(),
+                .keyword_for => return try p.expectFor(expectTypeExpr),
+                .keyword_while => return try p.expectWhileTypeExpr(),
                 else => return p.fail(.expected_inlinable),
             }
         },
-        .keyword_for => return try p.parseFor(expectTypeExpr),
-        .keyword_while => return try p.parseWhileTypeExpr(),
+        .keyword_for => return try p.expectFor(expectTypeExpr),
+        .keyword_while => return try p.expectWhileTypeExpr(),
         .period => switch (p.tokenTag(p.tok_i + 1)) {
             .identifier => {
                 p.tok_i += 1;
@@ -2643,10 +2612,8 @@ fn parsePrimaryTypeExpr(p: *Parse) !?Node.Index {
             },
             else => {
                 const main_token = p.nextToken();
-                const period = p.eatToken(.period);
-                if (period == null) return p.failExpected(.period);
-                const identifier = p.eatToken(.identifier);
-                if (identifier == null) return p.failExpected(.identifier);
+                _ = try p.expectToken(.period);
+                _ = try p.expectToken(.identifier);
                 return try p.addNode(.{
                     .tag = .error_value,
                     .main_token = main_token,
@@ -2672,9 +2639,9 @@ fn expectPrimaryTypeExpr(p: *Parse) !Node.Index {
 
 /// WhilePrefix <- KEYWORD_while LPAREN Expr RPAREN PtrPayload? WhileContinueExpr?
 ///
-/// WhileTypeExpr <- WhilePrefix TypeExpr (KEYWORD_else Payload? TypeExpr)? !ExprSuffix
-fn parseWhileTypeExpr(p: *Parse) !?Node.Index {
-    const while_token = p.eatToken(.keyword_while) orelse return null;
+/// WhileTypeExpr <- WhilePrefix TypeExpr (KEYWORD_else Payload? TypeExpr / !KEYWORD_else)
+fn expectWhileTypeExpr(p: *Parse) !Node.Index {
+    const while_token = p.assertToken(.keyword_while);
     _ = try p.expectToken(.l_paren);
     const condition = try p.expectExpr();
     _ = try p.expectToken(.r_paren);
@@ -3076,16 +3043,29 @@ const PtrModifiers = struct {
     bit_range_end: Node.OptionalIndex,
 };
 
-fn parsePtrModifiers(p: *Parse) !PtrModifiers {
+/// PtrMods
+///    <- PtrMod* ByteAlign? PtrMod* AddrSpace? PtrMod*
+///     / PtrMod* AddrSpace? PtrMod* ByteAlign? PtrMod*
+///
+/// SinglePtrMods
+///    <- PtrMod* BitAlign? PtrMod* AddrSpace? PtrMod*
+///     / PtrMod* AddrSpace? PtrMod* BitAlign? PtrMod*
+///
+/// PtrMod
+///     <- KEYWORD_allowzero
+///      / KEYWORD_const
+///      / KEYWORD_volatile
+///
+/// AddrSpace <- KEYWORD_addrspace LPAREN Expr RPAREN
+/// ByteAlign <- KEYWORD_align LPAREN Expr RPAREN
+/// BitAlign <- KEYWORD_align LPAREN Expr (COLON Expr COLON Expr)? RPAREN
+fn parsePtrModifiers(p: *Parse, align_type: enum { bit_align, byte_align }) !PtrModifiers {
     var result: PtrModifiers = .{
         .align_node = .none,
         .addrspace_node = .none,
         .bit_range_start = .none,
         .bit_range_end = .none,
     };
-    var saw_const = false;
-    var saw_volatile = false;
-    var saw_allowzero = false;
     while (true) {
         switch (p.tokenTag(p.tok_i)) {
             .keyword_align => {
@@ -3096,7 +3076,10 @@ fn parsePtrModifiers(p: *Parse) !PtrModifiers {
                 _ = try p.expectToken(.l_paren);
                 result.align_node = (try p.expectExpr()).toOptional();
 
-                if (p.eatToken(.colon)) |_| {
+                if (p.eatToken(.colon)) |colon| {
+                    if (align_type == .byte_align) {
+                        try p.warnMsg(.{ .tag = .invalid_bit_range, .token = colon });
+                    }
                     result.bit_range_start = (try p.expectExpr()).toOptional();
                     _ = try p.expectToken(.colon);
                     result.bit_range_end = (try p.expectExpr()).toOptional();
@@ -3104,33 +3087,16 @@ fn parsePtrModifiers(p: *Parse) !PtrModifiers {
 
                 _ = try p.expectToken(.r_paren);
             },
-            .keyword_const => {
-                if (saw_const) {
-                    try p.warn(.extra_const_qualifier);
-                }
-                p.tok_i += 1;
-                saw_const = true;
-            },
-            .keyword_volatile => {
-                if (saw_volatile) {
-                    try p.warn(.extra_volatile_qualifier);
-                }
-                p.tok_i += 1;
-                saw_volatile = true;
-            },
-            .keyword_allowzero => {
-                if (saw_allowzero) {
-                    try p.warn(.extra_allowzero_qualifier);
-                }
-                p.tok_i += 1;
-                saw_allowzero = true;
-            },
             .keyword_addrspace => {
                 if (result.addrspace_node != .none) {
                     try p.warn(.extra_addrspace_qualifier);
                 }
                 result.addrspace_node = .fromOptional(try p.parseAddrSpace());
             },
+            .keyword_allowzero,
+            .keyword_const,
+            .keyword_volatile,
+            => p.tok_i += 1,
             else => return result,
         }
     }
@@ -3140,7 +3106,12 @@ fn parsePtrModifiers(p: *Parse) !PtrModifiers {
 ///     <- LBRACKET Expr (DOT2 Expr? (COLON Expr)?)? RBRACKET
 ///      / DOT IDENTIFIER
 ///      / DOTASTERISK
-///      / DOTQUESTIONMARK
+///      / DOT QUESTIONMARK
+///      / FnCallArguments
+///
+/// FnCallArguments <- LPAREN ExprList RPAREN
+///
+/// ExprList <- (Expr COMMA)* Expr?
 fn parseSuffixOp(p: *Parse, lhs: Node.Index) !?Node.Index {
     switch (p.tokenTag(p.tok_i)) {
         .l_bracket => {
@@ -3230,6 +3201,46 @@ fn parseSuffixOp(p: *Parse, lhs: Node.Index) !?Node.Index {
                 return null;
             },
         },
+        .l_paren => {
+            const lparen = p.nextToken();
+            const scratch_top = p.scratch.items.len;
+            defer p.scratch.shrinkRetainingCapacity(scratch_top);
+            while (true) {
+                if (p.eatToken(.r_paren)) |_| break;
+                const param = try p.expectExpr();
+                try p.scratch.append(p.gpa, param);
+                switch (p.tokenTag(p.tok_i)) {
+                    .comma => p.tok_i += 1,
+                    .r_paren => {
+                        p.tok_i += 1;
+                        break;
+                    },
+                    .colon, .r_brace, .r_bracket => return p.failExpected(.r_paren),
+                    // Likely just a missing comma; give error but continue parsing.
+                    else => try p.warn(.expected_comma_after_arg),
+                }
+            }
+            const comma = (p.tokenTag(p.tok_i - 2)) == .comma;
+            const params = p.scratch.items[scratch_top..];
+            switch (params.len) {
+                0, 1 => return try p.addNode(.{
+                    .tag = if (comma) .call_one_comma else .call_one,
+                    .main_token = lparen,
+                    .data = .{ .node_and_opt_node = .{
+                        lhs,
+                        if (params.len >= 1) .fromOptional(params[0]) else .none,
+                    } },
+                }),
+                else => return try p.addNode(.{
+                    .tag = if (comma) .call_comma else .call,
+                    .main_token = lparen,
+                    .data = .{ .node_and_extra = .{
+                        lhs,
+                        try p.addExtra(try p.listToSpan(params)),
+                    } },
+                }),
+            }
+        },
         else => return null,
     }
 }
@@ -3243,7 +3254,7 @@ fn parseSuffixOp(p: *Parse, lhs: Node.Index) !?Node.Index {
 ///      / KEYWORD_opaque
 ///      / KEYWORD_enum (LPAREN Expr RPAREN)?
 ///      / KEYWORD_union (LPAREN (KEYWORD_enum (LPAREN Expr RPAREN)? / Expr) RPAREN)?
-fn parseContainerDeclAuto(p: *Parse) !?Node.Index {
+fn expectContainerDeclAuto(p: *Parse) !Node.Index {
     const main_token = p.nextToken();
     const arg_expr = switch (p.tokenTag(main_token)) {
         .keyword_opaque => null,
@@ -3366,6 +3377,7 @@ fn parseContainerDeclAuto(p: *Parse) !?Node.Index {
 /// Give a helpful error message for those transitioning from
 /// C's 'struct Foo {};' to Zig's 'const Foo = struct {};'.
 fn parseCStyleContainer(p: *Parse) Error!bool {
+    if (!p.recover) return false;
     const main_token = p.tok_i;
     switch (p.tokenTag(p.tok_i)) {
         .keyword_enum, .keyword_union, .keyword_struct => {},
@@ -3431,10 +3443,13 @@ fn parseParamDeclList(p: *Parse) !SmallSpan {
     _ = try p.expectToken(.l_paren);
     const scratch_top = p.scratch.items.len;
     defer p.scratch.shrinkRetainingCapacity(scratch_top);
-    var varargs: union(enum) { none, seen, nonfinal: TokenIndex } = .none;
+    var varargs: enum { none, seen, err } = .none;
     while (true) {
         if (p.eatToken(.r_paren)) |_| break;
-        if (varargs == .seen) varargs = .{ .nonfinal = p.tok_i };
+        if (varargs == .seen) {
+            try p.warnMsg(.{ .tag = .varargs_nonfinal, .token = p.tok_i });
+            varargs = .err;
+        }
         const opt_param = try p.expectParamDecl();
         if (opt_param) |param| {
             try p.scratch.append(p.gpa, param);
@@ -3452,9 +3467,6 @@ fn parseParamDeclList(p: *Parse) !SmallSpan {
             else => try p.warn(.expected_comma_after_param),
         }
     }
-    if (varargs == .nonfinal) {
-        try p.warnMsg(.{ .tag = .varargs_nonfinal, .token = varargs.nonfinal });
-    }
     const params = p.scratch.items[scratch_top..];
     return switch (params.len) {
         0 => .{ .zero_or_one = .none },
@@ -3466,7 +3478,7 @@ fn parseParamDeclList(p: *Parse) !SmallSpan {
 /// FnCallArguments <- LPAREN ExprList RPAREN
 ///
 /// ExprList <- (Expr COMMA)* Expr?
-fn parseBuiltinCall(p: *Parse) !Node.Index {
+fn expectBuiltinCall(p: *Parse) !Node.Index {
     const builtin_token = p.assertToken(.builtin);
     _ = p.eatToken(.l_paren) orelse {
         try p.warn(.expected_param_list);
@@ -3514,9 +3526,13 @@ fn parseBuiltinCall(p: *Parse) !Node.Index {
     }
 }
 
+/// IfExpr <- IfPrefix Expr (KEYWORD_else Payload? Expr / !KEYWORD_else)
+///
+/// IfTypeExpr <- IfPrefix TypeExpr (KEYWORD_else Payload? TypeExpr / !KEYWORD_else)
+///
 /// IfPrefix <- KEYWORD_if LPAREN Expr RPAREN PtrPayload?
-fn parseIf(p: *Parse, comptime bodyParseFn: fn (p: *Parse) Error!Node.Index) !?Node.Index {
-    const if_token = p.eatToken(.keyword_if) orelse return null;
+fn expectIf(p: *Parse, comptime bodyParseFn: fn (p: *Parse) Error!Node.Index) !Node.Index {
+    const if_token = p.assertToken(.keyword_if);
     _ = try p.expectToken(.l_paren);
     const condition = try p.expectExpr();
     _ = try p.expectToken(.r_paren);
@@ -3548,11 +3564,11 @@ fn parseIf(p: *Parse, comptime bodyParseFn: fn (p: *Parse) Error!Node.Index) !?N
     });
 }
 
-/// ForExpr <- ForPrefix Expr (KEYWORD_else Expr / !KEYWORD_else) !ExprSuffix
+/// ForExpr <- ForPrefix Expr (KEYWORD_else Expr / !KEYWORD_else)
 ///
-/// ForTypeExpr <- ForPrefix TypeExpr (KEYWORD_else TypeExpr / !KEYWORD_else) !ExprSuffix
-fn parseFor(p: *Parse, comptime bodyParseFn: fn (p: *Parse) Error!Node.Index) !?Node.Index {
-    const for_token = p.eatToken(.keyword_for) orelse return null;
+/// ForTypeExpr <- ForPrefix TypeExpr (KEYWORD_else TypeExpr / !KEYWORD_else)
+fn expectFor(p: *Parse, comptime bodyParseFn: fn (p: *Parse) Error!Node.Index) !Node.Index {
+    const for_token = p.assertToken(.keyword_for);
 
     const scratch_top = p.scratch.items.len;
     defer p.scratch.shrinkRetainingCapacity(scratch_top);
@@ -3588,7 +3604,7 @@ fn parseFor(p: *Parse, comptime bodyParseFn: fn (p: *Parse) Error!Node.Index) !?
 }
 
 /// Skips over doc comment tokens. Returns the first one, if any.
-fn eatDocComments(p: *Parse) Allocator.Error!?TokenIndex {
+fn eatDocComments(p: *Parse) Error!?TokenIndex {
     if (p.eatToken(.doc_comment)) |tok| {
         var first_line = tok;
         if (tok > 0 and tokensOnSameLine(p, tok - 1, tok)) {
@@ -3643,7 +3659,7 @@ fn expectSemicolon(p: *Parse, error_tag: AstError.Tag, recoverable: bool) Error!
         return;
     }
     try p.warn(error_tag);
-    if (!recoverable) return error.ParseError;
+    if (!recoverable or !p.recover) return error.ParseError;
 }
 
 fn nextToken(p: *Parse) TokenIndex {
diff --git a/lib/std/zig/parser_fuzz.zig b/lib/std/zig/parser_fuzz.zig
new file mode 100644
index 0000000000000000000000000000000000000000..48823191202f822ba38be1d7d68530a458877a69
--- /dev/null
+++ b/lib/std/zig/parser_fuzz.zig
@@ -0,0 +1,243 @@
+const std = @import("../std.zig");
+const Allocator = std.mem.Allocator;
+const Smith = std.testing.Smith;
+
+const oracle = @import("parser_generated_oracle.zig");
+
+test "fuzz std.zig.Ast.parse() against generated oracle" {
+    try std.testing.fuzz({}, fuzzAgainstOracle, .{});
+}
+
+fn fuzzAgainstOracle(_: void, smith: *Smith) !void {
+    var buffer: [1 << 14]u8 = undefined;
+    const len = smith.slice(buffer[0 .. buffer.len - 1]);
+    buffer[len] = 0;
+    const source = buffer[0..len :0];
+
+    checkAgainstOracle(source) catch |err| switch (err) {
+        error.MaxDepth => return error.SkipZigTest,
+        else => |e| return e,
+    };
+}
+
+test "max depth" {
+    try std.testing.expectError(error.MaxDepth, checkAgainstOracle("((((("));
+    _ = checkAgainstOracle("((((") catch |err| switch (err) {
+        error.MaxDepth => try std.testing.expect(false),
+        else => |e| return e,
+    };
+}
+
+// Found using AFL++
+test "operator whitespace" {
+    try checkAgainstOracle(
+        \\test {
+        \\    _!= 0;
+        \\}
+    );
+    try checkAgainstOracle(
+        \\test{{\\
+        \\*0;}}
+    );
+}
+
+// Found using AFL++
+test "doc comment or division operator" {
+    try checkAgainstOracle("0=0///\n0");
+}
+
+// Found using AFL++
+test "double ampersand" {
+    try checkAgainstOracle("0=0&&0"); // error
+    try checkAgainstOracle("test{&&0;}"); // ok
+}
+
+// Found using AFL++
+test "newline required before doc comment not at start of file" {
+    try checkAgainstOracle("0,///\n0"); // error
+    try checkAgainstOracle("///\n0"); // ok
+    try checkAgainstOracle(" ///\n0"); // ok
+    try checkAgainstOracle("\n///\n0"); // ok
+    try checkAgainstOracle("///"); // error
+    try checkAgainstOracle("///\n//!");
+    try checkAgainstOracle("///\ntest {}");
+    try checkAgainstOracle("///\ncomptime 0");
+}
+
+// Found using AFL++
+test "extra capture in for loop" {
+    try checkAgainstOracle("for(0)|t,r|0");
+}
+
+// Found using AFL++
+test "expression nesting" {
+    try checkAgainstOracle("test{*comptime 0 == 0;}");
+}
+
+// Found using AFL++
+test "comptime fn" {
+    try checkAgainstOracle("comptime fn()0");
+}
+
+// Found using AFL++
+test "return asterisk" {
+    try checkAgainstOracle("test{return*!0;}");
+}
+
+// Found using AFL++
+test "fn container field" {
+    try checkAgainstOracle("fn()0");
+}
+
+// Found using AFL++
+test "at newline string" {
+    try checkAgainstOracle(
+        \\@
+        \\""
+    );
+}
+
+// Found using AFL++
+test "string lit" {
+    try checkAgainstOracle(
+        \\"\\"
+    );
+}
+
+// Found using AFL++
+test "dot question" {
+    try checkAgainstOracle("0. ?");
+}
+
+// Found using AFL++
+test "volatile const" {
+    try checkAgainstOracle("*volatile\nconst\n0");
+}
+
+// Found using AFL++
+test "addrspace align" {
+    try checkAgainstOracle("*addrspace(0) align(0) 0");
+    try checkAgainstOracle("*align(0) addrspace(0) 0");
+    try checkAgainstOracle("[*]addrspace(0) align(0) 0");
+    try checkAgainstOracle("[*]align(0) addrspace(0) 0");
+}
+
+// Found using AFL++
+test "catch capture whitespace" {
+    try checkAgainstOracle("test{0 catch |h|0;}");
+}
+
+// Found using AFL++
+test "byte order mark" {
+    // https://en.wikipedia.org/wiki/Byte_order_mark
+    try checkAgainstOracle("\xef\xbb\xbf");
+    try checkAgainstOracle("\xef\xbb\xbf///\n0");
+}
+
+// Found using AFL++
+test "nosuspend multi assign" {
+    try checkAgainstOracle("test{nosuspend*0,var _=0;}");
+}
+
+// Found using AFL++
+test "bin op at end of file" {
+    try checkAgainstOracle(
+        \\test {
+        \\    _ = 00
+        \\|
+    );
+}
+
+// Found using AFL++
+test "resume block chained compare ops" {
+    try checkAgainstOracle("test{resume{0 > 0;} > 0 > 0;}");
+}
+
+// Found using AFL++
+test "for multiassign" {
+    try checkAgainstOracle("test{for(0)|t|0,const w=0;}");
+}
+
+fn checkAgainstOracle(source: [:0]const u8) !void {
+    var fba_buf: [1 << 18]u8 = undefined;
+    var fba: std.heap.FixedBufferAllocator = .init(&fba_buf);
+
+    const expected = try oracle.parse(source);
+
+    // It is important to disable recovery for fuzz testing.
+    // Consider the case where there is a parse error right at the beginning of the file,
+    // followed by a valid declaration with a million nested parens. The oracle will not
+    // skip this input due to the max depth being exceeded since the oracle hits a parse
+    // error right away and does no recovery. However, std.zig.Ast.parse() does recovery
+    // by default and will hit a stack overflow rather than returning after the parser error.
+    // Stack overflows are not interesting and we do not want the fuzzer to be able to find them.
+    const ast = try std.zig.Ast.parse(fba.allocator(), source, .zig, .{ .recover = false });
+
+    errdefer logBadSource(source, ast);
+    try std.testing.expectEqual(expected, ast.errors.len == 0);
+}
+
+fn logBadSource(source: []const u8, ast: std.zig.Ast) void {
+    @disableInstrumentation();
+    var buf: [256]u8 = undefined;
+    const ls = std.debug.lockStderr(&buf);
+    defer std.debug.unlockStderr();
+    logBadSourceInner(source, ls.terminal(), ast) catch {};
+}
+
+fn logBadSourceInner(source: []const u8, t: std.Io.Terminal, ast: std.zig.Ast) std.Io.Writer.Error!void {
+    @disableInstrumentation();
+    try logSourceInner(source, t);
+    const w = t.writer;
+
+    try w.writeAll("=== Parse Errors ===\n");
+    for (ast.errors) |err| {
+        const loc = ast.tokenLocation(0, err.token);
+        try w.print("{}:{}: ", .{ loc.line + 1, loc.column + 1 });
+        try ast.renderError(err, w);
+        try w.writeByte('\n');
+    }
+}
+
+pub fn logSource(source: []const u8) void {
+    @disableInstrumentation();
+    var buf: [256]u8 = undefined;
+    const ls = std.debug.lockStderr(&buf);
+    defer std.debug.unlockStderr();
+    logSourceInner(source, ls.terminal()) catch {};
+}
+
+fn logSourceInner(source: []const u8, t: std.Io.Terminal) std.Io.Writer.Error!void {
+    @disableInstrumentation();
+    const w = t.writer;
+
+    t.setColor(.dim) catch {};
+    try w.writeAll("=== Source ===\n");
+    t.setColor(.reset) catch {};
+
+    var line: usize = 1;
+    try w.print("{: >5} ", .{line});
+    for (source) |c| switch (c) {
+        ' '...0x7e => try w.writeByte(c),
+        '\n' => {
+            line += 1;
+            try w.print("\n{: >5} ", .{line});
+        },
+        '\r' => {
+            t.setColor(.cyan) catch {};
+            try w.writeAll("\\r");
+            t.setColor(.reset) catch {};
+        },
+        '\t' => {
+            t.setColor(.cyan) catch {};
+            try w.writeAll("\\t");
+            t.setColor(.reset) catch {};
+        },
+        else => {
+            t.setColor(.cyan) catch {};
+            try w.print("\\x{x:0>2}", .{c});
+            t.setColor(.reset) catch {};
+        },
+    };
+    try w.writeByte('\n');
+}
diff --git a/lib/std/zig/parser_generated_oracle.zig b/lib/std/zig/parser_generated_oracle.zig
new file mode 100644
index 0000000000000000000000000000000000000000..2b24677c96cc33db44ea3871c7255e79fd9b5b82
--- /dev/null
+++ b/lib/std/zig/parser_generated_oracle.zig
@@ -0,0 +1,6552 @@
+//! This file is generated, do not edit manually! To generate, run:
+//! zig build gen-parser-oracle
+
+const std = @import("std");
+
+const Error = error{MaxDepth};
+const max_depth = 5;
+
+/// Returns true if the input source is in the language defined by
+/// the grammar.
+/// Returns error.MaxDepth if more than `max_depth` levels of recursion/iteration are reached.
+pub fn parse(source: []const u8) Error!bool {
+    var p: Parser = .{ .source = source, .i = 0, .depths = @splat(1) };
+    return p.parseRoot();
+}
+const Def = enum {
+    defRoot,
+    defContainerMembers,
+    defContainerMembersRest,
+    defContainerDecl,
+    defContainerDeclPrefix,
+    defTestDecl,
+    defComptimeDecl,
+    defDecl,
+    defDeclPrefix,
+    defFnProto,
+    defVarDeclProto,
+    defGlobalVarDecl,
+    defContainerField,
+    defBlockStatement,
+    defStatement,
+    defStatementPrefix,
+    defIfStatement,
+    defLabeledStatement,
+    defLoopStatement,
+    defForStatement,
+    defWhileStatement,
+    defBlockExprStatement,
+    defBlockExprPrefix,
+    defBlockExpr,
+    defVarAssignStatement,
+    defAssignExpr,
+    defSingleAssignExpr,
+    defExpr,
+    defBoolOrExpr,
+    defBoolAndExpr,
+    defCompareExpr,
+    defBitwiseExpr,
+    defBitShiftExpr,
+    defAdditionExpr,
+    defMultiplyExpr,
+    defPrefixExpr,
+    defPrimaryExpr,
+    defIfExpr,
+    defBlock,
+    defLoopExpr,
+    defForExpr,
+    defWhileExpr,
+    defCurlySuffixExpr,
+    defInitList,
+    defTypeExpr,
+    defErrorUnionExpr,
+    defSuffixExpr,
+    defPrimaryTypeExpr,
+    defContainerType,
+    defErrorSetDecl,
+    defGroupedExpr,
+    defIfTypeExpr,
+    defLabeledTypeExpr,
+    defLoopTypeExpr,
+    defForTypeExpr,
+    defWhileTypeExpr,
+    defSwitchExpr,
+    defAsmExpr,
+    defAsmOutput,
+    defAsmOutputItem,
+    defAsmInput,
+    defAsmInputItem,
+    defAsmClobbers,
+    defBreakLabel,
+    defBlockLabel,
+    defFieldInit,
+    defWhileContinueExpr,
+    defLinkSection,
+    defAddrSpace,
+    defCallConv,
+    defParamDecl,
+    defParamType,
+    defIfPrefix,
+    defWhilePrefix,
+    defForPrefix,
+    defPayload,
+    defPtrPayload,
+    defPtrIndexPayload,
+    defPtrListPayload,
+    defSwitchProng,
+    defSwitchCase,
+    defSwitchItem,
+    defForArgumentsList,
+    defForItem,
+    defAssignOp,
+    defOrOp,
+    defAndOp,
+    defCompareOp,
+    defCompareOpTok,
+    defBitwiseOp,
+    defBitwiseOpTok,
+    defBitShiftOp,
+    defBitShiftOpTok,
+    defAdditionOp,
+    defAdditionOpTok,
+    defMultiplyOp,
+    defMultiplyOpTok,
+    defPrefixOp,
+    defPrefixTypeOp,
+    defPtrMods,
+    defSinglePtrMods,
+    defPtrMod,
+    defPrefixTypeOpPrefix,
+    defSuffixOp,
+    defSuffixOpPrefix,
+    defFnCallArguments,
+    defSliceTypeStart,
+    defSinglePtrTypeStart,
+    defManyPtrTypeStart,
+    defArrayTypeStart,
+    defContainerTypeAuto,
+    defContainerTypeKind,
+    defByteAlign,
+    defBitAlign,
+    defIdentifierList,
+    defSwitchProngList,
+    defAsmOutputList,
+    defAsmInputList,
+    defParamDeclList,
+    defParamDeclListRest,
+    defExprList,
+    defExprPrefix,
+    defbyte_order_mark,
+    defsof,
+    defeof,
+    defox80_oxBF,
+    defoxF4,
+    defox80_ox8F,
+    defoxF1_oxF3,
+    defoxF0,
+    defox90_0xBF,
+    defoxEE_oxEF,
+    defoxED,
+    defox80_ox9F,
+    defoxE1_oxEC,
+    defoxE0,
+    defoxA0_oxBF,
+    defoxC2_oxDF,
+    defmultibyte_utf8,
+    defnon_control_ascii,
+    defnon_control_utf8,
+    defchar_char,
+    defstring_char,
+    defcontainer_doc_comment,
+    defdoc_comment,
+    defline_comment,
+    defline_string,
+    defnewline,
+    defskip,
+    defskip_require_newline,
+    defpre_op_white,
+    defpost_op_white,
+    defCHAR_LITERAL,
+    defdigit,
+    defdigit_int,
+    defdigit_float,
+    defNUMBERLITERAL,
+    defstring,
+    defSTRINGLITERALSINGLE,
+    defSTRINGLITERAL,
+    defIDENTIFIER,
+    defBUILTINIDENTIFIER,
+    defAMPERSAND,
+    defAMPERSANDEQUAL,
+    defASTERISK,
+    defASTERISKEQUAL,
+    defASTERISKPERCENT,
+    defASTERISKPERCENTEQUAL,
+    defASTERISKPIPE,
+    defASTERISKPIPEEQUAL,
+    defCARET,
+    defCARETEQUAL,
+    defCOLON,
+    defCOMMA,
+    defDOT,
+    defDOT2,
+    defDOT3,
+    defDOTASTERISK,
+    defEQUAL,
+    defEQUALEQUAL,
+    defEQUALRARROW,
+    defEXCLAMATIONMARK,
+    defEXCLAMATIONMARKEQUAL,
+    defLARROW,
+    defLARROW2,
+    defLARROW2EQUAL,
+    defLARROW2PIPE,
+    defLARROW2PIPEEQUAL,
+    defLARROWEQUAL,
+    defLBRACE,
+    defLBRACKET,
+    defLPAREN,
+    defMINUS,
+    defMINUSEQUAL,
+    defMINUSPERCENT,
+    defMINUSPERCENTEQUAL,
+    defMINUSPIPE,
+    defMINUSPIPEEQUAL,
+    defMINUSRARROW,
+    defPERCENT,
+    defPERCENTEQUAL,
+    defPIPE,
+    defPIPE2,
+    defPIPEEQUAL,
+    defPLUS,
+    defPLUS2,
+    defPLUSEQUAL,
+    defPLUSPERCENT,
+    defPLUSPERCENTEQUAL,
+    defPLUSPIPE,
+    defPLUSPIPEEQUAL,
+    defLETTERC,
+    defQUESTIONMARK,
+    defRARROW,
+    defRARROW2,
+    defRARROW2EQUAL,
+    defRARROWEQUAL,
+    defRBRACE,
+    defRBRACKET,
+    defRPAREN,
+    defSEMICOLON,
+    defSLASH,
+    defSLASHEQUAL,
+    defTILDE,
+    defend_of_word,
+    defKEYWORD_addrspace,
+    defKEYWORD_align,
+    defKEYWORD_allowzero,
+    defKEYWORD_and,
+    defKEYWORD_anyframe,
+    defKEYWORD_anytype,
+    defKEYWORD_asm,
+    defKEYWORD_break,
+    defKEYWORD_callconv,
+    defKEYWORD_catch,
+    defKEYWORD_comptime,
+    defKEYWORD_const,
+    defKEYWORD_continue,
+    defKEYWORD_defer,
+    defKEYWORD_else,
+    defKEYWORD_enum,
+    defKEYWORD_errdefer,
+    defKEYWORD_error,
+    defKEYWORD_export,
+    defKEYWORD_extern,
+    defKEYWORD_fn,
+    defKEYWORD_for,
+    defKEYWORD_if,
+    defKEYWORD_inline,
+    defKEYWORD_noalias,
+    defKEYWORD_nosuspend,
+    defKEYWORD_noinline,
+    defKEYWORD_opaque,
+    defKEYWORD_or,
+    defKEYWORD_orelse,
+    defKEYWORD_packed,
+    defKEYWORD_pub,
+    defKEYWORD_resume,
+    defKEYWORD_return,
+    defKEYWORD_linksection,
+    defKEYWORD_struct,
+    defKEYWORD_suspend,
+    defKEYWORD_switch,
+    defKEYWORD_test,
+    defKEYWORD_threadlocal,
+    defKEYWORD_try,
+    defKEYWORD_union,
+    defKEYWORD_unreachable,
+    defKEYWORD_var,
+    defKEYWORD_volatile,
+    defKEYWORD_while,
+    defkeyword,
+};
+const Parser = struct {
+    source: []const u8,
+    i: usize,
+    depths: [272]u8,
+    pub fn parseRoot(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defRoot);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseContainerMembers() and try p.parseskip() and try p.parseeof()) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseContainerMembers(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defContainerMembers);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if ((try p.parsecontainer_doc_comment() or true) and blk_1: {
+                var i_1: usize = 0;
+                while (try p.parseContainerDecl()) {
+                    if (i_1 > max_depth) return error.MaxDepth;
+                    i_1 += 1;
+                }
+                break :blk_1 true;
+            } and try p.parseContainerMembersRest()) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseContainerMembersRest(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defContainerMembersRest);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (blk_1: {
+                const pos_1 = p.i;
+                const match_1 = try p.parseContainerDeclPrefix();
+                p.i = pos_1;
+                break :blk_1 !match_1;
+            } and try p.parseContainerField() and (blk_3: {
+                const pos_3 = p.i;
+                if (try p.parseCOMMA() and try p.parseContainerMembersRest()) break :blk_3 true;
+                p.i = pos_3;
+                break :blk_3 false;
+            } or true)) break :blk_0 true;
+            p.i = pos_0;
+            if (blk_1: {
+                var i_1: usize = 0;
+                while (try p.parseContainerDecl()) {
+                    if (i_1 > max_depth) return error.MaxDepth;
+                    i_1 += 1;
+                }
+                break :blk_1 true;
+            }) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseContainerDecl(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defContainerDecl);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseTestDecl()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseComptimeDecl()) break :blk_0 true;
+            p.i = pos_0;
+            if ((try p.parsedoc_comment() or true) and (try p.parseKEYWORD_pub() or true) and try p.parseDecl()) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseContainerDeclPrefix(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defContainerDeclPrefix);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseKEYWORD_test()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseKEYWORD_comptime() and try p.parseLBRACE()) break :blk_0 true;
+            p.i = pos_0;
+            if ((try p.parsedoc_comment() or true) and (try p.parseKEYWORD_pub() or true) and try p.parseDeclPrefix()) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseTestDecl(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defTestDecl);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseKEYWORD_test() and (blk_3: {
+                const pos_3 = p.i;
+                if (try p.parseSTRINGLITERALSINGLE()) break :blk_3 true;
+                p.i = pos_3;
+                if (try p.parseIDENTIFIER()) break :blk_3 true;
+                p.i = pos_3;
+                break :blk_3 false;
+            } or true) and try p.parseBlock()) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseComptimeDecl(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defComptimeDecl);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseKEYWORD_comptime() and try p.parseBlock()) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseDecl(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defDecl);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if ((blk_3: {
+                const pos_3 = p.i;
+                if (try p.parseKEYWORD_export()) break :blk_3 true;
+                p.i = pos_3;
+                if (try p.parseKEYWORD_inline()) break :blk_3 true;
+                p.i = pos_3;
+                if (try p.parseKEYWORD_noinline()) break :blk_3 true;
+                p.i = pos_3;
+                break :blk_3 false;
+            } or true) and try p.parseFnProto() and blk_2: {
+                const pos_2 = p.i;
+                if (try p.parseSEMICOLON()) break :blk_2 true;
+                p.i = pos_2;
+                if (try p.parseBlock()) break :blk_2 true;
+                p.i = pos_2;
+                break :blk_2 false;
+            }) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseKEYWORD_extern() and (try p.parseSTRINGLITERALSINGLE() or true) and try p.parseFnProto() and try p.parseSEMICOLON()) break :blk_0 true;
+            p.i = pos_0;
+            if ((blk_3: {
+                const pos_3 = p.i;
+                if (try p.parseKEYWORD_export()) break :blk_3 true;
+                p.i = pos_3;
+                if (try p.parseKEYWORD_extern() and (try p.parseSTRINGLITERALSINGLE() or true)) break :blk_3 true;
+                p.i = pos_3;
+                break :blk_3 false;
+            } or true) and (try p.parseKEYWORD_threadlocal() or true) and try p.parseGlobalVarDecl()) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseDeclPrefix(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defDeclPrefix);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if ((blk_3: {
+                const pos_3 = p.i;
+                if (try p.parseKEYWORD_export()) break :blk_3 true;
+                p.i = pos_3;
+                if (try p.parseKEYWORD_inline()) break :blk_3 true;
+                p.i = pos_3;
+                if (try p.parseKEYWORD_noinline()) break :blk_3 true;
+                p.i = pos_3;
+                break :blk_3 false;
+            } or true) and try p.parseKEYWORD_fn()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseKEYWORD_extern() and (try p.parseSTRINGLITERALSINGLE() or true) and try p.parseKEYWORD_fn()) break :blk_0 true;
+            p.i = pos_0;
+            if ((blk_3: {
+                const pos_3 = p.i;
+                if (try p.parseKEYWORD_export()) break :blk_3 true;
+                p.i = pos_3;
+                if (try p.parseKEYWORD_extern() and (try p.parseSTRINGLITERALSINGLE() or true)) break :blk_3 true;
+                p.i = pos_3;
+                break :blk_3 false;
+            } or true) and (try p.parseKEYWORD_threadlocal() or true) and blk_2: {
+                const pos_2 = p.i;
+                if (try p.parseKEYWORD_const()) break :blk_2 true;
+                p.i = pos_2;
+                if (try p.parseKEYWORD_var()) break :blk_2 true;
+                p.i = pos_2;
+                break :blk_2 false;
+            }) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseFnProto(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defFnProto);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseKEYWORD_fn() and (try p.parseIDENTIFIER() or true) and try p.parseParamDeclList() and (try p.parseByteAlign() or true) and (try p.parseAddrSpace() or true) and (try p.parseLinkSection() or true) and (try p.parseCallConv() or true) and (try p.parseEXCLAMATIONMARK() or true) and try p.parseTypeExpr()) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseVarDeclProto(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defVarDeclProto);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (blk_2: {
+                const pos_2 = p.i;
+                if (try p.parseKEYWORD_const()) break :blk_2 true;
+                p.i = pos_2;
+                if (try p.parseKEYWORD_var()) break :blk_2 true;
+                p.i = pos_2;
+                break :blk_2 false;
+            } and try p.parseIDENTIFIER() and (blk_3: {
+                const pos_3 = p.i;
+                if (try p.parseCOLON() and try p.parseTypeExpr()) break :blk_3 true;
+                p.i = pos_3;
+                break :blk_3 false;
+            } or true) and (try p.parseByteAlign() or true) and (try p.parseAddrSpace() or true) and (try p.parseLinkSection() or true)) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseGlobalVarDecl(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defGlobalVarDecl);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseVarDeclProto() and (blk_3: {
+                const pos_3 = p.i;
+                if (try p.parseEQUAL() and try p.parseExpr()) break :blk_3 true;
+                p.i = pos_3;
+                break :blk_3 false;
+            } or true) and try p.parseSEMICOLON()) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseContainerField(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defContainerField);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if ((try p.parsedoc_comment() or true) and (try p.parseKEYWORD_comptime() or true) and (blk_3: {
+                const pos_3 = p.i;
+                if (try p.parseIDENTIFIER() and try p.parseCOLON()) break :blk_3 true;
+                p.i = pos_3;
+                break :blk_3 false;
+            } or true) and try p.parseTypeExpr() and (try p.parseByteAlign() or true) and (blk_3: {
+                const pos_3 = p.i;
+                if (try p.parseEQUAL() and try p.parseExpr()) break :blk_3 true;
+                p.i = pos_3;
+                break :blk_3 false;
+            } or true)) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseBlockStatement(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defBlockStatement);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseStatement()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseKEYWORD_defer() and try p.parseBlockExprStatement()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseKEYWORD_errdefer() and try p.parseBlockExprStatement()) break :blk_0 true;
+            p.i = pos_0;
+            if (blk_1: {
+                const pos_1 = p.i;
+                const match_1 = try p.parseStatementPrefix();
+                p.i = pos_1;
+                break :blk_1 !match_1;
+            } and (try p.parseKEYWORD_comptime() or true) and try p.parseVarAssignStatement()) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseStatement(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defStatement);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseIfStatement()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseLabeledStatement()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseKEYWORD_nosuspend() and try p.parseBlockExprStatement()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseKEYWORD_comptime() and try p.parseBlockExpr()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseKEYWORD_suspend() and try p.parseBlockExprStatement()) break :blk_0 true;
+            p.i = pos_0;
+            if (blk_1: {
+                const pos_1 = p.i;
+                const match_1 = try p.parseStatementPrefix();
+                p.i = pos_1;
+                break :blk_1 !match_1;
+            } and (try p.parseKEYWORD_comptime() or true) and try p.parseAssignExpr() and try p.parseSEMICOLON()) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseStatementPrefix(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defStatementPrefix);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseKEYWORD_if()) break :blk_0 true;
+            p.i = pos_0;
+            if ((try p.parseBlockLabel() or true) and blk_2: {
+                const pos_2 = p.i;
+                if (try p.parseLBRACE()) break :blk_2 true;
+                p.i = pos_2;
+                if ((try p.parseKEYWORD_inline() or true) and blk_4: {
+                    const pos_4 = p.i;
+                    if (try p.parseKEYWORD_for()) break :blk_4 true;
+                    p.i = pos_4;
+                    if (try p.parseKEYWORD_while()) break :blk_4 true;
+                    p.i = pos_4;
+                    break :blk_4 false;
+                }) break :blk_2 true;
+                p.i = pos_2;
+                if (try p.parseKEYWORD_switch()) break :blk_2 true;
+                p.i = pos_2;
+                break :blk_2 false;
+            }) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseKEYWORD_nosuspend()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseKEYWORD_comptime() and try p.parseBlockExprPrefix()) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseIfStatement(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defIfStatement);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseIfPrefix() and try p.parseBlockExpr() and blk_2: {
+                const pos_2 = p.i;
+                if (try p.parseKEYWORD_else() and (try p.parsePayload() or true) and try p.parseStatement()) break :blk_2 true;
+                p.i = pos_2;
+                if (blk_3: {
+                    const pos_3 = p.i;
+                    const match_3 = try p.parseKEYWORD_else();
+                    p.i = pos_3;
+                    break :blk_3 !match_3;
+                }) break :blk_2 true;
+                p.i = pos_2;
+                break :blk_2 false;
+            }) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseIfPrefix() and blk_1: {
+                const pos_1 = p.i;
+                const match_1 = try p.parseBlockExprPrefix();
+                p.i = pos_1;
+                break :blk_1 !match_1;
+            } and try p.parseAssignExpr() and blk_2: {
+                const pos_2 = p.i;
+                if (try p.parseSEMICOLON()) break :blk_2 true;
+                p.i = pos_2;
+                if (try p.parseKEYWORD_else() and (try p.parsePayload() or true) and try p.parseStatement()) break :blk_2 true;
+                p.i = pos_2;
+                break :blk_2 false;
+            }) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseLabeledStatement(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defLabeledStatement);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if ((try p.parseBlockLabel() or true) and blk_2: {
+                const pos_2 = p.i;
+                if (try p.parseBlock()) break :blk_2 true;
+                p.i = pos_2;
+                if (try p.parseLoopStatement()) break :blk_2 true;
+                p.i = pos_2;
+                if (try p.parseSwitchExpr()) break :blk_2 true;
+                p.i = pos_2;
+                break :blk_2 false;
+            }) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseLoopStatement(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defLoopStatement);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if ((try p.parseKEYWORD_inline() or true) and blk_2: {
+                const pos_2 = p.i;
+                if (try p.parseForStatement()) break :blk_2 true;
+                p.i = pos_2;
+                if (try p.parseWhileStatement()) break :blk_2 true;
+                p.i = pos_2;
+                break :blk_2 false;
+            }) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseForStatement(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defForStatement);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseForPrefix() and try p.parseBlockExpr() and blk_2: {
+                const pos_2 = p.i;
+                if (try p.parseKEYWORD_else() and try p.parseStatement()) break :blk_2 true;
+                p.i = pos_2;
+                if (blk_3: {
+                    const pos_3 = p.i;
+                    const match_3 = try p.parseKEYWORD_else();
+                    p.i = pos_3;
+                    break :blk_3 !match_3;
+                }) break :blk_2 true;
+                p.i = pos_2;
+                break :blk_2 false;
+            }) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseForPrefix() and blk_1: {
+                const pos_1 = p.i;
+                const match_1 = try p.parseBlockExprPrefix();
+                p.i = pos_1;
+                break :blk_1 !match_1;
+            } and try p.parseAssignExpr() and blk_2: {
+                const pos_2 = p.i;
+                if (try p.parseSEMICOLON()) break :blk_2 true;
+                p.i = pos_2;
+                if (try p.parseKEYWORD_else() and try p.parseStatement()) break :blk_2 true;
+                p.i = pos_2;
+                break :blk_2 false;
+            }) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseWhileStatement(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defWhileStatement);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseWhilePrefix() and try p.parseBlockExpr() and blk_2: {
+                const pos_2 = p.i;
+                if (try p.parseKEYWORD_else() and (try p.parsePayload() or true) and try p.parseStatement()) break :blk_2 true;
+                p.i = pos_2;
+                if (blk_3: {
+                    const pos_3 = p.i;
+                    const match_3 = try p.parseKEYWORD_else();
+                    p.i = pos_3;
+                    break :blk_3 !match_3;
+                }) break :blk_2 true;
+                p.i = pos_2;
+                break :blk_2 false;
+            }) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseWhilePrefix() and blk_1: {
+                const pos_1 = p.i;
+                const match_1 = try p.parseBlockExprPrefix();
+                p.i = pos_1;
+                break :blk_1 !match_1;
+            } and try p.parseAssignExpr() and blk_2: {
+                const pos_2 = p.i;
+                if (try p.parseSEMICOLON()) break :blk_2 true;
+                p.i = pos_2;
+                if (try p.parseKEYWORD_else() and (try p.parsePayload() or true) and try p.parseStatement()) break :blk_2 true;
+                p.i = pos_2;
+                break :blk_2 false;
+            }) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseBlockExprStatement(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defBlockExprStatement);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseBlockExpr()) break :blk_0 true;
+            p.i = pos_0;
+            if (blk_1: {
+                const pos_1 = p.i;
+                const match_1 = try p.parseBlockExprPrefix();
+                p.i = pos_1;
+                break :blk_1 !match_1;
+            } and try p.parseAssignExpr() and try p.parseSEMICOLON()) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseBlockExprPrefix(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defBlockExprPrefix);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if ((try p.parseBlockLabel() or true) and try p.parseLBRACE()) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseBlockExpr(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defBlockExpr);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if ((try p.parseBlockLabel() or true) and try p.parseBlock()) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseVarAssignStatement(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defVarAssignStatement);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (blk_2: {
+                const pos_2 = p.i;
+                if (try p.parseVarDeclProto()) break :blk_2 true;
+                p.i = pos_2;
+                if (try p.parseExpr()) break :blk_2 true;
+                p.i = pos_2;
+                break :blk_2 false;
+            } and blk_1: {
+                var i_1: usize = 0;
+                while (blk_3: {
+                    const pos_3 = p.i;
+                    if (try p.parseCOMMA() and blk_5: {
+                        const pos_5 = p.i;
+                        if (try p.parseVarDeclProto()) break :blk_5 true;
+                        p.i = pos_5;
+                        if (try p.parseExpr()) break :blk_5 true;
+                        p.i = pos_5;
+                        break :blk_5 false;
+                    }) break :blk_3 true;
+                    p.i = pos_3;
+                    break :blk_3 false;
+                }) {
+                    if (i_1 > max_depth) return error.MaxDepth;
+                    i_1 += 1;
+                }
+                break :blk_1 true;
+            } and try p.parseEQUAL() and try p.parseExpr() and try p.parseSEMICOLON()) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseAssignExpr(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defAssignExpr);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseExpr() and blk_2: {
+                const pos_2 = p.i;
+                if (try p.parseAssignOp() and try p.parseExpr()) break :blk_2 true;
+                p.i = pos_2;
+                if (blk_3: {
+                    var match_3 = false;
+                    var i_3: usize = 0;
+                    while (blk_5: {
+                        const pos_5 = p.i;
+                        if (try p.parseCOMMA() and try p.parseExpr()) break :blk_5 true;
+                        p.i = pos_5;
+                        break :blk_5 false;
+                    }) {
+                        match_3 = true;
+                        if (i_3 > max_depth) return error.MaxDepth;
+                        i_3 += 1;
+                    }
+                    break :blk_3 match_3;
+                } and try p.parseEQUAL() and try p.parseExpr()) break :blk_2 true;
+                p.i = pos_2;
+                if (blk_3: {
+                    const pos_3 = p.i;
+                    const match_3 = try p.parseAssignOp();
+                    p.i = pos_3;
+                    break :blk_3 !match_3;
+                } and blk_3: {
+                    const pos_3 = p.i;
+                    const match_3 = try p.parseCOMMA();
+                    p.i = pos_3;
+                    break :blk_3 !match_3;
+                }) break :blk_2 true;
+                p.i = pos_2;
+                break :blk_2 false;
+            }) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseSingleAssignExpr(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defSingleAssignExpr);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseExpr() and blk_2: {
+                const pos_2 = p.i;
+                if (try p.parseAssignOp() and try p.parseExpr()) break :blk_2 true;
+                p.i = pos_2;
+                if (blk_3: {
+                    const pos_3 = p.i;
+                    const match_3 = try p.parseAssignOp();
+                    p.i = pos_3;
+                    break :blk_3 !match_3;
+                }) break :blk_2 true;
+                p.i = pos_2;
+                break :blk_2 false;
+            }) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseExpr(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defExpr);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseBoolOrExpr()) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseBoolOrExpr(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defBoolOrExpr);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseBoolAndExpr() and blk_1: {
+                var i_1: usize = 0;
+                while (blk_3: {
+                    const pos_3 = p.i;
+                    if (try p.parseOrOp() and try p.parseBoolAndExpr()) break :blk_3 true;
+                    p.i = pos_3;
+                    break :blk_3 false;
+                }) {
+                    if (i_1 > max_depth) return error.MaxDepth;
+                    i_1 += 1;
+                }
+                break :blk_1 true;
+            } and blk_1: {
+                const pos_1 = p.i;
+                const match_1 = try p.parseOrOp();
+                p.i = pos_1;
+                break :blk_1 !match_1;
+            }) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseBoolAndExpr(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defBoolAndExpr);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseCompareExpr() and blk_1: {
+                var i_1: usize = 0;
+                while (blk_3: {
+                    const pos_3 = p.i;
+                    if (try p.parseAndOp() and try p.parseCompareExpr()) break :blk_3 true;
+                    p.i = pos_3;
+                    break :blk_3 false;
+                }) {
+                    if (i_1 > max_depth) return error.MaxDepth;
+                    i_1 += 1;
+                }
+                break :blk_1 true;
+            } and blk_1: {
+                const pos_1 = p.i;
+                const match_1 = try p.parseAndOp();
+                p.i = pos_1;
+                break :blk_1 !match_1;
+            }) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseCompareExpr(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defCompareExpr);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseBitwiseExpr() and (blk_3: {
+                const pos_3 = p.i;
+                if (try p.parseCompareOp() and try p.parseBitwiseExpr()) break :blk_3 true;
+                p.i = pos_3;
+                break :blk_3 false;
+            } or true) and blk_1: {
+                const pos_1 = p.i;
+                const match_1 = try p.parseCompareOp();
+                p.i = pos_1;
+                break :blk_1 !match_1;
+            }) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseBitwiseExpr(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defBitwiseExpr);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseBitShiftExpr() and blk_1: {
+                var i_1: usize = 0;
+                while (blk_3: {
+                    const pos_3 = p.i;
+                    if (try p.parseBitwiseOp() and try p.parseBitShiftExpr()) break :blk_3 true;
+                    p.i = pos_3;
+                    break :blk_3 false;
+                }) {
+                    if (i_1 > max_depth) return error.MaxDepth;
+                    i_1 += 1;
+                }
+                break :blk_1 true;
+            } and blk_1: {
+                const pos_1 = p.i;
+                const match_1 = try p.parseBitwiseOp();
+                p.i = pos_1;
+                break :blk_1 !match_1;
+            }) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseBitShiftExpr(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defBitShiftExpr);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseAdditionExpr() and blk_1: {
+                var i_1: usize = 0;
+                while (blk_3: {
+                    const pos_3 = p.i;
+                    if (try p.parseBitShiftOp() and try p.parseAdditionExpr()) break :blk_3 true;
+                    p.i = pos_3;
+                    break :blk_3 false;
+                }) {
+                    if (i_1 > max_depth) return error.MaxDepth;
+                    i_1 += 1;
+                }
+                break :blk_1 true;
+            } and blk_1: {
+                const pos_1 = p.i;
+                const match_1 = try p.parseBitShiftOp();
+                p.i = pos_1;
+                break :blk_1 !match_1;
+            }) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseAdditionExpr(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defAdditionExpr);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseMultiplyExpr() and blk_1: {
+                var i_1: usize = 0;
+                while (blk_3: {
+                    const pos_3 = p.i;
+                    if (try p.parseAdditionOp() and try p.parseMultiplyExpr()) break :blk_3 true;
+                    p.i = pos_3;
+                    break :blk_3 false;
+                }) {
+                    if (i_1 > max_depth) return error.MaxDepth;
+                    i_1 += 1;
+                }
+                break :blk_1 true;
+            } and blk_1: {
+                const pos_1 = p.i;
+                const match_1 = try p.parseAdditionOp();
+                p.i = pos_1;
+                break :blk_1 !match_1;
+            }) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseMultiplyExpr(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defMultiplyExpr);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parsePrefixExpr() and blk_1: {
+                var i_1: usize = 0;
+                while (blk_3: {
+                    const pos_3 = p.i;
+                    if (try p.parseMultiplyOp() and try p.parsePrefixExpr()) break :blk_3 true;
+                    p.i = pos_3;
+                    break :blk_3 false;
+                }) {
+                    if (i_1 > max_depth) return error.MaxDepth;
+                    i_1 += 1;
+                }
+                break :blk_1 true;
+            } and blk_1: {
+                const pos_1 = p.i;
+                const match_1 = try p.parseMultiplyOp();
+                p.i = pos_1;
+                break :blk_1 !match_1;
+            }) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parsePrefixExpr(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defPrefixExpr);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (blk_1: {
+                var i_1: usize = 0;
+                while (try p.parsePrefixOp()) {
+                    if (i_1 > max_depth) return error.MaxDepth;
+                    i_1 += 1;
+                }
+                break :blk_1 true;
+            } and blk_1: {
+                const pos_1 = p.i;
+                const match_1 = try p.parsePrefixOp();
+                p.i = pos_1;
+                break :blk_1 !match_1;
+            } and try p.parsePrimaryExpr()) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parsePrimaryExpr(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defPrimaryExpr);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseAsmExpr()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseIfExpr()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseKEYWORD_break() and (try p.parseBreakLabel() or true) and blk_2: {
+                const pos_2 = p.i;
+                if (try p.parseExpr()) break :blk_2 true;
+                p.i = pos_2;
+                if (blk_3: {
+                    const pos_3 = p.i;
+                    const match_3 = try p.parseExprPrefix();
+                    p.i = pos_3;
+                    break :blk_3 !match_3;
+                }) break :blk_2 true;
+                p.i = pos_2;
+                break :blk_2 false;
+            }) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseKEYWORD_comptime() and try p.parseExpr()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseKEYWORD_nosuspend() and try p.parseExpr()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseKEYWORD_continue() and (try p.parseBreakLabel() or true) and blk_2: {
+                const pos_2 = p.i;
+                if (try p.parseExpr()) break :blk_2 true;
+                p.i = pos_2;
+                if (blk_3: {
+                    const pos_3 = p.i;
+                    const match_3 = try p.parseExprPrefix();
+                    p.i = pos_3;
+                    break :blk_3 !match_3;
+                }) break :blk_2 true;
+                p.i = pos_2;
+                break :blk_2 false;
+            }) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseKEYWORD_resume() and try p.parseExpr()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseKEYWORD_return() and blk_2: {
+                const pos_2 = p.i;
+                if (try p.parseExpr()) break :blk_2 true;
+                p.i = pos_2;
+                if (blk_3: {
+                    const pos_3 = p.i;
+                    const match_3 = try p.parseExprPrefix();
+                    p.i = pos_3;
+                    break :blk_3 !match_3;
+                }) break :blk_2 true;
+                p.i = pos_2;
+                break :blk_2 false;
+            }) break :blk_0 true;
+            p.i = pos_0;
+            if ((try p.parseBlockLabel() or true) and try p.parseLoopExpr()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseBlock()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseCurlySuffixExpr()) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseIfExpr(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defIfExpr);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseIfPrefix() and try p.parseExpr() and blk_2: {
+                const pos_2 = p.i;
+                if (try p.parseKEYWORD_else() and (try p.parsePayload() or true) and try p.parseExpr()) break :blk_2 true;
+                p.i = pos_2;
+                if (blk_3: {
+                    const pos_3 = p.i;
+                    const match_3 = try p.parseKEYWORD_else();
+                    p.i = pos_3;
+                    break :blk_3 !match_3;
+                }) break :blk_2 true;
+                p.i = pos_2;
+                break :blk_2 false;
+            }) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseBlock(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defBlock);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseLBRACE() and blk_1: {
+                var i_1: usize = 0;
+                while (try p.parseBlockStatement()) {
+                    if (i_1 > max_depth) return error.MaxDepth;
+                    i_1 += 1;
+                }
+                break :blk_1 true;
+            } and try p.parseRBRACE()) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseLoopExpr(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defLoopExpr);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if ((try p.parseKEYWORD_inline() or true) and blk_2: {
+                const pos_2 = p.i;
+                if (try p.parseForExpr()) break :blk_2 true;
+                p.i = pos_2;
+                if (try p.parseWhileExpr()) break :blk_2 true;
+                p.i = pos_2;
+                break :blk_2 false;
+            }) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseForExpr(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defForExpr);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseForPrefix() and try p.parseExpr() and blk_2: {
+                const pos_2 = p.i;
+                if (try p.parseKEYWORD_else() and try p.parseExpr()) break :blk_2 true;
+                p.i = pos_2;
+                if (blk_3: {
+                    const pos_3 = p.i;
+                    const match_3 = try p.parseKEYWORD_else();
+                    p.i = pos_3;
+                    break :blk_3 !match_3;
+                }) break :blk_2 true;
+                p.i = pos_2;
+                break :blk_2 false;
+            }) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseWhileExpr(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defWhileExpr);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseWhilePrefix() and try p.parseExpr() and (blk_3: {
+                const pos_3 = p.i;
+                if (try p.parseKEYWORD_else() and (try p.parsePayload() or true) and try p.parseExpr()) break :blk_3 true;
+                p.i = pos_3;
+                break :blk_3 false;
+            } or true)) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseCurlySuffixExpr(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defCurlySuffixExpr);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseTypeExpr() and blk_2: {
+                const pos_2 = p.i;
+                if (try p.parseInitList()) break :blk_2 true;
+                p.i = pos_2;
+                if (blk_3: {
+                    const pos_3 = p.i;
+                    const match_3 = try p.parseLBRACE();
+                    p.i = pos_3;
+                    break :blk_3 !match_3;
+                }) break :blk_2 true;
+                p.i = pos_2;
+                break :blk_2 false;
+            }) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseInitList(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defInitList);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseLBRACE() and try p.parseFieldInit() and blk_1: {
+                var i_1: usize = 0;
+                while (blk_3: {
+                    const pos_3 = p.i;
+                    if (try p.parseCOMMA() and try p.parseFieldInit()) break :blk_3 true;
+                    p.i = pos_3;
+                    break :blk_3 false;
+                }) {
+                    if (i_1 > max_depth) return error.MaxDepth;
+                    i_1 += 1;
+                }
+                break :blk_1 true;
+            } and (try p.parseCOMMA() or true) and try p.parseRBRACE()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseLBRACE() and try p.parseExpr() and blk_1: {
+                var i_1: usize = 0;
+                while (blk_3: {
+                    const pos_3 = p.i;
+                    if (try p.parseCOMMA() and try p.parseExpr()) break :blk_3 true;
+                    p.i = pos_3;
+                    break :blk_3 false;
+                }) {
+                    if (i_1 > max_depth) return error.MaxDepth;
+                    i_1 += 1;
+                }
+                break :blk_1 true;
+            } and (try p.parseCOMMA() or true) and try p.parseRBRACE()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseLBRACE() and try p.parseRBRACE()) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseTypeExpr(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defTypeExpr);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (blk_1: {
+                var i_1: usize = 0;
+                while (try p.parsePrefixTypeOp()) {
+                    if (i_1 > max_depth) return error.MaxDepth;
+                    i_1 += 1;
+                }
+                break :blk_1 true;
+            } and blk_1: {
+                const pos_1 = p.i;
+                const match_1 = try p.parsePrefixTypeOpPrefix();
+                p.i = pos_1;
+                break :blk_1 !match_1;
+            } and try p.parseErrorUnionExpr()) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseErrorUnionExpr(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defErrorUnionExpr);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseSuffixExpr() and blk_2: {
+                const pos_2 = p.i;
+                if (try p.parseEXCLAMATIONMARK() and try p.parseTypeExpr()) break :blk_2 true;
+                p.i = pos_2;
+                if (blk_3: {
+                    const pos_3 = p.i;
+                    const match_3 = try p.parseEXCLAMATIONMARK();
+                    p.i = pos_3;
+                    break :blk_3 !match_3;
+                }) break :blk_2 true;
+                p.i = pos_2;
+                break :blk_2 false;
+            }) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseSuffixExpr(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defSuffixExpr);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parsePrimaryTypeExpr() and blk_1: {
+                var i_1: usize = 0;
+                while (try p.parseSuffixOp()) {
+                    if (i_1 > max_depth) return error.MaxDepth;
+                    i_1 += 1;
+                }
+                break :blk_1 true;
+            } and blk_1: {
+                const pos_1 = p.i;
+                const match_1 = try p.parseSuffixOpPrefix();
+                p.i = pos_1;
+                break :blk_1 !match_1;
+            }) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parsePrimaryTypeExpr(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defPrimaryTypeExpr);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseBUILTINIDENTIFIER() and try p.parseFnCallArguments()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseCHAR_LITERAL()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseContainerType()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseDOT() and try p.parseIDENTIFIER()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseDOT() and try p.parseInitList()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseErrorSetDecl()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseFnProto()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseGroupedExpr()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseLabeledTypeExpr()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseIDENTIFIER()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseIfTypeExpr()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseKEYWORD_comptime() and try p.parseTypeExpr()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseKEYWORD_error() and try p.parseDOT() and try p.parseIDENTIFIER()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseKEYWORD_anyframe()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseKEYWORD_unreachable()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseNUMBERLITERAL()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseSTRINGLITERAL()) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseContainerType(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defContainerType);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if ((blk_3: {
+                const pos_3 = p.i;
+                if (try p.parseKEYWORD_extern()) break :blk_3 true;
+                p.i = pos_3;
+                if (try p.parseKEYWORD_packed()) break :blk_3 true;
+                p.i = pos_3;
+                break :blk_3 false;
+            } or true) and try p.parseContainerTypeAuto()) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseErrorSetDecl(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defErrorSetDecl);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseKEYWORD_error() and try p.parseLBRACE() and try p.parseIdentifierList() and try p.parseRBRACE()) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseGroupedExpr(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defGroupedExpr);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseLPAREN() and try p.parseExpr() and try p.parseRPAREN()) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseIfTypeExpr(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defIfTypeExpr);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseIfPrefix() and try p.parseTypeExpr() and blk_2: {
+                const pos_2 = p.i;
+                if (try p.parseKEYWORD_else() and (try p.parsePayload() or true) and try p.parseTypeExpr()) break :blk_2 true;
+                p.i = pos_2;
+                if (blk_3: {
+                    const pos_3 = p.i;
+                    const match_3 = try p.parseKEYWORD_else();
+                    p.i = pos_3;
+                    break :blk_3 !match_3;
+                }) break :blk_2 true;
+                p.i = pos_2;
+                break :blk_2 false;
+            }) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseLabeledTypeExpr(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defLabeledTypeExpr);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseBlockLabel() and try p.parseBlock()) break :blk_0 true;
+            p.i = pos_0;
+            if ((try p.parseBlockLabel() or true) and try p.parseLoopTypeExpr()) break :blk_0 true;
+            p.i = pos_0;
+            if ((try p.parseBlockLabel() or true) and try p.parseSwitchExpr()) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseLoopTypeExpr(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defLoopTypeExpr);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if ((try p.parseKEYWORD_inline() or true) and blk_2: {
+                const pos_2 = p.i;
+                if (try p.parseForTypeExpr()) break :blk_2 true;
+                p.i = pos_2;
+                if (try p.parseWhileTypeExpr()) break :blk_2 true;
+                p.i = pos_2;
+                break :blk_2 false;
+            }) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseForTypeExpr(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defForTypeExpr);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseForPrefix() and try p.parseTypeExpr() and blk_2: {
+                const pos_2 = p.i;
+                if (try p.parseKEYWORD_else() and try p.parseTypeExpr()) break :blk_2 true;
+                p.i = pos_2;
+                if (blk_3: {
+                    const pos_3 = p.i;
+                    const match_3 = try p.parseKEYWORD_else();
+                    p.i = pos_3;
+                    break :blk_3 !match_3;
+                }) break :blk_2 true;
+                p.i = pos_2;
+                break :blk_2 false;
+            }) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseWhileTypeExpr(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defWhileTypeExpr);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseWhilePrefix() and try p.parseTypeExpr() and blk_2: {
+                const pos_2 = p.i;
+                if (try p.parseKEYWORD_else() and (try p.parsePayload() or true) and try p.parseTypeExpr()) break :blk_2 true;
+                p.i = pos_2;
+                if (blk_3: {
+                    const pos_3 = p.i;
+                    const match_3 = try p.parseKEYWORD_else();
+                    p.i = pos_3;
+                    break :blk_3 !match_3;
+                }) break :blk_2 true;
+                p.i = pos_2;
+                break :blk_2 false;
+            }) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseSwitchExpr(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defSwitchExpr);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseKEYWORD_switch() and try p.parseLPAREN() and try p.parseExpr() and try p.parseRPAREN() and try p.parseLBRACE() and try p.parseSwitchProngList() and try p.parseRBRACE()) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseAsmExpr(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defAsmExpr);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseKEYWORD_asm() and (try p.parseKEYWORD_volatile() or true) and try p.parseLPAREN() and try p.parseExpr() and (try p.parseAsmOutput() or true) and try p.parseRPAREN()) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseAsmOutput(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defAsmOutput);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseCOLON() and try p.parseAsmOutputList() and (try p.parseAsmInput() or true)) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseAsmOutputItem(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defAsmOutputItem);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseLBRACKET() and try p.parseIDENTIFIER() and try p.parseRBRACKET() and try p.parseSTRINGLITERALSINGLE() and try p.parseLPAREN() and blk_2: {
+                const pos_2 = p.i;
+                if (try p.parseMINUSRARROW() and try p.parseTypeExpr()) break :blk_2 true;
+                p.i = pos_2;
+                if (try p.parseIDENTIFIER()) break :blk_2 true;
+                p.i = pos_2;
+                break :blk_2 false;
+            } and try p.parseRPAREN()) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseAsmInput(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defAsmInput);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseCOLON() and try p.parseAsmInputList() and (try p.parseAsmClobbers() or true)) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseAsmInputItem(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defAsmInputItem);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseLBRACKET() and try p.parseIDENTIFIER() and try p.parseRBRACKET() and try p.parseSTRINGLITERALSINGLE() and try p.parseLPAREN() and try p.parseExpr() and try p.parseRPAREN()) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseAsmClobbers(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defAsmClobbers);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseCOLON() and try p.parseExpr()) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseBreakLabel(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defBreakLabel);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseCOLON() and try p.parseIDENTIFIER()) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseBlockLabel(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defBlockLabel);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseIDENTIFIER() and try p.parseCOLON()) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseFieldInit(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defFieldInit);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseDOT() and try p.parseIDENTIFIER() and try p.parseEQUAL() and try p.parseExpr()) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseWhileContinueExpr(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defWhileContinueExpr);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseCOLON() and try p.parseLPAREN() and try p.parseAssignExpr() and try p.parseRPAREN()) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseLinkSection(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defLinkSection);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseKEYWORD_linksection() and try p.parseLPAREN() and try p.parseExpr() and try p.parseRPAREN()) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseAddrSpace(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defAddrSpace);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseKEYWORD_addrspace() and try p.parseLPAREN() and try p.parseExpr() and try p.parseRPAREN()) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseCallConv(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defCallConv);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseKEYWORD_callconv() and try p.parseLPAREN() and try p.parseExpr() and try p.parseRPAREN()) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseParamDecl(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defParamDecl);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if ((try p.parsedoc_comment() or true) and blk_2: {
+                const pos_2 = p.i;
+                if (try p.parseKEYWORD_noalias()) break :blk_2 true;
+                p.i = pos_2;
+                if ((try p.parseKEYWORD_comptime() or true)) break :blk_2 true;
+                p.i = pos_2;
+                break :blk_2 false;
+            } and (blk_3: {
+                const pos_3 = p.i;
+                if (try p.parseIDENTIFIER() and try p.parseCOLON()) break :blk_3 true;
+                p.i = pos_3;
+                break :blk_3 false;
+            } or true) and try p.parseParamType()) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseParamType(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defParamType);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseKEYWORD_anytype()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseTypeExpr()) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseIfPrefix(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defIfPrefix);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseKEYWORD_if() and try p.parseLPAREN() and try p.parseExpr() and try p.parseRPAREN() and (try p.parsePtrPayload() or true)) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseWhilePrefix(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defWhilePrefix);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseKEYWORD_while() and try p.parseLPAREN() and try p.parseExpr() and try p.parseRPAREN() and (try p.parsePtrPayload() or true) and (try p.parseWhileContinueExpr() or true)) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseForPrefix(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defForPrefix);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseKEYWORD_for() and try p.parseLPAREN() and try p.parseForArgumentsList() and try p.parseRPAREN() and try p.parsePtrListPayload()) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parsePayload(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defPayload);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parsePIPE() and try p.parseIDENTIFIER() and try p.parsePIPE()) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parsePtrPayload(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defPtrPayload);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parsePIPE() and (try p.parseASTERISK() or true) and try p.parseIDENTIFIER() and try p.parsePIPE()) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parsePtrIndexPayload(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defPtrIndexPayload);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parsePIPE() and (try p.parseASTERISK() or true) and try p.parseIDENTIFIER() and (blk_3: {
+                const pos_3 = p.i;
+                if (try p.parseCOMMA() and try p.parseIDENTIFIER()) break :blk_3 true;
+                p.i = pos_3;
+                break :blk_3 false;
+            } or true) and try p.parsePIPE()) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parsePtrListPayload(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defPtrListPayload);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parsePIPE() and (try p.parseASTERISK() or true) and try p.parseIDENTIFIER() and blk_1: {
+                var i_1: usize = 0;
+                while (blk_3: {
+                    const pos_3 = p.i;
+                    if (try p.parseCOMMA() and (try p.parseASTERISK() or true) and try p.parseIDENTIFIER()) break :blk_3 true;
+                    p.i = pos_3;
+                    break :blk_3 false;
+                }) {
+                    if (i_1 > max_depth) return error.MaxDepth;
+                    i_1 += 1;
+                }
+                break :blk_1 true;
+            } and (try p.parseCOMMA() or true) and try p.parsePIPE()) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseSwitchProng(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defSwitchProng);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if ((try p.parseKEYWORD_inline() or true) and try p.parseSwitchCase() and try p.parseEQUALRARROW() and (try p.parsePtrIndexPayload() or true) and try p.parseSingleAssignExpr()) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseSwitchCase(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defSwitchCase);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseSwitchItem() and blk_1: {
+                var i_1: usize = 0;
+                while (blk_3: {
+                    const pos_3 = p.i;
+                    if (try p.parseCOMMA() and try p.parseSwitchItem()) break :blk_3 true;
+                    p.i = pos_3;
+                    break :blk_3 false;
+                }) {
+                    if (i_1 > max_depth) return error.MaxDepth;
+                    i_1 += 1;
+                }
+                break :blk_1 true;
+            } and (try p.parseCOMMA() or true)) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseKEYWORD_else()) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseSwitchItem(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defSwitchItem);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseExpr() and (blk_3: {
+                const pos_3 = p.i;
+                if (try p.parseDOT3() and try p.parseExpr()) break :blk_3 true;
+                p.i = pos_3;
+                break :blk_3 false;
+            } or true)) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseForArgumentsList(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defForArgumentsList);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseForItem() and blk_1: {
+                var i_1: usize = 0;
+                while (blk_3: {
+                    const pos_3 = p.i;
+                    if (try p.parseCOMMA() and try p.parseForItem()) break :blk_3 true;
+                    p.i = pos_3;
+                    break :blk_3 false;
+                }) {
+                    if (i_1 > max_depth) return error.MaxDepth;
+                    i_1 += 1;
+                }
+                break :blk_1 true;
+            } and (try p.parseCOMMA() or true)) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseForItem(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defForItem);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseExpr() and blk_2: {
+                const pos_2 = p.i;
+                if (try p.parseDOT2() and blk_4: {
+                    const pos_4 = p.i;
+                    if (try p.parseExpr()) break :blk_4 true;
+                    p.i = pos_4;
+                    if (blk_5: {
+                        const pos_5 = p.i;
+                        const match_5 = try p.parseExprPrefix();
+                        p.i = pos_5;
+                        break :blk_5 !match_5;
+                    }) break :blk_4 true;
+                    p.i = pos_4;
+                    break :blk_4 false;
+                }) break :blk_2 true;
+                p.i = pos_2;
+                if (blk_3: {
+                    const pos_3 = p.i;
+                    const match_3 = try p.parseDOT2();
+                    p.i = pos_3;
+                    break :blk_3 !match_3;
+                }) break :blk_2 true;
+                p.i = pos_2;
+                break :blk_2 false;
+            }) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseAssignOp(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defAssignOp);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseASTERISKEQUAL()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseASTERISKPIPEEQUAL()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseSLASHEQUAL()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parsePERCENTEQUAL()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parsePLUSEQUAL()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parsePLUSPIPEEQUAL()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseMINUSEQUAL()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseMINUSPIPEEQUAL()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseLARROW2EQUAL()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseLARROW2PIPEEQUAL()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseRARROW2EQUAL()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseAMPERSANDEQUAL()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseCARETEQUAL()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parsePIPEEQUAL()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseASTERISKPERCENTEQUAL()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parsePLUSPERCENTEQUAL()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseMINUSPERCENTEQUAL()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseEQUAL()) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseOrOp(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defOrOp);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parsepre_op_white() and try p.parseKEYWORD_or() and try p.parsepost_op_white()) break :blk_0 true;
+            p.i = pos_0;
+            if (blk_1: {
+                const pos_1 = p.i;
+                const match_1 = try p.parsepre_op_white();
+                p.i = pos_1;
+                break :blk_1 !match_1;
+            } and try p.parseKEYWORD_or() and blk_1: {
+                const pos_1 = p.i;
+                const match_1 = try p.parsepost_op_white();
+                p.i = pos_1;
+                break :blk_1 !match_1;
+            }) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseAndOp(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defAndOp);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parsepre_op_white() and try p.parseKEYWORD_and() and try p.parsepost_op_white()) break :blk_0 true;
+            p.i = pos_0;
+            if (blk_1: {
+                const pos_1 = p.i;
+                const match_1 = try p.parsepre_op_white();
+                p.i = pos_1;
+                break :blk_1 !match_1;
+            } and try p.parseKEYWORD_and() and blk_1: {
+                const pos_1 = p.i;
+                const match_1 = try p.parsepost_op_white();
+                p.i = pos_1;
+                break :blk_1 !match_1;
+            }) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseCompareOp(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defCompareOp);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parsepre_op_white() and try p.parseCompareOpTok() and try p.parsepost_op_white()) break :blk_0 true;
+            p.i = pos_0;
+            if (blk_1: {
+                const pos_1 = p.i;
+                const match_1 = try p.parsepre_op_white();
+                p.i = pos_1;
+                break :blk_1 !match_1;
+            } and try p.parseCompareOpTok() and blk_1: {
+                const pos_1 = p.i;
+                const match_1 = try p.parsepost_op_white();
+                p.i = pos_1;
+                break :blk_1 !match_1;
+            }) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseCompareOpTok(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defCompareOpTok);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseEQUALEQUAL()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseEXCLAMATIONMARKEQUAL()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseLARROW()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseRARROW()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseLARROWEQUAL()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseRARROWEQUAL()) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseBitwiseOp(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defBitwiseOp);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parsepre_op_white() and try p.parseBitwiseOpTok() and try p.parsepost_op_white()) break :blk_0 true;
+            p.i = pos_0;
+            if (blk_1: {
+                const pos_1 = p.i;
+                const match_1 = try p.parsepre_op_white();
+                p.i = pos_1;
+                break :blk_1 !match_1;
+            } and try p.parseBitwiseOpTok() and blk_1: {
+                const pos_1 = p.i;
+                const match_1 = try p.parsepost_op_white();
+                p.i = pos_1;
+                break :blk_1 !match_1;
+            }) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parsepre_op_white() and try p.parseKEYWORD_catch() and try p.parsepost_op_white() and (try p.parsePayload() or true)) break :blk_0 true;
+            p.i = pos_0;
+            if (blk_1: {
+                const pos_1 = p.i;
+                const match_1 = try p.parsepre_op_white();
+                p.i = pos_1;
+                break :blk_1 !match_1;
+            } and try p.parseKEYWORD_catch() and blk_1: {
+                const pos_1 = p.i;
+                const match_1 = try p.parsepost_op_white();
+                p.i = pos_1;
+                break :blk_1 !match_1;
+            } and (try p.parsePayload() or true)) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseBitwiseOpTok(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defBitwiseOpTok);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseAMPERSAND() and blk_1: {
+                const pos_1 = p.i;
+                const match_1 = (p.i < p.source.len and switch (p.source[p.i]) {
+                    '&'...'&',
+                    => blk_2: {
+                        p.i += 1;
+                        break :blk_2 true;
+                    },
+                    else => false,
+                });
+                p.i = pos_1;
+                break :blk_1 !match_1;
+            }) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseCARET()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parsePIPE()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseKEYWORD_orelse()) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseBitShiftOp(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defBitShiftOp);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parsepre_op_white() and try p.parseBitShiftOpTok() and try p.parsepost_op_white()) break :blk_0 true;
+            p.i = pos_0;
+            if (blk_1: {
+                const pos_1 = p.i;
+                const match_1 = try p.parsepre_op_white();
+                p.i = pos_1;
+                break :blk_1 !match_1;
+            } and try p.parseBitShiftOpTok() and blk_1: {
+                const pos_1 = p.i;
+                const match_1 = try p.parsepost_op_white();
+                p.i = pos_1;
+                break :blk_1 !match_1;
+            }) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseBitShiftOpTok(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defBitShiftOpTok);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseLARROW2()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseRARROW2()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseLARROW2PIPE()) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseAdditionOp(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defAdditionOp);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parsepre_op_white() and try p.parseAdditionOpTok() and try p.parsepost_op_white()) break :blk_0 true;
+            p.i = pos_0;
+            if (blk_1: {
+                const pos_1 = p.i;
+                const match_1 = try p.parsepre_op_white();
+                p.i = pos_1;
+                break :blk_1 !match_1;
+            } and try p.parseAdditionOpTok() and blk_1: {
+                const pos_1 = p.i;
+                const match_1 = try p.parsepost_op_white();
+                p.i = pos_1;
+                break :blk_1 !match_1;
+            }) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseAdditionOpTok(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defAdditionOpTok);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parsePLUS()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseMINUS()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parsePLUS2()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parsePLUSPERCENT()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseMINUSPERCENT()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parsePLUSPIPE()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseMINUSPIPE()) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseMultiplyOp(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defMultiplyOp);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parsepre_op_white() and try p.parseMultiplyOpTok() and try p.parsepost_op_white()) break :blk_0 true;
+            p.i = pos_0;
+            if (blk_1: {
+                const pos_1 = p.i;
+                const match_1 = try p.parsepre_op_white();
+                p.i = pos_1;
+                break :blk_1 !match_1;
+            } and try p.parseMultiplyOpTok() and blk_1: {
+                const pos_1 = p.i;
+                const match_1 = try p.parsepost_op_white();
+                p.i = pos_1;
+                break :blk_1 !match_1;
+            }) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseMultiplyOpTok(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defMultiplyOpTok);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parsePIPE2()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseASTERISK()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseSLASH()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parsePERCENT()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseASTERISKPERCENT()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseASTERISKPIPE()) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parsePrefixOp(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defPrefixOp);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseEXCLAMATIONMARK()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseMINUS()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseTILDE()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseMINUSPERCENT()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseAMPERSAND()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseKEYWORD_try()) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parsePrefixTypeOp(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defPrefixTypeOp);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseQUESTIONMARK()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseKEYWORD_anyframe() and try p.parseMINUSRARROW()) break :blk_0 true;
+            p.i = pos_0;
+            if (blk_2: {
+                const pos_2 = p.i;
+                if (try p.parseManyPtrTypeStart()) break :blk_2 true;
+                p.i = pos_2;
+                if (try p.parseSliceTypeStart()) break :blk_2 true;
+                p.i = pos_2;
+                break :blk_2 false;
+            } and try p.parsePtrMods()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseSinglePtrTypeStart() and try p.parseSinglePtrMods()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseArrayTypeStart()) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parsePtrMods(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defPtrMods);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (blk_1: {
+                var i_1: usize = 0;
+                while (try p.parsePtrMod()) {
+                    if (i_1 > max_depth) return error.MaxDepth;
+                    i_1 += 1;
+                }
+                break :blk_1 true;
+            } and blk_1: {
+                const pos_1 = p.i;
+                const match_1 = try p.parseKEYWORD_addrspace();
+                p.i = pos_1;
+                break :blk_1 !match_1;
+            } and (try p.parseByteAlign() or true) and blk_1: {
+                var i_1: usize = 0;
+                while (try p.parsePtrMod()) {
+                    if (i_1 > max_depth) return error.MaxDepth;
+                    i_1 += 1;
+                }
+                break :blk_1 true;
+            } and (try p.parseAddrSpace() or true) and blk_1: {
+                var i_1: usize = 0;
+                while (try p.parsePtrMod()) {
+                    if (i_1 > max_depth) return error.MaxDepth;
+                    i_1 += 1;
+                }
+                break :blk_1 true;
+            }) break :blk_0 true;
+            p.i = pos_0;
+            if (blk_1: {
+                var i_1: usize = 0;
+                while (try p.parsePtrMod()) {
+                    if (i_1 > max_depth) return error.MaxDepth;
+                    i_1 += 1;
+                }
+                break :blk_1 true;
+            } and blk_1: {
+                const pos_1 = p.i;
+                const match_1 = try p.parseKEYWORD_align();
+                p.i = pos_1;
+                break :blk_1 !match_1;
+            } and (try p.parseAddrSpace() or true) and blk_1: {
+                var i_1: usize = 0;
+                while (try p.parsePtrMod()) {
+                    if (i_1 > max_depth) return error.MaxDepth;
+                    i_1 += 1;
+                }
+                break :blk_1 true;
+            } and (try p.parseByteAlign() or true) and blk_1: {
+                var i_1: usize = 0;
+                while (try p.parsePtrMod()) {
+                    if (i_1 > max_depth) return error.MaxDepth;
+                    i_1 += 1;
+                }
+                break :blk_1 true;
+            }) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseSinglePtrMods(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defSinglePtrMods);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (blk_1: {
+                var i_1: usize = 0;
+                while (try p.parsePtrMod()) {
+                    if (i_1 > max_depth) return error.MaxDepth;
+                    i_1 += 1;
+                }
+                break :blk_1 true;
+            } and blk_1: {
+                const pos_1 = p.i;
+                const match_1 = try p.parseKEYWORD_addrspace();
+                p.i = pos_1;
+                break :blk_1 !match_1;
+            } and (try p.parseBitAlign() or true) and blk_1: {
+                var i_1: usize = 0;
+                while (try p.parsePtrMod()) {
+                    if (i_1 > max_depth) return error.MaxDepth;
+                    i_1 += 1;
+                }
+                break :blk_1 true;
+            } and (try p.parseAddrSpace() or true) and blk_1: {
+                var i_1: usize = 0;
+                while (try p.parsePtrMod()) {
+                    if (i_1 > max_depth) return error.MaxDepth;
+                    i_1 += 1;
+                }
+                break :blk_1 true;
+            }) break :blk_0 true;
+            p.i = pos_0;
+            if (blk_1: {
+                var i_1: usize = 0;
+                while (try p.parsePtrMod()) {
+                    if (i_1 > max_depth) return error.MaxDepth;
+                    i_1 += 1;
+                }
+                break :blk_1 true;
+            } and blk_1: {
+                const pos_1 = p.i;
+                const match_1 = try p.parseKEYWORD_align();
+                p.i = pos_1;
+                break :blk_1 !match_1;
+            } and (try p.parseAddrSpace() or true) and blk_1: {
+                var i_1: usize = 0;
+                while (try p.parsePtrMod()) {
+                    if (i_1 > max_depth) return error.MaxDepth;
+                    i_1 += 1;
+                }
+                break :blk_1 true;
+            } and (try p.parseBitAlign() or true) and blk_1: {
+                var i_1: usize = 0;
+                while (try p.parsePtrMod()) {
+                    if (i_1 > max_depth) return error.MaxDepth;
+                    i_1 += 1;
+                }
+                break :blk_1 true;
+            }) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parsePtrMod(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defPtrMod);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseKEYWORD_allowzero()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseKEYWORD_const()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseKEYWORD_volatile()) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parsePrefixTypeOpPrefix(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defPrefixTypeOpPrefix);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseQUESTIONMARK()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseKEYWORD_anyframe() and try p.parseMINUSRARROW()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseLBRACKET()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseASTERISK()) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseSuffixOp(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defSuffixOp);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseLBRACKET() and try p.parseExpr() and (blk_3: {
+                const pos_3 = p.i;
+                if (try p.parseDOT2() and blk_5: {
+                    const pos_5 = p.i;
+                    if (try p.parseExpr()) break :blk_5 true;
+                    p.i = pos_5;
+                    if (blk_6: {
+                        const pos_6 = p.i;
+                        const match_6 = try p.parseExprPrefix();
+                        p.i = pos_6;
+                        break :blk_6 !match_6;
+                    }) break :blk_5 true;
+                    p.i = pos_5;
+                    break :blk_5 false;
+                } and (blk_6: {
+                    const pos_6 = p.i;
+                    if (try p.parseCOLON() and try p.parseExpr()) break :blk_6 true;
+                    p.i = pos_6;
+                    break :blk_6 false;
+                } or true)) break :blk_3 true;
+                p.i = pos_3;
+                break :blk_3 false;
+            } or true) and try p.parseRBRACKET()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseDOT() and try p.parseIDENTIFIER()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseDOTASTERISK()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseDOT() and try p.parseQUESTIONMARK()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseFnCallArguments()) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseSuffixOpPrefix(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defSuffixOpPrefix);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseLBRACKET()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseDOT() and try p.parseIDENTIFIER()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseDOTASTERISK()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseDOT() and try p.parseQUESTIONMARK()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseLPAREN()) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseFnCallArguments(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defFnCallArguments);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseLPAREN() and try p.parseExprList() and try p.parseRPAREN()) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseSliceTypeStart(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defSliceTypeStart);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseLBRACKET() and (blk_3: {
+                const pos_3 = p.i;
+                if (try p.parseCOLON() and try p.parseExpr()) break :blk_3 true;
+                p.i = pos_3;
+                break :blk_3 false;
+            } or true) and try p.parseRBRACKET()) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseSinglePtrTypeStart(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defSinglePtrTypeStart);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseASTERISK()) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseManyPtrTypeStart(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defManyPtrTypeStart);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseLBRACKET() and try p.parseASTERISK() and (blk_3: {
+                const pos_3 = p.i;
+                if (try p.parseLETTERC()) break :blk_3 true;
+                p.i = pos_3;
+                if (try p.parseCOLON() and try p.parseExpr()) break :blk_3 true;
+                p.i = pos_3;
+                break :blk_3 false;
+            } or true) and try p.parseRBRACKET()) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseArrayTypeStart(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defArrayTypeStart);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseLBRACKET() and blk_1: {
+                const pos_1 = p.i;
+                const match_1 = try p.parseASTERISK();
+                p.i = pos_1;
+                break :blk_1 !match_1;
+            } and try p.parseExpr() and (blk_3: {
+                const pos_3 = p.i;
+                if (try p.parseCOLON() and try p.parseExpr()) break :blk_3 true;
+                p.i = pos_3;
+                break :blk_3 false;
+            } or true) and try p.parseRBRACKET()) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseContainerTypeAuto(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defContainerTypeAuto);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseContainerTypeKind() and try p.parseLBRACE() and try p.parseContainerMembers() and try p.parseRBRACE()) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseContainerTypeKind(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defContainerTypeKind);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseKEYWORD_struct() and (blk_3: {
+                const pos_3 = p.i;
+                if (try p.parseLPAREN() and try p.parseExpr() and try p.parseRPAREN()) break :blk_3 true;
+                p.i = pos_3;
+                break :blk_3 false;
+            } or true)) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseKEYWORD_opaque()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseKEYWORD_enum() and (blk_3: {
+                const pos_3 = p.i;
+                if (try p.parseLPAREN() and try p.parseExpr() and try p.parseRPAREN()) break :blk_3 true;
+                p.i = pos_3;
+                break :blk_3 false;
+            } or true)) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseKEYWORD_union() and (blk_3: {
+                const pos_3 = p.i;
+                if (try p.parseLPAREN() and blk_5: {
+                    const pos_5 = p.i;
+                    if (try p.parseKEYWORD_enum() and (blk_8: {
+                        const pos_8 = p.i;
+                        if (try p.parseLPAREN() and try p.parseExpr() and try p.parseRPAREN()) break :blk_8 true;
+                        p.i = pos_8;
+                        break :blk_8 false;
+                    } or true)) break :blk_5 true;
+                    p.i = pos_5;
+                    if (try p.parseExpr()) break :blk_5 true;
+                    p.i = pos_5;
+                    break :blk_5 false;
+                } and try p.parseRPAREN()) break :blk_3 true;
+                p.i = pos_3;
+                break :blk_3 false;
+            } or true)) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseByteAlign(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defByteAlign);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseKEYWORD_align() and try p.parseLPAREN() and try p.parseExpr() and try p.parseRPAREN()) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseBitAlign(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defBitAlign);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseKEYWORD_align() and try p.parseLPAREN() and try p.parseExpr() and (blk_3: {
+                const pos_3 = p.i;
+                if (try p.parseCOLON() and try p.parseExpr() and try p.parseCOLON() and try p.parseExpr()) break :blk_3 true;
+                p.i = pos_3;
+                break :blk_3 false;
+            } or true) and try p.parseRPAREN()) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseIdentifierList(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defIdentifierList);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if ((blk_3: {
+                const pos_3 = p.i;
+                if ((try p.parsedoc_comment() or true) and try p.parseIDENTIFIER() and (blk_6: {
+                    const pos_6 = p.i;
+                    if (try p.parseCOMMA() and try p.parseIdentifierList()) break :blk_6 true;
+                    p.i = pos_6;
+                    break :blk_6 false;
+                } or true)) break :blk_3 true;
+                p.i = pos_3;
+                break :blk_3 false;
+            } or true)) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseSwitchProngList(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defSwitchProngList);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if ((blk_3: {
+                const pos_3 = p.i;
+                if (try p.parseSwitchProng() and (blk_6: {
+                    const pos_6 = p.i;
+                    if (try p.parseCOMMA() and try p.parseSwitchProngList()) break :blk_6 true;
+                    p.i = pos_6;
+                    break :blk_6 false;
+                } or true)) break :blk_3 true;
+                p.i = pos_3;
+                break :blk_3 false;
+            } or true)) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseAsmOutputList(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defAsmOutputList);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if ((blk_3: {
+                const pos_3 = p.i;
+                if (try p.parseAsmOutputItem() and (blk_6: {
+                    const pos_6 = p.i;
+                    if (try p.parseCOMMA() and try p.parseAsmOutputList()) break :blk_6 true;
+                    p.i = pos_6;
+                    break :blk_6 false;
+                } or true)) break :blk_3 true;
+                p.i = pos_3;
+                break :blk_3 false;
+            } or true)) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseAsmInputList(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defAsmInputList);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if ((blk_3: {
+                const pos_3 = p.i;
+                if (try p.parseAsmInputItem() and (blk_6: {
+                    const pos_6 = p.i;
+                    if (try p.parseCOMMA() and try p.parseAsmInputList()) break :blk_6 true;
+                    p.i = pos_6;
+                    break :blk_6 false;
+                } or true)) break :blk_3 true;
+                p.i = pos_3;
+                break :blk_3 false;
+            } or true)) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseParamDeclList(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defParamDeclList);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseLPAREN() and try p.parseParamDeclListRest()) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseParamDeclListRest(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defParamDeclListRest);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseRPAREN()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseDOT3() and (try p.parseCOMMA() or true) and try p.parseRPAREN()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseParamDecl() and blk_2: {
+                const pos_2 = p.i;
+                if (try p.parseCOMMA() and try p.parseParamDeclListRest()) break :blk_2 true;
+                p.i = pos_2;
+                if (try p.parseRPAREN()) break :blk_2 true;
+                p.i = pos_2;
+                break :blk_2 false;
+            }) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseExprList(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defExprList);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseExpr() and (blk_3: {
+                const pos_3 = p.i;
+                if (try p.parseCOMMA() and try p.parseExprList()) break :blk_3 true;
+                p.i = pos_3;
+                break :blk_3 false;
+            } or true)) break :blk_0 true;
+            p.i = pos_0;
+            if (blk_1: {
+                const pos_1 = p.i;
+                const match_1 = try p.parseExprPrefix();
+                p.i = pos_1;
+                break :blk_1 !match_1;
+            }) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseExprPrefix(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defExprPrefix);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseASTERISK()) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parsebyte_order_mark(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defbyte_order_mark);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (blk_1: {
+                if (std.mem.startsWith(u8, p.source[p.i..], "\xef\xbb\xbf")) {
+                    p.i += 3;
+                    break :blk_1 true;
+                }
+                break :blk_1 false;
+            }) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parsesof(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defsof);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if ((p.i == 0) and (try p.parsebyte_order_mark() or true)) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseeof(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defeof);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (blk_1: {
+                const pos_1 = p.i;
+                const match_1 = blk_2: {
+                    if (p.i < p.source.len) {
+                        p.i += 1;
+                        break :blk_2 true;
+                    }
+                    break :blk_2 false;
+                };
+                p.i = pos_1;
+                break :blk_1 !match_1;
+            }) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseox80_oxBF(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defox80_oxBF);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if ((p.i < p.source.len and switch (p.source[p.i]) {
+                '\x80'...'\xbf',
+                => blk_1: {
+                    p.i += 1;
+                    break :blk_1 true;
+                },
+                else => false,
+            })) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseoxF4(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defoxF4);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (blk_1: {
+                if (std.mem.startsWith(u8, p.source[p.i..], "\xf4")) {
+                    p.i += 1;
+                    break :blk_1 true;
+                }
+                break :blk_1 false;
+            }) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseox80_ox8F(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defox80_ox8F);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if ((p.i < p.source.len and switch (p.source[p.i]) {
+                '\x80'...'\x8f',
+                => blk_1: {
+                    p.i += 1;
+                    break :blk_1 true;
+                },
+                else => false,
+            })) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseoxF1_oxF3(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defoxF1_oxF3);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if ((p.i < p.source.len and switch (p.source[p.i]) {
+                '\xf1'...'\xf3',
+                => blk_1: {
+                    p.i += 1;
+                    break :blk_1 true;
+                },
+                else => false,
+            })) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseoxF0(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defoxF0);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (blk_1: {
+                if (std.mem.startsWith(u8, p.source[p.i..], "\xf0")) {
+                    p.i += 1;
+                    break :blk_1 true;
+                }
+                break :blk_1 false;
+            }) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseox90_0xBF(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defox90_0xBF);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if ((p.i < p.source.len and switch (p.source[p.i]) {
+                '\x90'...'\xbf',
+                => blk_1: {
+                    p.i += 1;
+                    break :blk_1 true;
+                },
+                else => false,
+            })) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseoxEE_oxEF(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defoxEE_oxEF);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if ((p.i < p.source.len and switch (p.source[p.i]) {
+                '\xee'...'\xef',
+                => blk_1: {
+                    p.i += 1;
+                    break :blk_1 true;
+                },
+                else => false,
+            })) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseoxED(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defoxED);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (blk_1: {
+                if (std.mem.startsWith(u8, p.source[p.i..], "\xed")) {
+                    p.i += 1;
+                    break :blk_1 true;
+                }
+                break :blk_1 false;
+            }) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseox80_ox9F(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defox80_ox9F);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if ((p.i < p.source.len and switch (p.source[p.i]) {
+                '\x80'...'\x9f',
+                => blk_1: {
+                    p.i += 1;
+                    break :blk_1 true;
+                },
+                else => false,
+            })) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseoxE1_oxEC(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defoxE1_oxEC);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if ((p.i < p.source.len and switch (p.source[p.i]) {
+                '\xe1'...'\xec',
+                => blk_1: {
+                    p.i += 1;
+                    break :blk_1 true;
+                },
+                else => false,
+            })) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseoxE0(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defoxE0);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (blk_1: {
+                if (std.mem.startsWith(u8, p.source[p.i..], "\xe0")) {
+                    p.i += 1;
+                    break :blk_1 true;
+                }
+                break :blk_1 false;
+            }) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseoxA0_oxBF(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defoxA0_oxBF);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if ((p.i < p.source.len and switch (p.source[p.i]) {
+                '\xa0'...'\xbf',
+                => blk_1: {
+                    p.i += 1;
+                    break :blk_1 true;
+                },
+                else => false,
+            })) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseoxC2_oxDF(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defoxC2_oxDF);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if ((p.i < p.source.len and switch (p.source[p.i]) {
+                '\xc2'...'\xdf',
+                => blk_1: {
+                    p.i += 1;
+                    break :blk_1 true;
+                },
+                else => false,
+            })) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parsemultibyte_utf8(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defmultibyte_utf8);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseoxF4() and try p.parseox80_ox8F() and try p.parseox80_oxBF() and try p.parseox80_oxBF()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseoxF1_oxF3() and try p.parseox80_oxBF() and try p.parseox80_oxBF() and try p.parseox80_oxBF()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseoxF0() and try p.parseox90_0xBF() and try p.parseox80_oxBF() and try p.parseox80_oxBF()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseoxEE_oxEF() and try p.parseox80_oxBF() and try p.parseox80_oxBF()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseoxED() and try p.parseox80_ox9F() and try p.parseox80_oxBF()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseoxE1_oxEC() and try p.parseox80_oxBF() and try p.parseox80_oxBF()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseoxE0() and try p.parseoxA0_oxBF() and try p.parseox80_oxBF()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseoxC2_oxDF() and try p.parseox80_oxBF()) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parsenon_control_ascii(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defnon_control_ascii);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if ((p.i < p.source.len and switch (p.source[p.i]) {
+                ' '...'~',
+                => blk_1: {
+                    p.i += 1;
+                    break :blk_1 true;
+                },
+                else => false,
+            })) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parsenon_control_utf8(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defnon_control_utf8);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if ((p.i < p.source.len and switch (p.source[p.i]) {
+                ' '...'~',
+                '\x80'...'\xff',
+                => blk_1: {
+                    p.i += 1;
+                    break :blk_1 true;
+                },
+                else => false,
+            })) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parsechar_char(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defchar_char);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (blk_1: {
+                if (std.mem.startsWith(u8, p.source[p.i..], "\\\\")) {
+                    p.i += 2;
+                    break :blk_1 true;
+                }
+                break :blk_1 false;
+            }) break :blk_0 true;
+            p.i = pos_0;
+            if (blk_1: {
+                if (std.mem.startsWith(u8, p.source[p.i..], "\\'")) {
+                    p.i += 2;
+                    break :blk_1 true;
+                }
+                break :blk_1 false;
+            }) break :blk_0 true;
+            p.i = pos_0;
+            if (blk_1: {
+                const pos_1 = p.i;
+                const match_1 = (p.i < p.source.len and switch (p.source[p.i]) {
+                    '\''...'\'',
+                    => blk_2: {
+                        p.i += 1;
+                        break :blk_2 true;
+                    },
+                    else => false,
+                });
+                p.i = pos_1;
+                break :blk_1 !match_1;
+            } and try p.parsenon_control_utf8()) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parsestring_char(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defstring_char);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (blk_1: {
+                if (std.mem.startsWith(u8, p.source[p.i..], "\\\\")) {
+                    p.i += 2;
+                    break :blk_1 true;
+                }
+                break :blk_1 false;
+            }) break :blk_0 true;
+            p.i = pos_0;
+            if (blk_1: {
+                if (std.mem.startsWith(u8, p.source[p.i..], "\\\"")) {
+                    p.i += 2;
+                    break :blk_1 true;
+                }
+                break :blk_1 false;
+            }) break :blk_0 true;
+            p.i = pos_0;
+            if (blk_1: {
+                const pos_1 = p.i;
+                const match_1 = (p.i < p.source.len and switch (p.source[p.i]) {
+                    '"'...'"',
+                    => blk_2: {
+                        p.i += 1;
+                        break :blk_2 true;
+                    },
+                    else => false,
+                });
+                p.i = pos_1;
+                break :blk_1 !match_1;
+            } and try p.parsenon_control_utf8()) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parsecontainer_doc_comment(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defcontainer_doc_comment);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (blk_1: {
+                var match_1 = false;
+                var i_1: usize = 0;
+                while (blk_3: {
+                    const pos_3 = p.i;
+                    if (try p.parseskip() and blk_4: {
+                        if (std.mem.startsWith(u8, p.source[p.i..], "//!")) {
+                            p.i += 3;
+                            break :blk_4 true;
+                        }
+                        break :blk_4 false;
+                    } and blk_4: {
+                        var i_4: usize = 0;
+                        while (try p.parsenon_control_utf8()) {
+                            if (i_4 > max_depth) return error.MaxDepth;
+                            i_4 += 1;
+                        }
+                        break :blk_4 true;
+                    } and try p.parsenewline()) break :blk_3 true;
+                    p.i = pos_3;
+                    break :blk_3 false;
+                }) {
+                    match_1 = true;
+                    if (i_1 > max_depth) return error.MaxDepth;
+                    i_1 += 1;
+                }
+                break :blk_1 match_1;
+            }) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parsedoc_comment(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defdoc_comment);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (blk_2: {
+                const pos_2 = p.i;
+                if (try p.parsesof()) break :blk_2 true;
+                p.i = pos_2;
+                if (try p.parseskip_require_newline()) break :blk_2 true;
+                p.i = pos_2;
+                break :blk_2 false;
+            } and blk_1: {
+                var match_1 = false;
+                var i_1: usize = 0;
+                while (blk_3: {
+                    const pos_3 = p.i;
+                    if (try p.parseskip() and blk_4: {
+                        if (std.mem.startsWith(u8, p.source[p.i..], "///")) {
+                            p.i += 3;
+                            break :blk_4 true;
+                        }
+                        break :blk_4 false;
+                    } and blk_4: {
+                        var i_4: usize = 0;
+                        while (try p.parsenon_control_utf8()) {
+                            if (i_4 > max_depth) return error.MaxDepth;
+                            i_4 += 1;
+                        }
+                        break :blk_4 true;
+                    } and try p.parsenewline()) break :blk_3 true;
+                    p.i = pos_3;
+                    break :blk_3 false;
+                }) {
+                    match_1 = true;
+                    if (i_1 > max_depth) return error.MaxDepth;
+                    i_1 += 1;
+                }
+                break :blk_1 match_1;
+            }) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseline_comment(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defline_comment);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (blk_1: {
+                if (std.mem.startsWith(u8, p.source[p.i..], "//")) {
+                    p.i += 2;
+                    break :blk_1 true;
+                }
+                break :blk_1 false;
+            } and blk_1: {
+                const pos_1 = p.i;
+                const match_1 = (p.i < p.source.len and switch (p.source[p.i]) {
+                    '!'...'!',
+                    '/'...'/',
+                    => blk_2: {
+                        p.i += 1;
+                        break :blk_2 true;
+                    },
+                    else => false,
+                });
+                p.i = pos_1;
+                break :blk_1 !match_1;
+            } and blk_1: {
+                var i_1: usize = 0;
+                while (try p.parsenon_control_utf8()) {
+                    if (i_1 > max_depth) return error.MaxDepth;
+                    i_1 += 1;
+                }
+                break :blk_1 true;
+            } and try p.parsenewline()) break :blk_0 true;
+            p.i = pos_0;
+            if (blk_1: {
+                if (std.mem.startsWith(u8, p.source[p.i..], "////")) {
+                    p.i += 4;
+                    break :blk_1 true;
+                }
+                break :blk_1 false;
+            } and blk_1: {
+                var i_1: usize = 0;
+                while (try p.parsenon_control_utf8()) {
+                    if (i_1 > max_depth) return error.MaxDepth;
+                    i_1 += 1;
+                }
+                break :blk_1 true;
+            } and try p.parsenewline()) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseline_string(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defline_string);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (blk_1: {
+                if (std.mem.startsWith(u8, p.source[p.i..], "\\\\")) {
+                    p.i += 2;
+                    break :blk_1 true;
+                }
+                break :blk_1 false;
+            } and blk_1: {
+                var i_1: usize = 0;
+                while (try p.parsenon_control_utf8()) {
+                    if (i_1 > max_depth) return error.MaxDepth;
+                    i_1 += 1;
+                }
+                break :blk_1 true;
+            } and try p.parsenewline()) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parsenewline(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defnewline);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (blk_1: {
+                const pos_1 = p.i;
+                const match_1 = blk_3: {
+                    const pos_3 = p.i;
+                    if (blk_4: {
+                        if (std.mem.startsWith(u8, p.source[p.i..], "\n")) {
+                            p.i += 1;
+                            break :blk_4 true;
+                        }
+                        break :blk_4 false;
+                    }) break :blk_3 true;
+                    p.i = pos_3;
+                    if (blk_4: {
+                        if (std.mem.startsWith(u8, p.source[p.i..], "\r\n")) {
+                            p.i += 2;
+                            break :blk_4 true;
+                        }
+                        break :blk_4 false;
+                    }) break :blk_3 true;
+                    p.i = pos_3;
+                    if (try p.parseeof()) break :blk_3 true;
+                    p.i = pos_3;
+                    break :blk_3 false;
+                };
+                p.i = pos_1;
+                break :blk_1 match_1;
+            }) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseskip(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defskip);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if ((try p.parsesof() or true) and blk_1: {
+                var i_1: usize = 0;
+                while (blk_3: {
+                    const pos_3 = p.i;
+                    if ((p.i < p.source.len and switch (p.source[p.i]) {
+                        ' '...' ',
+                        '\n'...'\n',
+                        '\t'...'\t',
+                        '\r'...'\r',
+                        => blk_4: {
+                            p.i += 1;
+                            break :blk_4 true;
+                        },
+                        else => false,
+                    })) break :blk_3 true;
+                    p.i = pos_3;
+                    if (try p.parseline_comment()) break :blk_3 true;
+                    p.i = pos_3;
+                    break :blk_3 false;
+                }) {
+                    if (i_1 > max_depth) return error.MaxDepth;
+                    i_1 += 1;
+                }
+                break :blk_1 true;
+            }) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseskip_require_newline(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defskip_require_newline);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (blk_1: {
+                var i_1: usize = 0;
+                while ((p.i < p.source.len and switch (p.source[p.i]) {
+                    ' '...' ',
+                    '\t'...'\t',
+                    '\r'...'\r',
+                    => blk_2: {
+                        p.i += 1;
+                        break :blk_2 true;
+                    },
+                    else => false,
+                })) {
+                    if (i_1 > max_depth) return error.MaxDepth;
+                    i_1 += 1;
+                }
+                break :blk_1 true;
+            } and blk_2: {
+                const pos_2 = p.i;
+                if ((p.i < p.source.len and switch (p.source[p.i]) {
+                    '\n'...'\n',
+                    => blk_3: {
+                        p.i += 1;
+                        break :blk_3 true;
+                    },
+                    else => false,
+                })) break :blk_2 true;
+                p.i = pos_2;
+                if (try p.parseline_comment()) break :blk_2 true;
+                p.i = pos_2;
+                break :blk_2 false;
+            } and try p.parseskip()) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parsepre_op_white(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defpre_op_white);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (blk_1: {
+                var match_1 = false;
+                var i_1: usize = 0;
+                while (blk_3: {
+                    const pos_3 = p.i;
+                    if ((p.i < p.source.len and switch (p.source[p.i]) {
+                        ' '...' ',
+                        '\n'...'\n',
+                        '\t'...'\t',
+                        '\r'...'\r',
+                        => blk_4: {
+                            p.i += 1;
+                            break :blk_4 true;
+                        },
+                        else => false,
+                    })) break :blk_3 true;
+                    p.i = pos_3;
+                    if (try p.parseline_comment()) break :blk_3 true;
+                    p.i = pos_3;
+                    break :blk_3 false;
+                }) {
+                    match_1 = true;
+                    if (i_1 > max_depth) return error.MaxDepth;
+                    i_1 += 1;
+                }
+                break :blk_1 match_1;
+            }) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parsepost_op_white(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defpost_op_white);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if ((p.i < p.source.len and switch (p.source[p.i]) {
+                ' '...' ',
+                '\n'...'\n',
+                '\t'...'\t',
+                '\r'...'\r',
+                => blk_1: {
+                    p.i += 1;
+                    break :blk_1 true;
+                },
+                else => false,
+            }) and try p.parseskip()) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseCHAR_LITERAL(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defCHAR_LITERAL);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseskip() and (p.i < p.source.len and switch (p.source[p.i]) {
+                '\''...'\'',
+                => blk_1: {
+                    p.i += 1;
+                    break :blk_1 true;
+                },
+                else => false,
+            }) and blk_1: {
+                var i_1: usize = 0;
+                while (try p.parsechar_char()) {
+                    if (i_1 > max_depth) return error.MaxDepth;
+                    i_1 += 1;
+                }
+                break :blk_1 true;
+            } and (p.i < p.source.len and switch (p.source[p.i]) {
+                '\''...'\'',
+                => blk_1: {
+                    p.i += 1;
+                    break :blk_1 true;
+                },
+                else => false,
+            })) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parsedigit(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defdigit);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if ((p.i < p.source.len and switch (p.source[p.i]) {
+                '_'...'_',
+                '0'...'9',
+                'A'...'D',
+                'F'...'O',
+                'Q'...'Z',
+                'a'...'d',
+                'f'...'o',
+                'q'...'z',
+                => blk_1: {
+                    p.i += 1;
+                    break :blk_1 true;
+                },
+                else => false,
+            })) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parsedigit_int(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defdigit_int);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parsedigit()) break :blk_0 true;
+            p.i = pos_0;
+            if ((p.i < p.source.len and switch (p.source[p.i]) {
+                'e'...'e',
+                'E'...'E',
+                'p'...'p',
+                'P'...'P',
+                => blk_1: {
+                    p.i += 1;
+                    break :blk_1 true;
+                },
+                else => false,
+            })) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parsedigit_float(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defdigit_float);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parsedigit()) break :blk_0 true;
+            p.i = pos_0;
+            if ((p.i < p.source.len and switch (p.source[p.i]) {
+                'e'...'e',
+                'E'...'E',
+                'p'...'p',
+                'P'...'P',
+                => blk_1: {
+                    p.i += 1;
+                    break :blk_1 true;
+                },
+                else => false,
+            }) and ((p.i < p.source.len and switch (p.source[p.i]) {
+                '-'...'-',
+                '+'...'+',
+                => blk_2: {
+                    p.i += 1;
+                    break :blk_2 true;
+                },
+                else => false,
+            }) or true)) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseNUMBERLITERAL(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defNUMBERLITERAL);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseskip() and (p.i < p.source.len and switch (p.source[p.i]) {
+                '0'...'9',
+                => blk_1: {
+                    p.i += 1;
+                    break :blk_1 true;
+                },
+                else => false,
+            }) and blk_1: {
+                var i_1: usize = 0;
+                while (try p.parsedigit_int()) {
+                    if (i_1 > max_depth) return error.MaxDepth;
+                    i_1 += 1;
+                }
+                break :blk_1 true;
+            } and blk_1: {
+                if (std.mem.startsWith(u8, p.source[p.i..], ".")) {
+                    p.i += 1;
+                    break :blk_1 true;
+                }
+                break :blk_1 false;
+            } and blk_1: {
+                var match_1 = false;
+                var i_1: usize = 0;
+                while (try p.parsedigit_float()) {
+                    match_1 = true;
+                    if (i_1 > max_depth) return error.MaxDepth;
+                    i_1 += 1;
+                }
+                break :blk_1 match_1;
+            }) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseskip() and (p.i < p.source.len and switch (p.source[p.i]) {
+                '0'...'9',
+                => blk_1: {
+                    p.i += 1;
+                    break :blk_1 true;
+                },
+                else => false,
+            }) and blk_1: {
+                var i_1: usize = 0;
+                while (try p.parsedigit_float()) {
+                    if (i_1 > max_depth) return error.MaxDepth;
+                    i_1 += 1;
+                }
+                break :blk_1 true;
+            }) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parsestring(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defstring);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if ((p.i < p.source.len and switch (p.source[p.i]) {
+                '"'...'"',
+                => blk_1: {
+                    p.i += 1;
+                    break :blk_1 true;
+                },
+                else => false,
+            }) and blk_1: {
+                var i_1: usize = 0;
+                while (try p.parsestring_char()) {
+                    if (i_1 > max_depth) return error.MaxDepth;
+                    i_1 += 1;
+                }
+                break :blk_1 true;
+            } and (p.i < p.source.len and switch (p.source[p.i]) {
+                '"'...'"',
+                => blk_1: {
+                    p.i += 1;
+                    break :blk_1 true;
+                },
+                else => false,
+            })) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseSTRINGLITERALSINGLE(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defSTRINGLITERALSINGLE);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseskip() and try p.parsestring()) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseSTRINGLITERAL(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defSTRINGLITERAL);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseskip() and try p.parsestring()) break :blk_0 true;
+            p.i = pos_0;
+            if (blk_1: {
+                var match_1 = false;
+                var i_1: usize = 0;
+                while (blk_3: {
+                    const pos_3 = p.i;
+                    if (try p.parseskip() and try p.parseline_string()) break :blk_3 true;
+                    p.i = pos_3;
+                    break :blk_3 false;
+                }) {
+                    match_1 = true;
+                    if (i_1 > max_depth) return error.MaxDepth;
+                    i_1 += 1;
+                }
+                break :blk_1 match_1;
+            }) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseIDENTIFIER(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defIDENTIFIER);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseskip() and blk_1: {
+                const pos_1 = p.i;
+                const match_1 = try p.parsekeyword();
+                p.i = pos_1;
+                break :blk_1 !match_1;
+            } and (p.i < p.source.len and switch (p.source[p.i]) {
+                'A'...'Z',
+                'a'...'z',
+                '_'...'_',
+                => blk_1: {
+                    p.i += 1;
+                    break :blk_1 true;
+                },
+                else => false,
+            }) and blk_1: {
+                var i_1: usize = 0;
+                while ((p.i < p.source.len and switch (p.source[p.i]) {
+                    'A'...'Z',
+                    'a'...'z',
+                    '0'...'9',
+                    '_'...'_',
+                    => blk_2: {
+                        p.i += 1;
+                        break :blk_2 true;
+                    },
+                    else => false,
+                })) {
+                    if (i_1 > max_depth) return error.MaxDepth;
+                    i_1 += 1;
+                }
+                break :blk_1 true;
+            }) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseskip() and blk_1: {
+                if (std.mem.startsWith(u8, p.source[p.i..], "@")) {
+                    p.i += 1;
+                    break :blk_1 true;
+                }
+                break :blk_1 false;
+            } and try p.parsestring()) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseBUILTINIDENTIFIER(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defBUILTINIDENTIFIER);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseskip() and blk_1: {
+                if (std.mem.startsWith(u8, p.source[p.i..], "@")) {
+                    p.i += 1;
+                    break :blk_1 true;
+                }
+                break :blk_1 false;
+            } and (p.i < p.source.len and switch (p.source[p.i]) {
+                'A'...'Z',
+                'a'...'z',
+                '_'...'_',
+                => blk_1: {
+                    p.i += 1;
+                    break :blk_1 true;
+                },
+                else => false,
+            }) and blk_1: {
+                var i_1: usize = 0;
+                while ((p.i < p.source.len and switch (p.source[p.i]) {
+                    'A'...'Z',
+                    'a'...'z',
+                    '0'...'9',
+                    '_'...'_',
+                    => blk_2: {
+                        p.i += 1;
+                        break :blk_2 true;
+                    },
+                    else => false,
+                })) {
+                    if (i_1 > max_depth) return error.MaxDepth;
+                    i_1 += 1;
+                }
+                break :blk_1 true;
+            }) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseAMPERSAND(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defAMPERSAND);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseskip() and blk_1: {
+                if (std.mem.startsWith(u8, p.source[p.i..], "&")) {
+                    p.i += 1;
+                    break :blk_1 true;
+                }
+                break :blk_1 false;
+            } and blk_1: {
+                const pos_1 = p.i;
+                const match_1 = (p.i < p.source.len and switch (p.source[p.i]) {
+                    '='...'=',
+                    => blk_2: {
+                        p.i += 1;
+                        break :blk_2 true;
+                    },
+                    else => false,
+                });
+                p.i = pos_1;
+                break :blk_1 !match_1;
+            }) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseAMPERSANDEQUAL(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defAMPERSANDEQUAL);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseskip() and blk_1: {
+                if (std.mem.startsWith(u8, p.source[p.i..], "&=")) {
+                    p.i += 2;
+                    break :blk_1 true;
+                }
+                break :blk_1 false;
+            }) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseASTERISK(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defASTERISK);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseskip() and blk_1: {
+                if (std.mem.startsWith(u8, p.source[p.i..], "*")) {
+                    p.i += 1;
+                    break :blk_1 true;
+                }
+                break :blk_1 false;
+            } and blk_1: {
+                const pos_1 = p.i;
+                const match_1 = (p.i < p.source.len and switch (p.source[p.i]) {
+                    '%'...'%',
+                    '='...'=',
+                    '|'...'|',
+                    => blk_2: {
+                        p.i += 1;
+                        break :blk_2 true;
+                    },
+                    else => false,
+                });
+                p.i = pos_1;
+                break :blk_1 !match_1;
+            }) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseASTERISKEQUAL(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defASTERISKEQUAL);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseskip() and blk_1: {
+                if (std.mem.startsWith(u8, p.source[p.i..], "*=")) {
+                    p.i += 2;
+                    break :blk_1 true;
+                }
+                break :blk_1 false;
+            }) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseASTERISKPERCENT(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defASTERISKPERCENT);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseskip() and blk_1: {
+                if (std.mem.startsWith(u8, p.source[p.i..], "*%")) {
+                    p.i += 2;
+                    break :blk_1 true;
+                }
+                break :blk_1 false;
+            } and blk_1: {
+                const pos_1 = p.i;
+                const match_1 = (p.i < p.source.len and switch (p.source[p.i]) {
+                    '='...'=',
+                    => blk_2: {
+                        p.i += 1;
+                        break :blk_2 true;
+                    },
+                    else => false,
+                });
+                p.i = pos_1;
+                break :blk_1 !match_1;
+            }) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseASTERISKPERCENTEQUAL(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defASTERISKPERCENTEQUAL);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseskip() and blk_1: {
+                if (std.mem.startsWith(u8, p.source[p.i..], "*%=")) {
+                    p.i += 3;
+                    break :blk_1 true;
+                }
+                break :blk_1 false;
+            }) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseASTERISKPIPE(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defASTERISKPIPE);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseskip() and blk_1: {
+                if (std.mem.startsWith(u8, p.source[p.i..], "*|")) {
+                    p.i += 2;
+                    break :blk_1 true;
+                }
+                break :blk_1 false;
+            } and blk_1: {
+                const pos_1 = p.i;
+                const match_1 = (p.i < p.source.len and switch (p.source[p.i]) {
+                    '='...'=',
+                    => blk_2: {
+                        p.i += 1;
+                        break :blk_2 true;
+                    },
+                    else => false,
+                });
+                p.i = pos_1;
+                break :blk_1 !match_1;
+            }) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseASTERISKPIPEEQUAL(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defASTERISKPIPEEQUAL);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseskip() and blk_1: {
+                if (std.mem.startsWith(u8, p.source[p.i..], "*|=")) {
+                    p.i += 3;
+                    break :blk_1 true;
+                }
+                break :blk_1 false;
+            }) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseCARET(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defCARET);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseskip() and blk_1: {
+                if (std.mem.startsWith(u8, p.source[p.i..], "^")) {
+                    p.i += 1;
+                    break :blk_1 true;
+                }
+                break :blk_1 false;
+            } and blk_1: {
+                const pos_1 = p.i;
+                const match_1 = (p.i < p.source.len and switch (p.source[p.i]) {
+                    '='...'=',
+                    => blk_2: {
+                        p.i += 1;
+                        break :blk_2 true;
+                    },
+                    else => false,
+                });
+                p.i = pos_1;
+                break :blk_1 !match_1;
+            }) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseCARETEQUAL(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defCARETEQUAL);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseskip() and blk_1: {
+                if (std.mem.startsWith(u8, p.source[p.i..], "^=")) {
+                    p.i += 2;
+                    break :blk_1 true;
+                }
+                break :blk_1 false;
+            }) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseCOLON(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defCOLON);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseskip() and blk_1: {
+                if (std.mem.startsWith(u8, p.source[p.i..], ":")) {
+                    p.i += 1;
+                    break :blk_1 true;
+                }
+                break :blk_1 false;
+            }) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseCOMMA(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defCOMMA);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseskip() and blk_1: {
+                if (std.mem.startsWith(u8, p.source[p.i..], ",")) {
+                    p.i += 1;
+                    break :blk_1 true;
+                }
+                break :blk_1 false;
+            }) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseDOT(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defDOT);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseskip() and blk_1: {
+                if (std.mem.startsWith(u8, p.source[p.i..], ".")) {
+                    p.i += 1;
+                    break :blk_1 true;
+                }
+                break :blk_1 false;
+            } and blk_1: {
+                const pos_1 = p.i;
+                const match_1 = (p.i < p.source.len and switch (p.source[p.i]) {
+                    '*'...'*',
+                    '.'...'.',
+                    => blk_2: {
+                        p.i += 1;
+                        break :blk_2 true;
+                    },
+                    else => false,
+                });
+                p.i = pos_1;
+                break :blk_1 !match_1;
+            }) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseDOT2(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defDOT2);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseskip() and blk_1: {
+                if (std.mem.startsWith(u8, p.source[p.i..], "..")) {
+                    p.i += 2;
+                    break :blk_1 true;
+                }
+                break :blk_1 false;
+            } and blk_1: {
+                const pos_1 = p.i;
+                const match_1 = (p.i < p.source.len and switch (p.source[p.i]) {
+                    '.'...'.',
+                    => blk_2: {
+                        p.i += 1;
+                        break :blk_2 true;
+                    },
+                    else => false,
+                });
+                p.i = pos_1;
+                break :blk_1 !match_1;
+            }) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseDOT3(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defDOT3);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseskip() and blk_1: {
+                if (std.mem.startsWith(u8, p.source[p.i..], "...")) {
+                    p.i += 3;
+                    break :blk_1 true;
+                }
+                break :blk_1 false;
+            }) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseDOTASTERISK(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defDOTASTERISK);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseskip() and blk_1: {
+                if (std.mem.startsWith(u8, p.source[p.i..], ".*")) {
+                    p.i += 2;
+                    break :blk_1 true;
+                }
+                break :blk_1 false;
+            }) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseEQUAL(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defEQUAL);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseskip() and blk_1: {
+                if (std.mem.startsWith(u8, p.source[p.i..], "=")) {
+                    p.i += 1;
+                    break :blk_1 true;
+                }
+                break :blk_1 false;
+            } and blk_1: {
+                const pos_1 = p.i;
+                const match_1 = (p.i < p.source.len and switch (p.source[p.i]) {
+                    '>'...'>',
+                    '='...'=',
+                    => blk_2: {
+                        p.i += 1;
+                        break :blk_2 true;
+                    },
+                    else => false,
+                });
+                p.i = pos_1;
+                break :blk_1 !match_1;
+            }) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseEQUALEQUAL(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defEQUALEQUAL);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseskip() and blk_1: {
+                if (std.mem.startsWith(u8, p.source[p.i..], "==")) {
+                    p.i += 2;
+                    break :blk_1 true;
+                }
+                break :blk_1 false;
+            }) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseEQUALRARROW(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defEQUALRARROW);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseskip() and blk_1: {
+                if (std.mem.startsWith(u8, p.source[p.i..], "=>")) {
+                    p.i += 2;
+                    break :blk_1 true;
+                }
+                break :blk_1 false;
+            }) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseEXCLAMATIONMARK(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defEXCLAMATIONMARK);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseskip() and blk_1: {
+                if (std.mem.startsWith(u8, p.source[p.i..], "!")) {
+                    p.i += 1;
+                    break :blk_1 true;
+                }
+                break :blk_1 false;
+            } and blk_1: {
+                const pos_1 = p.i;
+                const match_1 = (p.i < p.source.len and switch (p.source[p.i]) {
+                    '='...'=',
+                    => blk_2: {
+                        p.i += 1;
+                        break :blk_2 true;
+                    },
+                    else => false,
+                });
+                p.i = pos_1;
+                break :blk_1 !match_1;
+            }) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseEXCLAMATIONMARKEQUAL(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defEXCLAMATIONMARKEQUAL);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseskip() and blk_1: {
+                if (std.mem.startsWith(u8, p.source[p.i..], "!=")) {
+                    p.i += 2;
+                    break :blk_1 true;
+                }
+                break :blk_1 false;
+            }) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseLARROW(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defLARROW);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseskip() and blk_1: {
+                if (std.mem.startsWith(u8, p.source[p.i..], "<")) {
+                    p.i += 1;
+                    break :blk_1 true;
+                }
+                break :blk_1 false;
+            } and blk_1: {
+                const pos_1 = p.i;
+                const match_1 = (p.i < p.source.len and switch (p.source[p.i]) {
+                    '<'...'<',
+                    '='...'=',
+                    => blk_2: {
+                        p.i += 1;
+                        break :blk_2 true;
+                    },
+                    else => false,
+                });
+                p.i = pos_1;
+                break :blk_1 !match_1;
+            }) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseLARROW2(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defLARROW2);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseskip() and blk_1: {
+                if (std.mem.startsWith(u8, p.source[p.i..], "<<")) {
+                    p.i += 2;
+                    break :blk_1 true;
+                }
+                break :blk_1 false;
+            } and blk_1: {
+                const pos_1 = p.i;
+                const match_1 = (p.i < p.source.len and switch (p.source[p.i]) {
+                    '='...'=',
+                    '|'...'|',
+                    => blk_2: {
+                        p.i += 1;
+                        break :blk_2 true;
+                    },
+                    else => false,
+                });
+                p.i = pos_1;
+                break :blk_1 !match_1;
+            }) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseLARROW2EQUAL(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defLARROW2EQUAL);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseskip() and blk_1: {
+                if (std.mem.startsWith(u8, p.source[p.i..], "<<=")) {
+                    p.i += 3;
+                    break :blk_1 true;
+                }
+                break :blk_1 false;
+            }) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseLARROW2PIPE(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defLARROW2PIPE);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseskip() and blk_1: {
+                if (std.mem.startsWith(u8, p.source[p.i..], "<<|")) {
+                    p.i += 3;
+                    break :blk_1 true;
+                }
+                break :blk_1 false;
+            } and blk_1: {
+                const pos_1 = p.i;
+                const match_1 = (p.i < p.source.len and switch (p.source[p.i]) {
+                    '='...'=',
+                    => blk_2: {
+                        p.i += 1;
+                        break :blk_2 true;
+                    },
+                    else => false,
+                });
+                p.i = pos_1;
+                break :blk_1 !match_1;
+            }) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseLARROW2PIPEEQUAL(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defLARROW2PIPEEQUAL);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseskip() and blk_1: {
+                if (std.mem.startsWith(u8, p.source[p.i..], "<<|=")) {
+                    p.i += 4;
+                    break :blk_1 true;
+                }
+                break :blk_1 false;
+            }) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseLARROWEQUAL(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defLARROWEQUAL);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseskip() and blk_1: {
+                if (std.mem.startsWith(u8, p.source[p.i..], "<=")) {
+                    p.i += 2;
+                    break :blk_1 true;
+                }
+                break :blk_1 false;
+            }) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseLBRACE(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defLBRACE);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseskip() and blk_1: {
+                if (std.mem.startsWith(u8, p.source[p.i..], "{")) {
+                    p.i += 1;
+                    break :blk_1 true;
+                }
+                break :blk_1 false;
+            }) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseLBRACKET(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defLBRACKET);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseskip() and blk_1: {
+                if (std.mem.startsWith(u8, p.source[p.i..], "[")) {
+                    p.i += 1;
+                    break :blk_1 true;
+                }
+                break :blk_1 false;
+            }) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseLPAREN(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defLPAREN);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseskip() and blk_1: {
+                if (std.mem.startsWith(u8, p.source[p.i..], "(")) {
+                    p.i += 1;
+                    break :blk_1 true;
+                }
+                break :blk_1 false;
+            }) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseMINUS(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defMINUS);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseskip() and blk_1: {
+                if (std.mem.startsWith(u8, p.source[p.i..], "-")) {
+                    p.i += 1;
+                    break :blk_1 true;
+                }
+                break :blk_1 false;
+            } and blk_1: {
+                const pos_1 = p.i;
+                const match_1 = (p.i < p.source.len and switch (p.source[p.i]) {
+                    '%'...'%',
+                    '='...'=',
+                    '>'...'>',
+                    '|'...'|',
+                    => blk_2: {
+                        p.i += 1;
+                        break :blk_2 true;
+                    },
+                    else => false,
+                });
+                p.i = pos_1;
+                break :blk_1 !match_1;
+            }) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseMINUSEQUAL(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defMINUSEQUAL);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseskip() and blk_1: {
+                if (std.mem.startsWith(u8, p.source[p.i..], "-=")) {
+                    p.i += 2;
+                    break :blk_1 true;
+                }
+                break :blk_1 false;
+            }) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseMINUSPERCENT(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defMINUSPERCENT);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseskip() and blk_1: {
+                if (std.mem.startsWith(u8, p.source[p.i..], "-%")) {
+                    p.i += 2;
+                    break :blk_1 true;
+                }
+                break :blk_1 false;
+            } and blk_1: {
+                const pos_1 = p.i;
+                const match_1 = (p.i < p.source.len and switch (p.source[p.i]) {
+                    '='...'=',
+                    => blk_2: {
+                        p.i += 1;
+                        break :blk_2 true;
+                    },
+                    else => false,
+                });
+                p.i = pos_1;
+                break :blk_1 !match_1;
+            }) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseMINUSPERCENTEQUAL(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defMINUSPERCENTEQUAL);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseskip() and blk_1: {
+                if (std.mem.startsWith(u8, p.source[p.i..], "-%=")) {
+                    p.i += 3;
+                    break :blk_1 true;
+                }
+                break :blk_1 false;
+            }) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseMINUSPIPE(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defMINUSPIPE);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseskip() and blk_1: {
+                if (std.mem.startsWith(u8, p.source[p.i..], "-|")) {
+                    p.i += 2;
+                    break :blk_1 true;
+                }
+                break :blk_1 false;
+            } and blk_1: {
+                const pos_1 = p.i;
+                const match_1 = (p.i < p.source.len and switch (p.source[p.i]) {
+                    '='...'=',
+                    => blk_2: {
+                        p.i += 1;
+                        break :blk_2 true;
+                    },
+                    else => false,
+                });
+                p.i = pos_1;
+                break :blk_1 !match_1;
+            }) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseMINUSPIPEEQUAL(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defMINUSPIPEEQUAL);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseskip() and blk_1: {
+                if (std.mem.startsWith(u8, p.source[p.i..], "-|=")) {
+                    p.i += 3;
+                    break :blk_1 true;
+                }
+                break :blk_1 false;
+            }) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseMINUSRARROW(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defMINUSRARROW);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseskip() and blk_1: {
+                if (std.mem.startsWith(u8, p.source[p.i..], "->")) {
+                    p.i += 2;
+                    break :blk_1 true;
+                }
+                break :blk_1 false;
+            }) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parsePERCENT(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defPERCENT);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseskip() and blk_1: {
+                if (std.mem.startsWith(u8, p.source[p.i..], "%")) {
+                    p.i += 1;
+                    break :blk_1 true;
+                }
+                break :blk_1 false;
+            } and blk_1: {
+                const pos_1 = p.i;
+                const match_1 = (p.i < p.source.len and switch (p.source[p.i]) {
+                    '='...'=',
+                    => blk_2: {
+                        p.i += 1;
+                        break :blk_2 true;
+                    },
+                    else => false,
+                });
+                p.i = pos_1;
+                break :blk_1 !match_1;
+            }) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parsePERCENTEQUAL(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defPERCENTEQUAL);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseskip() and blk_1: {
+                if (std.mem.startsWith(u8, p.source[p.i..], "%=")) {
+                    p.i += 2;
+                    break :blk_1 true;
+                }
+                break :blk_1 false;
+            }) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parsePIPE(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defPIPE);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseskip() and blk_1: {
+                if (std.mem.startsWith(u8, p.source[p.i..], "|")) {
+                    p.i += 1;
+                    break :blk_1 true;
+                }
+                break :blk_1 false;
+            } and blk_1: {
+                const pos_1 = p.i;
+                const match_1 = (p.i < p.source.len and switch (p.source[p.i]) {
+                    '|'...'|',
+                    '='...'=',
+                    => blk_2: {
+                        p.i += 1;
+                        break :blk_2 true;
+                    },
+                    else => false,
+                });
+                p.i = pos_1;
+                break :blk_1 !match_1;
+            }) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parsePIPE2(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defPIPE2);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseskip() and blk_1: {
+                if (std.mem.startsWith(u8, p.source[p.i..], "||")) {
+                    p.i += 2;
+                    break :blk_1 true;
+                }
+                break :blk_1 false;
+            }) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parsePIPEEQUAL(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defPIPEEQUAL);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseskip() and blk_1: {
+                if (std.mem.startsWith(u8, p.source[p.i..], "|=")) {
+                    p.i += 2;
+                    break :blk_1 true;
+                }
+                break :blk_1 false;
+            }) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parsePLUS(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defPLUS);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseskip() and blk_1: {
+                if (std.mem.startsWith(u8, p.source[p.i..], "+")) {
+                    p.i += 1;
+                    break :blk_1 true;
+                }
+                break :blk_1 false;
+            } and blk_1: {
+                const pos_1 = p.i;
+                const match_1 = (p.i < p.source.len and switch (p.source[p.i]) {
+                    '%'...'%',
+                    '+'...'+',
+                    '='...'=',
+                    '|'...'|',
+                    => blk_2: {
+                        p.i += 1;
+                        break :blk_2 true;
+                    },
+                    else => false,
+                });
+                p.i = pos_1;
+                break :blk_1 !match_1;
+            }) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parsePLUS2(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defPLUS2);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseskip() and blk_1: {
+                if (std.mem.startsWith(u8, p.source[p.i..], "++")) {
+                    p.i += 2;
+                    break :blk_1 true;
+                }
+                break :blk_1 false;
+            }) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parsePLUSEQUAL(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defPLUSEQUAL);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseskip() and blk_1: {
+                if (std.mem.startsWith(u8, p.source[p.i..], "+=")) {
+                    p.i += 2;
+                    break :blk_1 true;
+                }
+                break :blk_1 false;
+            }) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parsePLUSPERCENT(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defPLUSPERCENT);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseskip() and blk_1: {
+                if (std.mem.startsWith(u8, p.source[p.i..], "+%")) {
+                    p.i += 2;
+                    break :blk_1 true;
+                }
+                break :blk_1 false;
+            } and blk_1: {
+                const pos_1 = p.i;
+                const match_1 = (p.i < p.source.len and switch (p.source[p.i]) {
+                    '='...'=',
+                    => blk_2: {
+                        p.i += 1;
+                        break :blk_2 true;
+                    },
+                    else => false,
+                });
+                p.i = pos_1;
+                break :blk_1 !match_1;
+            }) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parsePLUSPERCENTEQUAL(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defPLUSPERCENTEQUAL);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseskip() and blk_1: {
+                if (std.mem.startsWith(u8, p.source[p.i..], "+%=")) {
+                    p.i += 3;
+                    break :blk_1 true;
+                }
+                break :blk_1 false;
+            }) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parsePLUSPIPE(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defPLUSPIPE);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseskip() and blk_1: {
+                if (std.mem.startsWith(u8, p.source[p.i..], "+|")) {
+                    p.i += 2;
+                    break :blk_1 true;
+                }
+                break :blk_1 false;
+            } and blk_1: {
+                const pos_1 = p.i;
+                const match_1 = (p.i < p.source.len and switch (p.source[p.i]) {
+                    '='...'=',
+                    => blk_2: {
+                        p.i += 1;
+                        break :blk_2 true;
+                    },
+                    else => false,
+                });
+                p.i = pos_1;
+                break :blk_1 !match_1;
+            }) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parsePLUSPIPEEQUAL(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defPLUSPIPEEQUAL);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseskip() and blk_1: {
+                if (std.mem.startsWith(u8, p.source[p.i..], "+|=")) {
+                    p.i += 3;
+                    break :blk_1 true;
+                }
+                break :blk_1 false;
+            }) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseLETTERC(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defLETTERC);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseskip() and blk_1: {
+                if (std.mem.startsWith(u8, p.source[p.i..], "c")) {
+                    p.i += 1;
+                    break :blk_1 true;
+                }
+                break :blk_1 false;
+            }) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseQUESTIONMARK(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defQUESTIONMARK);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseskip() and blk_1: {
+                if (std.mem.startsWith(u8, p.source[p.i..], "?")) {
+                    p.i += 1;
+                    break :blk_1 true;
+                }
+                break :blk_1 false;
+            }) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseRARROW(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defRARROW);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseskip() and blk_1: {
+                if (std.mem.startsWith(u8, p.source[p.i..], ">")) {
+                    p.i += 1;
+                    break :blk_1 true;
+                }
+                break :blk_1 false;
+            } and blk_1: {
+                const pos_1 = p.i;
+                const match_1 = (p.i < p.source.len and switch (p.source[p.i]) {
+                    '>'...'>',
+                    '='...'=',
+                    => blk_2: {
+                        p.i += 1;
+                        break :blk_2 true;
+                    },
+                    else => false,
+                });
+                p.i = pos_1;
+                break :blk_1 !match_1;
+            }) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseRARROW2(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defRARROW2);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseskip() and blk_1: {
+                if (std.mem.startsWith(u8, p.source[p.i..], ">>")) {
+                    p.i += 2;
+                    break :blk_1 true;
+                }
+                break :blk_1 false;
+            } and blk_1: {
+                const pos_1 = p.i;
+                const match_1 = (p.i < p.source.len and switch (p.source[p.i]) {
+                    '='...'=',
+                    => blk_2: {
+                        p.i += 1;
+                        break :blk_2 true;
+                    },
+                    else => false,
+                });
+                p.i = pos_1;
+                break :blk_1 !match_1;
+            }) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseRARROW2EQUAL(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defRARROW2EQUAL);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseskip() and blk_1: {
+                if (std.mem.startsWith(u8, p.source[p.i..], ">>=")) {
+                    p.i += 3;
+                    break :blk_1 true;
+                }
+                break :blk_1 false;
+            }) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseRARROWEQUAL(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defRARROWEQUAL);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseskip() and blk_1: {
+                if (std.mem.startsWith(u8, p.source[p.i..], ">=")) {
+                    p.i += 2;
+                    break :blk_1 true;
+                }
+                break :blk_1 false;
+            }) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseRBRACE(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defRBRACE);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseskip() and blk_1: {
+                if (std.mem.startsWith(u8, p.source[p.i..], "}")) {
+                    p.i += 1;
+                    break :blk_1 true;
+                }
+                break :blk_1 false;
+            }) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseRBRACKET(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defRBRACKET);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseskip() and blk_1: {
+                if (std.mem.startsWith(u8, p.source[p.i..], "]")) {
+                    p.i += 1;
+                    break :blk_1 true;
+                }
+                break :blk_1 false;
+            }) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseRPAREN(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defRPAREN);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseskip() and blk_1: {
+                if (std.mem.startsWith(u8, p.source[p.i..], ")")) {
+                    p.i += 1;
+                    break :blk_1 true;
+                }
+                break :blk_1 false;
+            }) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseSEMICOLON(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defSEMICOLON);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseskip() and blk_1: {
+                if (std.mem.startsWith(u8, p.source[p.i..], ";")) {
+                    p.i += 1;
+                    break :blk_1 true;
+                }
+                break :blk_1 false;
+            }) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseSLASH(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defSLASH);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseskip() and blk_1: {
+                if (std.mem.startsWith(u8, p.source[p.i..], "/")) {
+                    p.i += 1;
+                    break :blk_1 true;
+                }
+                break :blk_1 false;
+            } and blk_1: {
+                const pos_1 = p.i;
+                const match_1 = (p.i < p.source.len and switch (p.source[p.i]) {
+                    '='...'=',
+                    '/'...'/',
+                    => blk_2: {
+                        p.i += 1;
+                        break :blk_2 true;
+                    },
+                    else => false,
+                });
+                p.i = pos_1;
+                break :blk_1 !match_1;
+            }) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseSLASHEQUAL(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defSLASHEQUAL);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseskip() and blk_1: {
+                if (std.mem.startsWith(u8, p.source[p.i..], "/=")) {
+                    p.i += 2;
+                    break :blk_1 true;
+                }
+                break :blk_1 false;
+            }) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseTILDE(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defTILDE);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseskip() and blk_1: {
+                if (std.mem.startsWith(u8, p.source[p.i..], "~")) {
+                    p.i += 1;
+                    break :blk_1 true;
+                }
+                break :blk_1 false;
+            }) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseend_of_word(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defend_of_word);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (blk_1: {
+                const pos_1 = p.i;
+                const match_1 = (p.i < p.source.len and switch (p.source[p.i]) {
+                    'a'...'z',
+                    'A'...'Z',
+                    '0'...'9',
+                    '_'...'_',
+                    => blk_2: {
+                        p.i += 1;
+                        break :blk_2 true;
+                    },
+                    else => false,
+                });
+                p.i = pos_1;
+                break :blk_1 !match_1;
+            }) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseKEYWORD_addrspace(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defKEYWORD_addrspace);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseskip() and blk_1: {
+                if (std.mem.startsWith(u8, p.source[p.i..], "addrspace")) {
+                    p.i += 9;
+                    break :blk_1 true;
+                }
+                break :blk_1 false;
+            } and try p.parseend_of_word()) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseKEYWORD_align(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defKEYWORD_align);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseskip() and blk_1: {
+                if (std.mem.startsWith(u8, p.source[p.i..], "align")) {
+                    p.i += 5;
+                    break :blk_1 true;
+                }
+                break :blk_1 false;
+            } and try p.parseend_of_word()) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseKEYWORD_allowzero(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defKEYWORD_allowzero);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseskip() and blk_1: {
+                if (std.mem.startsWith(u8, p.source[p.i..], "allowzero")) {
+                    p.i += 9;
+                    break :blk_1 true;
+                }
+                break :blk_1 false;
+            } and try p.parseend_of_word()) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseKEYWORD_and(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defKEYWORD_and);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseskip() and blk_1: {
+                if (std.mem.startsWith(u8, p.source[p.i..], "and")) {
+                    p.i += 3;
+                    break :blk_1 true;
+                }
+                break :blk_1 false;
+            } and try p.parseend_of_word()) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseKEYWORD_anyframe(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defKEYWORD_anyframe);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseskip() and blk_1: {
+                if (std.mem.startsWith(u8, p.source[p.i..], "anyframe")) {
+                    p.i += 8;
+                    break :blk_1 true;
+                }
+                break :blk_1 false;
+            } and try p.parseend_of_word()) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseKEYWORD_anytype(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defKEYWORD_anytype);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseskip() and blk_1: {
+                if (std.mem.startsWith(u8, p.source[p.i..], "anytype")) {
+                    p.i += 7;
+                    break :blk_1 true;
+                }
+                break :blk_1 false;
+            } and try p.parseend_of_word()) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseKEYWORD_asm(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defKEYWORD_asm);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseskip() and blk_1: {
+                if (std.mem.startsWith(u8, p.source[p.i..], "asm")) {
+                    p.i += 3;
+                    break :blk_1 true;
+                }
+                break :blk_1 false;
+            } and try p.parseend_of_word()) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseKEYWORD_break(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defKEYWORD_break);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseskip() and blk_1: {
+                if (std.mem.startsWith(u8, p.source[p.i..], "break")) {
+                    p.i += 5;
+                    break :blk_1 true;
+                }
+                break :blk_1 false;
+            } and try p.parseend_of_word()) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseKEYWORD_callconv(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defKEYWORD_callconv);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseskip() and blk_1: {
+                if (std.mem.startsWith(u8, p.source[p.i..], "callconv")) {
+                    p.i += 8;
+                    break :blk_1 true;
+                }
+                break :blk_1 false;
+            } and try p.parseend_of_word()) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseKEYWORD_catch(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defKEYWORD_catch);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseskip() and blk_1: {
+                if (std.mem.startsWith(u8, p.source[p.i..], "catch")) {
+                    p.i += 5;
+                    break :blk_1 true;
+                }
+                break :blk_1 false;
+            } and try p.parseend_of_word()) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseKEYWORD_comptime(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defKEYWORD_comptime);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseskip() and blk_1: {
+                if (std.mem.startsWith(u8, p.source[p.i..], "comptime")) {
+                    p.i += 8;
+                    break :blk_1 true;
+                }
+                break :blk_1 false;
+            } and try p.parseend_of_word()) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseKEYWORD_const(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defKEYWORD_const);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseskip() and blk_1: {
+                if (std.mem.startsWith(u8, p.source[p.i..], "const")) {
+                    p.i += 5;
+                    break :blk_1 true;
+                }
+                break :blk_1 false;
+            } and try p.parseend_of_word()) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseKEYWORD_continue(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defKEYWORD_continue);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseskip() and blk_1: {
+                if (std.mem.startsWith(u8, p.source[p.i..], "continue")) {
+                    p.i += 8;
+                    break :blk_1 true;
+                }
+                break :blk_1 false;
+            } and try p.parseend_of_word()) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseKEYWORD_defer(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defKEYWORD_defer);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseskip() and blk_1: {
+                if (std.mem.startsWith(u8, p.source[p.i..], "defer")) {
+                    p.i += 5;
+                    break :blk_1 true;
+                }
+                break :blk_1 false;
+            } and try p.parseend_of_word()) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseKEYWORD_else(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defKEYWORD_else);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseskip() and blk_1: {
+                if (std.mem.startsWith(u8, p.source[p.i..], "else")) {
+                    p.i += 4;
+                    break :blk_1 true;
+                }
+                break :blk_1 false;
+            } and try p.parseend_of_word()) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseKEYWORD_enum(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defKEYWORD_enum);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseskip() and blk_1: {
+                if (std.mem.startsWith(u8, p.source[p.i..], "enum")) {
+                    p.i += 4;
+                    break :blk_1 true;
+                }
+                break :blk_1 false;
+            } and try p.parseend_of_word()) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseKEYWORD_errdefer(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defKEYWORD_errdefer);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseskip() and blk_1: {
+                if (std.mem.startsWith(u8, p.source[p.i..], "errdefer")) {
+                    p.i += 8;
+                    break :blk_1 true;
+                }
+                break :blk_1 false;
+            } and try p.parseend_of_word()) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseKEYWORD_error(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defKEYWORD_error);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseskip() and blk_1: {
+                if (std.mem.startsWith(u8, p.source[p.i..], "error")) {
+                    p.i += 5;
+                    break :blk_1 true;
+                }
+                break :blk_1 false;
+            } and try p.parseend_of_word()) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseKEYWORD_export(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defKEYWORD_export);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseskip() and blk_1: {
+                if (std.mem.startsWith(u8, p.source[p.i..], "export")) {
+                    p.i += 6;
+                    break :blk_1 true;
+                }
+                break :blk_1 false;
+            } and try p.parseend_of_word()) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseKEYWORD_extern(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defKEYWORD_extern);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseskip() and blk_1: {
+                if (std.mem.startsWith(u8, p.source[p.i..], "extern")) {
+                    p.i += 6;
+                    break :blk_1 true;
+                }
+                break :blk_1 false;
+            } and try p.parseend_of_word()) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseKEYWORD_fn(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defKEYWORD_fn);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseskip() and blk_1: {
+                if (std.mem.startsWith(u8, p.source[p.i..], "fn")) {
+                    p.i += 2;
+                    break :blk_1 true;
+                }
+                break :blk_1 false;
+            } and try p.parseend_of_word()) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseKEYWORD_for(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defKEYWORD_for);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseskip() and blk_1: {
+                if (std.mem.startsWith(u8, p.source[p.i..], "for")) {
+                    p.i += 3;
+                    break :blk_1 true;
+                }
+                break :blk_1 false;
+            } and try p.parseend_of_word()) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseKEYWORD_if(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defKEYWORD_if);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseskip() and blk_1: {
+                if (std.mem.startsWith(u8, p.source[p.i..], "if")) {
+                    p.i += 2;
+                    break :blk_1 true;
+                }
+                break :blk_1 false;
+            } and try p.parseend_of_word()) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseKEYWORD_inline(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defKEYWORD_inline);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseskip() and blk_1: {
+                if (std.mem.startsWith(u8, p.source[p.i..], "inline")) {
+                    p.i += 6;
+                    break :blk_1 true;
+                }
+                break :blk_1 false;
+            } and try p.parseend_of_word()) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseKEYWORD_noalias(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defKEYWORD_noalias);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseskip() and blk_1: {
+                if (std.mem.startsWith(u8, p.source[p.i..], "noalias")) {
+                    p.i += 7;
+                    break :blk_1 true;
+                }
+                break :blk_1 false;
+            } and try p.parseend_of_word()) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseKEYWORD_nosuspend(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defKEYWORD_nosuspend);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseskip() and blk_1: {
+                if (std.mem.startsWith(u8, p.source[p.i..], "nosuspend")) {
+                    p.i += 9;
+                    break :blk_1 true;
+                }
+                break :blk_1 false;
+            } and try p.parseend_of_word()) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseKEYWORD_noinline(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defKEYWORD_noinline);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseskip() and blk_1: {
+                if (std.mem.startsWith(u8, p.source[p.i..], "noinline")) {
+                    p.i += 8;
+                    break :blk_1 true;
+                }
+                break :blk_1 false;
+            } and try p.parseend_of_word()) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseKEYWORD_opaque(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defKEYWORD_opaque);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseskip() and blk_1: {
+                if (std.mem.startsWith(u8, p.source[p.i..], "opaque")) {
+                    p.i += 6;
+                    break :blk_1 true;
+                }
+                break :blk_1 false;
+            } and try p.parseend_of_word()) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseKEYWORD_or(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defKEYWORD_or);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseskip() and blk_1: {
+                if (std.mem.startsWith(u8, p.source[p.i..], "or")) {
+                    p.i += 2;
+                    break :blk_1 true;
+                }
+                break :blk_1 false;
+            } and try p.parseend_of_word()) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseKEYWORD_orelse(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defKEYWORD_orelse);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseskip() and blk_1: {
+                if (std.mem.startsWith(u8, p.source[p.i..], "orelse")) {
+                    p.i += 6;
+                    break :blk_1 true;
+                }
+                break :blk_1 false;
+            } and try p.parseend_of_word()) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseKEYWORD_packed(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defKEYWORD_packed);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseskip() and blk_1: {
+                if (std.mem.startsWith(u8, p.source[p.i..], "packed")) {
+                    p.i += 6;
+                    break :blk_1 true;
+                }
+                break :blk_1 false;
+            } and try p.parseend_of_word()) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseKEYWORD_pub(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defKEYWORD_pub);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseskip() and blk_1: {
+                if (std.mem.startsWith(u8, p.source[p.i..], "pub")) {
+                    p.i += 3;
+                    break :blk_1 true;
+                }
+                break :blk_1 false;
+            } and try p.parseend_of_word()) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseKEYWORD_resume(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defKEYWORD_resume);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseskip() and blk_1: {
+                if (std.mem.startsWith(u8, p.source[p.i..], "resume")) {
+                    p.i += 6;
+                    break :blk_1 true;
+                }
+                break :blk_1 false;
+            } and try p.parseend_of_word()) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseKEYWORD_return(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defKEYWORD_return);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseskip() and blk_1: {
+                if (std.mem.startsWith(u8, p.source[p.i..], "return")) {
+                    p.i += 6;
+                    break :blk_1 true;
+                }
+                break :blk_1 false;
+            } and try p.parseend_of_word()) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseKEYWORD_linksection(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defKEYWORD_linksection);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseskip() and blk_1: {
+                if (std.mem.startsWith(u8, p.source[p.i..], "linksection")) {
+                    p.i += 11;
+                    break :blk_1 true;
+                }
+                break :blk_1 false;
+            } and try p.parseend_of_word()) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseKEYWORD_struct(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defKEYWORD_struct);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseskip() and blk_1: {
+                if (std.mem.startsWith(u8, p.source[p.i..], "struct")) {
+                    p.i += 6;
+                    break :blk_1 true;
+                }
+                break :blk_1 false;
+            } and try p.parseend_of_word()) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseKEYWORD_suspend(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defKEYWORD_suspend);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseskip() and blk_1: {
+                if (std.mem.startsWith(u8, p.source[p.i..], "suspend")) {
+                    p.i += 7;
+                    break :blk_1 true;
+                }
+                break :blk_1 false;
+            } and try p.parseend_of_word()) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseKEYWORD_switch(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defKEYWORD_switch);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseskip() and blk_1: {
+                if (std.mem.startsWith(u8, p.source[p.i..], "switch")) {
+                    p.i += 6;
+                    break :blk_1 true;
+                }
+                break :blk_1 false;
+            } and try p.parseend_of_word()) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseKEYWORD_test(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defKEYWORD_test);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseskip() and blk_1: {
+                if (std.mem.startsWith(u8, p.source[p.i..], "test")) {
+                    p.i += 4;
+                    break :blk_1 true;
+                }
+                break :blk_1 false;
+            } and try p.parseend_of_word()) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseKEYWORD_threadlocal(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defKEYWORD_threadlocal);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseskip() and blk_1: {
+                if (std.mem.startsWith(u8, p.source[p.i..], "threadlocal")) {
+                    p.i += 11;
+                    break :blk_1 true;
+                }
+                break :blk_1 false;
+            } and try p.parseend_of_word()) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseKEYWORD_try(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defKEYWORD_try);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseskip() and blk_1: {
+                if (std.mem.startsWith(u8, p.source[p.i..], "try")) {
+                    p.i += 3;
+                    break :blk_1 true;
+                }
+                break :blk_1 false;
+            } and try p.parseend_of_word()) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseKEYWORD_union(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defKEYWORD_union);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseskip() and blk_1: {
+                if (std.mem.startsWith(u8, p.source[p.i..], "union")) {
+                    p.i += 5;
+                    break :blk_1 true;
+                }
+                break :blk_1 false;
+            } and try p.parseend_of_word()) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseKEYWORD_unreachable(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defKEYWORD_unreachable);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseskip() and blk_1: {
+                if (std.mem.startsWith(u8, p.source[p.i..], "unreachable")) {
+                    p.i += 11;
+                    break :blk_1 true;
+                }
+                break :blk_1 false;
+            } and try p.parseend_of_word()) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseKEYWORD_var(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defKEYWORD_var);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseskip() and blk_1: {
+                if (std.mem.startsWith(u8, p.source[p.i..], "var")) {
+                    p.i += 3;
+                    break :blk_1 true;
+                }
+                break :blk_1 false;
+            } and try p.parseend_of_word()) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseKEYWORD_volatile(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defKEYWORD_volatile);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseskip() and blk_1: {
+                if (std.mem.startsWith(u8, p.source[p.i..], "volatile")) {
+                    p.i += 8;
+                    break :blk_1 true;
+                }
+                break :blk_1 false;
+            } and try p.parseend_of_word()) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parseKEYWORD_while(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defKEYWORD_while);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseskip() and blk_1: {
+                if (std.mem.startsWith(u8, p.source[p.i..], "while")) {
+                    p.i += 5;
+                    break :blk_1 true;
+                }
+                break :blk_1 false;
+            } and try p.parseend_of_word()) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+    pub fn parsekeyword(p: *Parser) Error!bool {
+        const def_index = @intFromEnum(Def.defkeyword);
+        if (p.depths[def_index] > max_depth) return error.MaxDepth;
+        p.depths[def_index] += 1;
+        defer p.depths[def_index] -= 1;
+        return blk_0: {
+            const pos_0 = p.i;
+            if (try p.parseKEYWORD_addrspace()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseKEYWORD_align()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseKEYWORD_allowzero()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseKEYWORD_and()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseKEYWORD_anyframe()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseKEYWORD_anytype()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseKEYWORD_asm()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseKEYWORD_break()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseKEYWORD_callconv()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseKEYWORD_catch()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseKEYWORD_comptime()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseKEYWORD_const()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseKEYWORD_continue()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseKEYWORD_defer()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseKEYWORD_else()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseKEYWORD_enum()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseKEYWORD_errdefer()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseKEYWORD_error()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseKEYWORD_export()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseKEYWORD_extern()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseKEYWORD_fn()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseKEYWORD_for()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseKEYWORD_if()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseKEYWORD_inline()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseKEYWORD_noalias()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseKEYWORD_nosuspend()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseKEYWORD_noinline()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseKEYWORD_opaque()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseKEYWORD_or()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseKEYWORD_orelse()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseKEYWORD_packed()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseKEYWORD_pub()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseKEYWORD_resume()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseKEYWORD_return()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseKEYWORD_linksection()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseKEYWORD_struct()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseKEYWORD_suspend()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseKEYWORD_switch()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseKEYWORD_test()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseKEYWORD_threadlocal()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseKEYWORD_try()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseKEYWORD_union()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseKEYWORD_unreachable()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseKEYWORD_var()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseKEYWORD_volatile()) break :blk_0 true;
+            p.i = pos_0;
+            if (try p.parseKEYWORD_while()) break :blk_0 true;
+            p.i = pos_0;
+            break :blk_0 false;
+        };
+    }
+};
diff --git a/lib/std/zig/parser_test.zig b/lib/std/zig/parser_test.zig
index 4e839c0d998e9728d3747ab233112d6e888d91b0..cc4e1bca11d3b0f17fcb16564f364e060fff18d5 100644
--- a/lib/std/zig/parser_test.zig
+++ b/lib/std/zig/parser_test.zig
@@ -6976,6 +6976,7 @@ test "recovery: missing comma" {
     , &[_]Error{
         .expected_comma_after_switch_prong,
         .expected_comma_after_switch_prong,
+        .mismatched_binary_op_whitespace,
         .expected_expr,
     });
 }
@@ -6992,10 +6993,10 @@ test "recovery: non-associative operators" {
 
 test "recovery: extra qualifier" {
     try testError(
-        \\const a: *const const u8;
+        \\const a: *align(4) align(8) u8;
         \\test ""
     , &[_]Error{
-        .extra_const_qualifier,
+        .extra_align_qualifier,
         .expected_block,
     });
 }
@@ -7230,7 +7231,7 @@ test "ampersand" {
 test "Ast: pointer types with subexprs containing qualifiers" {
     var fixed_allocator = std.heap.FixedBufferAllocator.init(fixed_buffer_mem[0..]);
     const allocator = fixed_allocator.allocator();
-    var tree = try std.zig.Ast.parse(allocator, "**addrspace(*align(1)T)T", .zon);
+    var tree = try std.zig.Ast.parse(allocator, "**addrspace(*align(1)T)T", .zon, .{});
     defer tree.deinit(allocator);
 
     const regular_ptr_node = tree.nodeData(.root).node;
@@ -7252,7 +7253,7 @@ fn testParse(io: Io, source: [:0]const u8, allocator: Allocator, anything_change
     defer io.unlockStderr();
     const writer = &stderr.file_writer.interface;
 
-    var tree = try std.zig.Ast.parse(allocator, source, .zig);
+    var tree = try std.zig.Ast.parse(allocator, source, .zig, .{});
     defer tree.deinit(allocator);
 
     for (tree.errors) |parse_error| {
@@ -7312,7 +7313,7 @@ fn testCanonical(source: [:0]const u8) !void {
 const Error = std.zig.Ast.Error.Tag;
 
 fn testError(source: [:0]const u8, expected_errors: []const Error) !void {
-    var tree = try std.zig.Ast.parse(std.testing.allocator, source, .zig);
+    var tree = try std.zig.Ast.parse(std.testing.allocator, source, .zig, .{});
     defer tree.deinit(std.testing.allocator);
 
     std.testing.expectEqual(expected_errors.len, tree.errors.len) catch |err| {
@@ -7332,268 +7333,5 @@ fn fuzzTestOneParse(_: void, smith: *std.testing.Smith) !void {
     const mode = smith.value(std.zig.Ast.Mode);
     var tokens: std.zig.TokenSmith = .gen(smith);
     var fba: std.heap.FixedBufferAllocator = .init(&fixed_buffer_mem);
-    _ = std.zig.Ast.parseTokens(fba.allocator(), tokens.source(), tokens.list(), mode) catch return;
-}
-
-test "zig fmt: fuzz" {
-    try std.testing.fuzz({}, fuzzRender, .{});
-}
-
-fn isRewritable(source: []const u8, tokens: std.zig.Ast.TokenList.Slice) !bool {
-    @disableInstrumentation();
-
-    // Byte-order marker is stripped
-    var maybe_rewritable = std.mem.startsWith(u8, source, "\xEF\xBB\xBF");
-    // The above variable can not yet be replaced by returns since error.SkipZigTest still needs to
-    // be checked for.
-
-    for (0.., tokens.items(.tag), tokens.items(.start)) |i, tag, start| switch (tag) {
-        // Extra colons can be removed
-        .keyword_asm,
-        // Qualifiers can be reordered
-        // keyword_const is intentionally excluded since it is used in other contexts and
-        // having only one qualifier will never lead to reordering.
-        .keyword_addrspace,
-        .keyword_align,
-        .keyword_allowzero,
-        .keyword_callconv,
-        .keyword_linksection,
-        .keyword_volatile,
-        => maybe_rewritable = true,
-        .builtin,
-        // Pointer casts can be reordered
-        => for ([_][]const u8{
-            "ptrCast",
-            "alignCast",
-            "addrSpaceCast",
-            "constCast",
-            "volatileCast",
-        }) |id| {
-            if (std.mem.startsWith(u8, source[start + 1 ..], id)) {
-                maybe_rewritable = true;
-            }
-        },
-        // Quoted identifiers can be unquoted
-        .identifier => if (source[start] == '@') {
-            maybe_rewritable = true;
-        },
-        else => {},
-        // #23754
-        .container_doc_comment,
-        => if (std.mem.endsWith(Token.Tag, tokens.items(.tag)[0..i], &.{.l_brace})) {
-            return error.SkipZigTest; // Can cause I.B.
-        },
-        // #24507
-        .keyword_inline,
-        .keyword_for,
-        .keyword_while,
-        .l_brace,
-        => if (std.mem.endsWith(Token.Tag, tokens.items(.tag)[0..i], &.{ .identifier, .colon })) {
-            return error.SkipZigTest; // Can cause I.B. due to double rendering of zig fmt on/off
-        },
-    };
-
-    return maybe_rewritable;
-}
-
-/// Checks equivelence of non-whitespace characters.
-/// If there are commas in `source`, then it is checked they are also present
-/// in `rendered`. Extra commas in `rendered` are ignored.
-fn isRewritten(source: [:0]const u8, rendered: [:0]const u8) bool {
-    @disableInstrumentation();
-    var i: usize = 0;
-    for (source[0 .. source.len + 1]) |c| switch (c) {
-        ' ', '\r', '\t', '\n' => {},
-        else => while (true) {
-            defer i += 1;
-            switch (rendered[i]) {
-                ' ', '\n' => {},
-                ',' => if (c == ',') break,
-                else => |r| if (c != r) return false else break,
-            }
-        },
-    };
-    std.debug.assert(i >= rendered.len);
-    return false;
-}
-
-/// Checks that no line ends in whitespace
-fn checkBetweenTokens(src: []const u8, fmt_on: *bool) error{
-    TrailingLineWhitespace,
-    DoubleEmptyLine,
-}!void {
-    @disableInstrumentation();
-    var pos: usize = 0;
-    while (true) {
-        const nl_pos = std.mem.indexOfScalarPos(u8, src, pos, '\n');
-        var check_trailing = fmt_on.*;
-
-        const line = src[pos .. nl_pos orelse src.len];
-        if (std.mem.indexOfScalar(u8, line, '/')) |comment_start| {
-            const comment_content = line[comment_start..][2..];
-            const trimmed_comment = std.mem.trim(u8, comment_content, &std.ascii.whitespace);
-            if (std.mem.eql(u8, trimmed_comment, "zig fmt: off")) {
-                fmt_on.* = false;
-            } else if (std.mem.eql(u8, trimmed_comment, "zig fmt: on")) {
-                fmt_on.* = true;
-                check_trailing = true;
-            }
-        }
-
-        pos = nl_pos orelse break;
-        if (check_trailing and pos != 0) switch (src[pos - 1]) {
-            ' ', '\t', '\r' => return error.TrailingLineWhitespace,
-            '\n' => if (pos != 1 and src[pos - 2] == '\n') return error.DoubleEmptyLine,
-            else => {},
-        };
-        pos += 1;
-    }
-}
-
-/// Ignores extre `.comma` tokens in `rendered`
-fn reparseTokens(
-    fba: Allocator,
-    rendered: [:0]const u8,
-    expected_tags: [:.eof]const Token.Tag,
-) error{
-    OutOfMemory,
-    SameLineMultilineStringLiteral,
-    TrailingLineWhitespace,
-    DoubleEmptyLine,
-}!struct {
-    toks: std.zig.Ast.TokenList,
-    rewritten: bool,
-} {
-    @disableInstrumentation();
-    var rewritten = false;
-    var tokens: std.zig.Ast.TokenList = .{};
-    var last_token_end: usize = 0;
-    var fmt_on = true;
-
-    try tokens.ensureTotalCapacity(fba, expected_tags.len + 2); // 1 for EOF and 1 for maybe a comma
-    var tokenizer: std.zig.Tokenizer = .init(rendered);
-    var i: usize = 0;
-    while (true) {
-        const tok = tokenizer.next();
-        try tokens.append(fba, .{
-            .tag = tok.tag,
-            .start = @intCast(tok.loc.start),
-        });
-
-        const between = rendered[last_token_end..tok.loc.start];
-        last_token_end = tok.loc.end;
-        try checkBetweenTokens(between, &fmt_on);
-        if (tok.tag == .multiline_string_literal_line and fmt_on) blk: {
-            if (tokens.len == 1)
-                break :blk; // first token
-            if (std.mem.indexOfScalar(u8, between, '\n') == null)
-                return error.SameLineMultilineStringLiteral;
-        }
-        if (tok.tag == expected_tags[i]) {
-            if (tok.tag == .eof)
-                break;
-            i += 1;
-        } else if (tok.tag != .comma or !fmt_on) {
-            rewritten = true;
-        }
-    }
-    std.debug.assert(i == expected_tags.len);
-    try checkBetweenTokens(rendered[last_token_end..], &fmt_on);
-
-    return .{ .toks = tokens, .rewritten = rewritten };
-}
-
-fn fuzzRender(_: void, smith: *std.testing.Smith) !void {
-    @disableInstrumentation();
-
-    var ast_smith: std.zig.AstSmith = .init(smith);
-    try ast_smith.generateSource();
-    var fba_ctx = std.heap.FixedBufferAllocator.init(&fixed_buffer_mem);
-    var opt_rendered: ?[]const u8 = null;
-    fuzzRenderInner(&ast_smith, fba_ctx.allocator(), &opt_rendered) catch |e| switch (e) {
-        error.SkipZigTest, error.OutOfMemory, error.WriteFailed => return error.SkipZigTest,
-        else => |failure| {
-            ast_smith.logSource();
-            if (opt_rendered) |rendered| {
-                logRenderedSource(rendered);
-            }
-            return failure;
-        },
-    };
-}
-
-fn fuzzRenderInner(ast_smith: *std.zig.AstSmith, fba: Allocator, opt_rendered: *?[]const u8) !void {
-    @disableInstrumentation();
-
-    const source = ast_smith.source();
-    const src_rewritable = try isRewritable(source, ast_smith.tokens());
-    const src_tree = try std.zig.Ast.parseTokens(fba, source, ast_smith.tokens(), .zig);
-    std.debug.assert(src_tree.errors.len == 0);
-    for (src_tree.nodes.items(.tag)) |tag| switch (tag) {
-        // #24507 (`switch(x) { inline for (a) |a| a => {} }` to
-        //         `switch(x) { { inline for (a) |a| a => {} }` since
-        //         AST determines inline case token as one before the case expression's first)
-        .switch_case_inline, .switch_case_inline_one => return error.SkipZigTest,
-        else => {},
-    };
-
-    var rendered_w: std.Io.Writer.Allocating = .init(fba);
-    try rendered_w.ensureUnusedCapacity(source.len + source.len / 2);
-    try src_tree.render(fba, &rendered_w.writer, .{});
-    // `toOwnedSliceSentinel` is not used since it reallocates the entire
-    // list to save space which is useless for fixed buffer allocators.
-    try rendered_w.writer.writeByte(0);
-    const rendered = rendered_w.written()[0 .. rendered_w.written().len - 1 :0];
-    opt_rendered.* = rendered;
-
-    // First check that the non-whitespace characters match. This ensures that
-    // identifier names, numbers, comments, et cetera are preserved.
-    if (!src_rewritable and isRewritten(source, rendered))
-        return error.Rewritten;
-    // Next check that the tokens are the same since whitespace removal can change the tokens
-    const src_tags = ast_smith.tokens().items(.tag);
-    const rendered_toks = try reparseTokens(fba, rendered, src_tags[0 .. src_tags.len - 1 :.eof]);
-    if (!src_rewritable and rendered_toks.rewritten)
-        return error.Rewritten;
-
-    // Rerender the tree to check idempotency and that new commas
-    // and whitespace changes did not create an AST error.
-    const rendered_tree = try std.zig.Ast.parseTokens(fba, rendered, rendered_toks.toks.slice(), .zig);
-    if (rendered_tree.errors.len != 0)
-        return error.Rewritten;
-    var rerendered_w: std.Io.Writer.Allocating = .init(fba);
-    try rerendered_w.ensureUnusedCapacity(source.len);
-    try rendered_tree.render(fba, &rerendered_w.writer, .{});
-    try std.testing.expectEqualStrings(rendered, rerendered_w.written());
-}
-
-fn logRenderedSource(source: []const u8) void {
-    var buf: [256]u8 = undefined;
-    const ls = std.debug.lockStderr(&buf);
-    defer std.debug.unlockStderr();
-    logRenderedSourceInner(source, ls.terminal()) catch {};
-}
-
-fn logRenderedSourceInner(source: []const u8, t: std.Io.Terminal) std.Io.Writer.Error!void {
-    const w = t.writer;
-
-    t.setColor(.dim) catch {};
-    try w.writeAll("=== Rendered Source ===\n");
-    t.setColor(.reset) catch {};
-
-    for (0.., source) |i, c| switch (c) {
-        ' '...0x7e => try w.writeByte(c),
-        '\n' => {
-            if (i != 0 and source[i - 1] == ' ') {
-                try w.writeAll("⏎");
-            }
-            try w.writeByte('\n');
-        },
-        else => {
-            t.setColor(.cyan) catch {};
-            try w.print("\\x{x:0>2}", .{c});
-            t.setColor(.reset) catch {};
-        },
-    };
-    try w.writeAll("␃\n");
+    _ = std.zig.Ast.parseTokens(fba.allocator(), tokens.source(), tokens.list(), mode, .{ .recover = false }) catch return;
 }
diff --git a/lib/std/zig/perf_test.zig b/lib/std/zig/perf_test.zig
index da3dd42f15fc3feb4f2c2347119e32b145d4430d..e04fa562c3a31d6e423eb772326af54a6679f3a6 100644
--- a/lib/std/zig/perf_test.zig
+++ b/lib/std/zig/perf_test.zig
@@ -32,6 +32,6 @@ pub fn main() !void {
 fn testOnce() usize {
     var fixed_buf_alloc = std.heap.FixedBufferAllocator.init(&fixed_buffer_mem);
     const allocator = fixed_buf_alloc.allocator();
-    _ = std.zig.Ast.parse(allocator, source, .zig) catch @panic("parse failure");
+    _ = std.zig.Ast.parse(allocator, source, .zig, .{}) catch @panic("parse failure");
     return fixed_buf_alloc.end_index;
 }
diff --git a/lib/std/zon/parse.zig b/lib/std/zon/parse.zig
index 249dc9b644ce80553568bfd5dfb77291ec6bf60c..d074a2198e798e3e191a9788f0c53626ca8fa7a5 100644
--- a/lib/std/zon/parse.zig
+++ b/lib/std/zon/parse.zig
@@ -294,7 +294,7 @@ pub fn fromSliceAlloc(
 ) error{ OutOfMemory, ParseZon }!T {
     if (diag) |s| s.assertEmpty();
 
-    var ast = try std.zig.Ast.parse(gpa, source, .zon);
+    var ast = try std.zig.Ast.parse(gpa, source, .zon, .{});
     defer if (diag == null) ast.deinit(gpa);
     if (diag) |s| s.ast = ast;
 
@@ -2140,7 +2140,7 @@ test "std.zon string literal" {
     // Passing string literal to a array
     {
         {
-            var ast = try std.zig.Ast.parse(gpa, "\"abcd\"", .zon);
+            var ast = try std.zig.Ast.parse(gpa, "\"abcd\"", .zon, .{});
             defer ast.deinit(gpa);
             var zoir = try ZonGen.generate(gpa, ast, .{ .parse_str_lits = false });
             defer zoir.deinit(gpa);
@@ -3534,7 +3534,7 @@ test "std.zon no alloc" {
 
     const Nested = struct { u8, u8, struct { u8, u8 } };
 
-    var ast = try std.zig.Ast.parse(gpa, ".{ 1, 2, .{ 3, 4 } }", .zon);
+    var ast = try std.zig.Ast.parse(gpa, ".{ 1, 2, .{ 3, 4 } }", .zon, .{});
     defer ast.deinit(gpa);
 
     var zoir = try ZonGen.generate(gpa, ast, .{ .parse_str_lits = false });
diff --git a/src/Builtin.zig b/src/Builtin.zig
index 2117aae11b1ef834cfdb594dfc1f7ea2711e5406..05329d77a21709c96445f48e8bac0e123d24ac1b 100644
--- a/src/Builtin.zig
+++ b/src/Builtin.zig
@@ -296,7 +296,7 @@ pub fn populateFile(opts: @This(), gpa: Allocator, file: *File) Allocator.Error!
 
     log.debug("parsing and generating 'builtin.zig'", .{});
 
-    file.tree = try std.zig.Ast.parse(gpa, file.source.?, .zig);
+    file.tree = try std.zig.Ast.parse(gpa, file.source.?, .zig, .{});
     assert(file.tree.?.errors.len == 0); // builtin.zig must parse
 
     file.zir = try AstGen.generate(gpa, file.tree.?);
diff --git a/src/Zcu.zig b/src/Zcu.zig
index d36c96c07dab3f38df7abfff2a67003529a80201..b6d17eb624e01a416f78ab3677a74a23f77318a5 100644
--- a/src/Zcu.zig
+++ b/src/Zcu.zig
@@ -1145,7 +1145,7 @@ pub const File = struct {
         if (file.tree) |*tree| return tree;
 
         const source = try file.getSource(zcu);
-        file.tree = try .parse(zcu.gpa, source, file.getMode());
+        file.tree = try .parse(zcu.gpa, source, file.getMode(), .{});
         return &file.tree.?;
     }
 
diff --git a/src/Zcu/PerThread.zig b/src/Zcu/PerThread.zig
index c6c665655cf1ae7a792fabb44b5433efa6664bef..a1c5d400b0e6fcda22716196b6ca60ddb7c3ba45 100644
--- a/src/Zcu/PerThread.zig
+++ b/src/Zcu/PerThread.zig
@@ -642,7 +642,7 @@ pub fn updateFile(
 
         var timer = comp.startTimer();
         // Any potential AST errors are converted to ZIR errors when we run AstGen/ZonGen.
-        file.tree = try Ast.parse(gpa, source, file.getMode());
+        file.tree = try Ast.parse(gpa, source, file.getMode(), .{});
         if (timer.finish(io)) |ns_parse| {
             comp.mutex.lockUncancelable(io);
             defer comp.mutex.unlock(io);
diff --git a/src/fmt.zig b/src/fmt.zig
index 73d8a1c162328f720e9687d17cf7e2129b431da2..247f9fb7affea661954faf6da84de95eabc89188 100644
--- a/src/fmt.zig
+++ b/src/fmt.zig
@@ -117,7 +117,7 @@ pub fn run(gpa: Allocator, arena: Allocator, io: Io, args: []const []const u8) !
         };
         defer gpa.free(source_code);
 
-        var tree = std.zig.Ast.parse(gpa, source_code, if (force_zon) .zon else .zig) catch |err| {
+        var tree = std.zig.Ast.parse(gpa, source_code, if (force_zon) .zon else .zig, .{}) catch |err| {
             fatal("error parsing stdin: {}", .{err});
         };
         defer tree.deinit(gpa);
@@ -312,7 +312,7 @@ fn fmtPathFile(
         break :mode .zig;
     };
 
-    var tree = try std.zig.Ast.parse(gpa, source_code, mode);
+    var tree = try std.zig.Ast.parse(gpa, source_code, mode, .{});
     defer tree.deinit(gpa);
 
     if (tree.errors.len != 0) {
diff --git a/src/main.zig b/src/main.zig
index 91d1a8cee30b57880bfb3092ca05576dd71abe30..346445e664a66f50c9c959b2ba03b3060218e3dc 100644
--- a/src/main.zig
+++ b/src/main.zig
@@ -5528,7 +5528,7 @@ fn cmdAstCheck(arena: Allocator, io: Io, args: []const []const u8, environ_map:
         break :mode .zig;
     };
 
-    const tree = try Ast.parse(arena, source, mode);
+    const tree = try Ast.parse(arena, source, mode, .{});
 
     var stdout_writer = Io.File.stdout().writerStreaming(io, &stdout_buffer);
     const stdout_bw = &stdout_writer.interface;
@@ -5698,7 +5698,7 @@ fn cmdChangelist(arena: Allocator, io: Io, args: []const []const u8, environ_map
             fatal("unable to read new source file {q}: {t}", .{ new_source_path, err });
     };
 
-    const old_tree = try Ast.parse(arena, old_source, .zig);
+    const old_tree = try Ast.parse(arena, old_source, .zig, .{});
     const old_zir = try AstGen.generate(arena, old_tree);
 
     if (old_zir.loweringFailed()) {
@@ -5710,7 +5710,7 @@ fn cmdChangelist(arena: Allocator, io: Io, args: []const []const u8, environ_map
         process.exit(1);
     }
 
-    const new_tree = try Ast.parse(arena, new_source, .zig);
+    const new_tree = try Ast.parse(arena, new_source, .zig, .{});
     const new_zir = try AstGen.generate(arena, new_tree);
 
     if (new_zir.loweringFailed()) {
diff --git a/test/standalone/build.zig b/test/standalone/build.zig
index c5376b2e0df839ff498ad712c657b624611d34bd..dc8d85d399477256b65c60dc1b4850144c641738 100644
--- a/test/standalone/build.zig
+++ b/test/standalone/build.zig
@@ -36,6 +36,7 @@ pub fn build(b: *std.Build) void {
         "../../tools/fetch_them_macos_headers.zig",
         "../../tools/gen_macos_headers_c.zig",
         "../../tools/gen_outline_atomics.zig",
+        "../../tools/gen_parser_oracle.zig",
         "../../tools/gen_spirv_spec.zig",
         "../../tools/gen_stubs.zig",
         "../../tools/generate_c_size_and_align_checks.zig",
diff --git a/tools/docgen.zig b/tools/docgen.zig
index 8d4324a0d4301c2b8a401b49aa35e900637b83a2..9f182f350cc73069a44bfe7b2cc52ade250f228e 100644
--- a/tools/docgen.zig
+++ b/tools/docgen.zig
@@ -25,6 +25,7 @@ const usage =
     \\
     \\Options:
     \\   --code-dir dir         Path to directory containing code example outputs
+    \\   --grammar file         Path to the PEG grammar definition
     \\   -h, --help             Print this help and exit
     \\
 ;
@@ -37,6 +38,7 @@ pub fn main(init: std.process.Init) !void {
     if (!args_it.skip()) @panic("expected self arg");
 
     var opt_code_dir: ?[]const u8 = null;
+    var opt_grammar: ?[]const u8 = null;
     var opt_input: ?[]const u8 = null;
     var opt_output: ?[]const u8 = null;
 
@@ -51,6 +53,12 @@ pub fn main(init: std.process.Init) !void {
                 } else {
                     fatal("expected parameter after --code-dir", .{});
                 }
+            } else if (mem.eql(u8, arg, "--grammar")) {
+                if (args_it.next()) |param| {
+                    opt_grammar = param;
+                } else {
+                    fatal("expected parameter after --grammar", .{});
+                }
             } else {
                 fatal("unrecognized option: '{s}'", .{arg});
             }
@@ -65,6 +73,7 @@ pub fn main(init: std.process.Init) !void {
     const input_path = opt_input orelse fatal("missing input file", .{});
     const output_path = opt_output orelse fatal("missing output file", .{});
     const code_dir_path = opt_code_dir orelse fatal("missing --code-dir argument", .{});
+    const grammar_path = opt_grammar orelse fatal("missing --grammar argument", .{});
 
     var in_file = try Dir.cwd().openFile(io, input_path, .{});
     defer in_file.close(io);
@@ -82,13 +91,16 @@ pub fn main(init: std.process.Init) !void {
     };
     defer code_dir.root_dir.handle.close(io);
 
+    const grammar = try Dir.cwd().readFileAlloc(io, grammar_path, init.gpa, .limited(max_doc_file_size));
+    defer init.gpa.free(grammar);
+
     var in_file_reader = in_file.reader(io, &.{});
     const input_file_bytes = try in_file_reader.interface.allocRemaining(arena, .limited(max_doc_file_size));
 
     var tokenizer = Tokenizer.init(input_path, input_file_bytes);
     var toc = try genToc(arena, &tokenizer);
 
-    try genHtml(arena, io, &tokenizer, &toc, code_dir, &out_file_writer.interface);
+    try genHtml(arena, io, &tokenizer, &toc, code_dir, grammar, &out_file_writer.interface);
     try out_file_writer.end();
 }
 
@@ -326,6 +338,7 @@ const Node = union(enum) {
     HeaderOpen: HeaderOpen,
     SeeAlso: []const SeeAlsoItem,
     Code: Code,
+    Grammar,
     Link: Link,
     InlineSyntax: Token,
     Shell: Token,
@@ -513,6 +526,9 @@ fn genToc(gpa: Allocator, tokenizer: *Tokenizer) !Toc {
                             .token = name_tok,
                         },
                     });
+                } else if (mem.eql(u8, tag_name, "grammar")) {
+                    _ = try eatToken(tokenizer, .bracket_close);
+                    try nodes.append(.Grammar);
                 } else if (mem.eql(u8, tag_name, "syntax")) {
                     _ = try eatToken(tokenizer, .bracket_close);
                     const content_tok = try eatToken(tokenizer, .content);
@@ -924,14 +940,14 @@ fn tokenizeAndPrint(
     return tokenizeAndPrintRaw(allocator, docgen_tokenizer, out, source_token, raw_src);
 }
 
-fn printSourceBlock(allocator: Allocator, docgen_tokenizer: *Tokenizer, out: *Writer, syntax_block: SyntaxBlock) !void {
+fn printSourceBlock(allocator: Allocator, docgen_tokenizer: *Tokenizer, out: *Writer, syntax_block: SyntaxBlock, content: ?[]const u8) !void {
     const source_type = @tagName(syntax_block.source_type);
 
     try out.print("<figure><figcaption class=\"{s}-cap\"><cite class=\"file\">{s}</cite></figcaption><pre>", .{ source_type, syntax_block.name });
     switch (syntax_block.source_type) {
         .zig => try tokenizeAndPrint(allocator, docgen_tokenizer, out, syntax_block.source_token),
         else => {
-            const raw_source = docgen_tokenizer.buffer[syntax_block.source_token.start..syntax_block.source_token.end];
+            const raw_source = content orelse docgen_tokenizer.buffer[syntax_block.source_token.start..syntax_block.source_token.end];
             const trimmed_raw_source = mem.trim(u8, raw_source, " \r\n");
 
             try out.writeAll("<code>");
@@ -995,6 +1011,7 @@ fn genHtml(
     tokenizer: *Tokenizer,
     toc: *Toc,
     code_dir: Path,
+    grammar: []const u8,
     out: *Writer,
 ) !void {
     for (toc.nodes) |node| {
@@ -1042,7 +1059,7 @@ fn genHtml(
                 try printShell(out, raw_shell_content, true);
             },
             .SyntaxBlock => |syntax_block| {
-                try printSourceBlock(allocator, tokenizer, out, syntax_block);
+                try printSourceBlock(allocator, tokenizer, out, syntax_block, null);
             },
             .Code => |code| {
                 const out_basename = try std.fmt.allocPrint(allocator, "{s}.out", .{
@@ -1062,6 +1079,13 @@ fn genHtml(
 
                 try out.writeAll(contents);
             },
+            .Grammar => {
+                try printSourceBlock(allocator, tokenizer, out, .{
+                    .source_type = .peg,
+                    .name = "grammar.peg",
+                    .source_token = undefined,
+                }, grammar);
+            },
         }
     }
 }
diff --git a/tools/gen_parser_oracle.zig b/tools/gen_parser_oracle.zig
new file mode 100644
index 0000000000000000000000000000000000000000..fafed31eb9eeea1fa0cf69fe9a75374a7bd78b6d
--- /dev/null
+++ b/tools/gen_parser_oracle.zig
@@ -0,0 +1,789 @@
+//! Example usage:
+//! zig build gen-parser-oracle
+//! zig build check-parser-oracle
+
+// This program implements a subset of the PEG grammar definition
+// in the peg(1) man page.
+//
+// It generates a recursive descent parser that returns true if a given input is
+// matched by the grammar. This generated parser is used as an oracle for fuzz testing.
+
+const std = @import("std");
+const assert = std.debug.assert;
+const Io = std.Io;
+const mem = std.mem;
+const Allocator = mem.Allocator;
+const log = std.log;
+
+pub fn main(init: std.process.Init) !void {
+    const gpa = init.gpa;
+    const arena = init.arena.allocator();
+    const io = init.io;
+    const args = try init.minimal.args.toSlice(arena);
+
+    const grammar_path = args[1];
+    const out_path = args[2];
+    const check = args.len > 3 and mem.eql(u8, args[3], "--check");
+
+    const grammar = try Io.Dir.cwd().readFileAlloc(io, grammar_path, gpa, .unlimited);
+    defer gpa.free(grammar);
+
+    var parser: Parser = .init(gpa, grammar);
+    defer parser.deinit();
+
+    const root = try parser.parseGrammar() orelse {
+        log.err("Invalid grammar", .{});
+        return;
+    };
+
+    var buffer: Io.Writer.Allocating = .init(gpa);
+    defer buffer.deinit();
+
+    var g: Generator = .init(&buffer.writer, &parser);
+    try g.genRoot(root);
+
+    const generated = try buffer.toOwnedSliceSentinel(0);
+    defer gpa.free(generated);
+
+    // Parse the generated Zig code and render it in the canonical format
+    var tree = try std.zig.Ast.parse(gpa, generated, .zig, .{});
+    defer tree.deinit(gpa);
+
+    if (tree.errors.len != 0) {
+        // This should never be reached, but helps a lot when debugging this script.
+        try std.zig.printAstErrorsToStderr(gpa, io, tree, "generated", .auto);
+        return error.ParseError;
+    }
+
+    if (check) {
+        const current = try Io.Dir.cwd().readFileAlloc(io, out_path, gpa, .unlimited);
+        defer gpa.free(current);
+        var aw: Io.Writer.Allocating = .init(gpa);
+        defer aw.deinit();
+        try tree.render(gpa, &aw.writer, .{});
+        if (!mem.eql(u8, current, aw.written())) {
+            std.log.err("grammar.peg modified without regenerating oracle", .{});
+            std.log.info("Run zig build gen-parser-oracle to regenerate", .{});
+            std.process.exit(1);
+        }
+    } else {
+        var out_file = try Io.Dir.cwd().createFile(io, out_path, .{});
+        defer out_file.close(io);
+        var out_buffer: [4096]u8 = undefined;
+        var out_writer = out_file.writer(io, &out_buffer);
+        const out = &out_writer.interface;
+
+        try tree.render(gpa, out, .{});
+        try out.flush();
+    }
+}
+
+const Generator = struct {
+    w: *Io.Writer,
+    p: *const Parser,
+    /// Suffix for generated identifiers, incremented for each nested scope to avoid shadowing,
+    /// Decremented at end of each generated scope to give smaller git diffs when regenerating
+    /// lib/std/zig/parser_generated_oracle.zig.
+    suffix: usize,
+
+    fn init(w: *Io.Writer, p: *const Parser) Generator {
+        return .{ .w = w, .p = p, .suffix = 0 };
+    }
+
+    const Error = Io.Writer.Error;
+    const Node = Parser.Node;
+
+    fn genRoot(g: *Generator, node: Node.Index) Error!void {
+        try g.w.writeAll(
+            \\//! This file is generated, do not edit manually! To generate, run:
+            \\//! zig build gen-parser-oracle
+            \\
+            \\const std = @import("std");
+            \\
+            \\const Error = error{MaxDepth};
+            \\const max_depth = 5;
+            \\
+            \\/// Returns true if the input source is in the language defined by
+            \\/// the grammar.
+            \\/// Returns error.MaxDepth if more than `max_depth` levels of recursion/iteration are reached.
+            \\pub fn parse(source: []const u8) Error!bool {
+            \\    var p: Parser = .{ .source = source, .i = 0, .depths = @splat(1) };
+            \\    return p.parseRoot();
+            \\}
+        );
+
+        const defs = g.p.getExtra(node.get(g.p).root);
+
+        // This enum exists to minimize git diffs in the generated oracle when
+        // the grammar is modified. It allows mapping from def name (stable) to
+        // def index (unstable).
+        try g.w.writeAll("const Def = enum {");
+        for (defs) |n| {
+            const def = n.get(g.p).def;
+            const id = def.id.get(g.p).id;
+            try g.w.print("def{s},", .{id});
+        }
+        try g.w.writeAll("};");
+
+        try g.w.print(
+            \\const Parser = struct {{
+            \\    source: []const u8,
+            \\    i: usize,
+            \\    depths: [{d}]u8,
+        , .{defs.len});
+        for (defs) |def| {
+            try g.genDef(def);
+        }
+        try g.w.writeAll("};");
+    }
+
+    fn genDef(g: *Generator, node: Node.Index) Error!void {
+        const def = node.get(g.p).def;
+        const id = def.id.get(g.p).id;
+        assert(g.suffix == 0);
+        try g.w.print("pub fn parse{s}(p: *Parser) Error!bool {{", .{id});
+        try g.w.print(
+            \\const def_index = @intFromEnum(Def.def{s});
+            \\if (p.depths[def_index] > max_depth) return error.MaxDepth;
+            \\p.depths[def_index] += 1;
+            \\defer p.depths[def_index] -= 1;
+        , .{id});
+        try g.w.writeAll("return ");
+        try g.genExpr(def.expr);
+        try g.w.writeAll(";}");
+    }
+
+    fn genExpr(g: *Generator, node: Node.Index) Error!void {
+        const suffix = g.suffix;
+        g.suffix += 1;
+        defer g.suffix -= 1;
+        try g.w.print(
+            \\blk_{d}: {{
+            \\const pos_{d} = p.i;
+        , .{ suffix, suffix });
+        for (g.p.getExtra(node.get(g.p).expr)) |seq| {
+            try g.w.writeAll("if (");
+            try g.genSeq(seq);
+            try g.w.print(") break :blk_{d} true;", .{suffix});
+            try g.w.print("p.i = pos_{d};", .{suffix});
+        }
+        try g.w.print("break :blk_{d} false; }}", .{suffix});
+    }
+
+    fn genSeq(g: *Generator, node: Node.Index) Error!void {
+        const items = g.p.getExtra(node.get(g.p).seq);
+        for (items, 0..) |item, i| {
+            if (i > 0) try g.w.writeAll(" and ");
+            try g.genNode(item);
+        }
+    }
+
+    fn genNode(g: *Generator, node: Node.Index) Error!void {
+        const suffix = g.suffix;
+        g.suffix += 1;
+        defer g.suffix -= 1;
+        switch (node.get(g.p)) {
+            .id => |id| try g.w.print("try p.parse{s}()", .{id}),
+            .expr => try g.genExpr(node),
+            .@"&" => |child| {
+                // XXX forbid unbounded lookahead
+                try g.w.print(
+                    \\blk_{d}: {{
+                    \\const pos_{d} = p.i;
+                    \\const match_{d} = 
+                , .{ suffix, suffix, suffix });
+                try g.genNode(child);
+                try g.w.print(
+                    \\;
+                    \\p.i = pos_{d};
+                    \\    break :blk_{d} match_{d};
+                    \\}}
+                , .{ suffix, suffix, suffix });
+            },
+            .@"!" => |child| {
+                // XXX forbid unbounded lookahead
+                try g.w.print(
+                    \\blk_{d}: {{
+                    \\const pos_{d} = p.i;
+                    \\const match_{d} = 
+                , .{ suffix, suffix, suffix });
+                try g.genNode(child);
+                try g.w.print(
+                    \\;
+                    \\p.i = pos_{d};
+                    \\    break :blk_{d} !match_{d};
+                    \\}}
+                , .{ suffix, suffix, suffix });
+            },
+            .@"?" => |child| {
+                try g.w.writeAll("(");
+                try g.genNode(child);
+                try g.w.writeAll(" or true )");
+            },
+            .@"*" => |child| {
+                try g.w.print(
+                    \\blk_{d}: {{
+                    \\var i_{d}: usize = 0;
+                    \\while (
+                , .{ suffix, suffix });
+                try g.genNode(child);
+                try g.w.print(
+                    \\) {{
+                    \\  if (i_{d} > max_depth) return error.MaxDepth;
+                    \\  i_{d} += 1;
+                    \\}}
+                    \\break :blk_{d} true; }}
+                , .{ suffix, suffix, suffix });
+            },
+            .@"+" => |child| {
+                try g.w.print(
+                    \\blk_{d}: {{
+                    \\var match_{d} = false;
+                    \\var i_{d}: usize = 0;
+                    \\while (
+                , .{ suffix, suffix, suffix });
+                try g.genNode(child);
+                try g.w.print(
+                    \\) {{
+                    \\  match_{d} = true;
+                    \\  if (i_{d} > max_depth) return error.MaxDepth;
+                    \\  i_{d} += 1;
+                    \\}}
+                    \\break :blk_{d} match_{d}; }}
+                , .{ suffix, suffix, suffix, suffix, suffix });
+            },
+            .@"." => {
+                try g.w.print(
+                    \\blk_{d}: {{
+                    \\    if (p.i < p.source.len) {{
+                    \\        p.i += 1;
+                    \\        break :blk_{d} true;
+                    \\    }}
+                    \\    break :blk_{d} false;
+                    \\}}
+                , .{ suffix, suffix, suffix });
+            },
+            .literal => |literal| {
+                const bytes = g.p.strings.items[literal.off..][0..literal.len];
+                try g.w.print(
+                    \\blk_{d}: {{
+                    \\if (std.mem.startsWith(u8, p.source[p.i..], "
+                , .{suffix});
+                try std.zig.stringEscape(bytes, g.w);
+                try g.w.print(
+                    \\")) {{
+                    \\p.i += {d};
+                    \\    break :blk_{d} true;
+                    \\}}
+                    \\break :blk_{d} false;
+                    \\}}
+                , .{ bytes.len, suffix, suffix });
+            },
+            .class => |ranges| {
+                try g.w.writeAll("(p.i < p.source.len and switch (p.source[p.i]) {");
+                for (g.p.getExtra(ranges)) |n| {
+                    const range = n.get(g.p).range;
+                    try g.w.writeAll("'");
+                    try std.zig.charEscape(range.start, g.w);
+                    try g.w.writeAll("'...'");
+                    try std.zig.charEscape(range.end, g.w);
+                    try g.w.writeAll("',");
+                }
+                try g.w.print(
+                    \\=> blk_{d}: {{ p.i += 1; break :blk_{d} true; }},
+                    \\else => false,
+                    \\}})
+                , .{ suffix, suffix });
+            },
+            .sof => try g.w.writeAll("(p.i == 0)"),
+            else => unreachable,
+        }
+    }
+};
+
+/// Parser implements a subset of the PEG grammar definition.
+/// We don't bother implementing the Action, BEGIN, and END rules
+/// and also omit unneeded character escape sequences.
+///
+/// The full PEG grammar found in the peg(1) man page:
+///
+/// Grammar         <- Spacing Definition+ EndOfFile
+///
+/// Definition      <- Identifier LEFTARROW Expression
+/// Expression      <- Sequence ( SLASH Sequence )*
+/// Sequence        <- Prefix*
+/// Prefix          <- AND Action
+///                  / ( AND / NOT )? Suffix
+/// Suffix          <- Primary ( QUERY / STAR / PLUS )?
+/// Primary         <- Identifier !LEFTARROW
+///                  / OPEN Expression CLOSE
+///                  / Literal
+///                  / Class
+///                  / DOT
+///                  / Action
+///                  / BEGIN
+///                  / END
+///
+/// Identifier      <- < IdentStart IdentCont* > Spacing
+/// IdentStart      <- [a-zA-Z_]
+/// IdentCont       <- IdentStart / [0-9]
+/// Literal         <- ['] < ( !['] Char  )* > ['] Spacing
+///                  / ["] < ( !["] Char  )* > ["] Spacing
+/// Class           <- '[' < ( !']' Range )* > ']' Spacing
+/// Range           <- Char '-' Char / Char
+/// Char            <- '\\' [abefnrtv'"\[\]\\]
+///                  / '\\' [0-3][0-7][0-7]
+///                  / '\\' [0-7][0-7]?
+///                  / '\\' '-'
+///                  / !'\\' .
+/// LEFTARROW       <- '<-' Spacing
+/// SLASH           <- '/' Spacing
+/// AND             <- '&' Spacing
+/// NOT             <- '!' Spacing
+/// QUERY           <- '?' Spacing
+/// STAR            <- '*' Spacing
+/// PLUS            <- '+' Spacing
+/// OPEN            <- '(' Spacing
+/// CLOSE           <- ')' Spacing
+/// DOT             <- '.' Spacing
+/// Spacing         <- ( Space / Comment )*
+/// Comment         <- '#' ( !EndOfLine . )* EndOfLine
+/// Space           <- ' ' / '\t' / EndOfLine
+/// EndOfLine       <- '\r\n' / '\n' / '\r'
+/// EndOfFile       <- !.
+/// Action          <- '{' < [^}]* > '}' Spacing
+/// BEGIN           <- '<' Spacing
+/// END             <- '>' Spacing
+const Parser = struct {
+    gpa: Allocator,
+    /// PEG grammar source
+    source: []const u8,
+    /// Current index into source
+    i: u32,
+    nodes: std.ArrayList(Node),
+    extra: std.ArrayList(Node.Index),
+    strings: std.ArrayList(u8),
+
+    const Node = union(enum) {
+        /// Slice into extra
+        root: Slice,
+        def: struct {
+            id: Index,
+            expr: Index,
+        },
+        /// Slice into Parser.source
+        id: []const u8,
+        /// Slice into extra
+        expr: Slice,
+        /// Slice into extra
+        seq: Slice,
+        @"&": Index,
+        @"!": Index,
+        @"?": Index,
+        @"*": Index,
+        @"+": Index,
+        @".",
+        /// Slice into strings
+        literal: Slice,
+        /// Slice into extra
+        class: Slice,
+        range: struct {
+            start: u8,
+            end: u8,
+        },
+        /// Start of file
+        sof,
+
+        const Index = enum(u32) {
+            _,
+
+            fn get(index: Index, p: *const Parser) Node {
+                return p.nodes.items[@intFromEnum(index)];
+            }
+        };
+
+        const Slice = struct {
+            off: u32,
+            len: u32,
+        };
+    };
+
+    fn init(gpa: Allocator, source: []const u8) Parser {
+        return .{
+            .gpa = gpa,
+            .source = source,
+            .i = 0,
+            .nodes = .empty,
+            .extra = .empty,
+            .strings = .empty,
+        };
+    }
+
+    fn deinit(p: *Parser) void {
+        p.nodes.deinit(p.gpa);
+        p.extra.deinit(p.gpa);
+        p.strings.deinit(p.gpa);
+    }
+
+    // Grammar         <- Spacing Definition+ EndOfFile
+    // EndOfFile       <- !.
+    fn parseGrammar(p: *Parser) !?Node.Index {
+        var scratch: std.ArrayList(Node.Index) = .empty;
+        defer scratch.deinit(p.gpa);
+        _ = p.eatSpacing();
+        while (try p.parseDefinition()) |def| {
+            try scratch.append(p.gpa, def);
+        }
+        if (scratch.items.len == 0) return null;
+        if (p.peek() != null) return null;
+        const defs = try p.addExtra(scratch.items);
+        return try p.addNode(.{ .root = defs });
+    }
+
+    // Definition      <- Identifier LEFTARROW Expression
+    fn parseDefinition(p: *Parser) !?Node.Index {
+        const id = try p.parseIdentifier() orelse return null;
+        if (!p.eatLeftArrow()) return null;
+        const expr = try p.parseExpression() orelse return null;
+        return try p.addNode(.{ .def = .{
+            .id = id,
+            .expr = expr,
+        } });
+    }
+
+    // Expression      <- Sequence ( SLASH Sequence )*
+    fn parseExpression(p: *Parser) error{OutOfMemory}!?Node.Index {
+        var scratch: std.ArrayList(Node.Index) = .empty;
+        defer scratch.deinit(p.gpa);
+        while (try p.parseSequence()) |seq| {
+            try scratch.append(p.gpa, seq);
+            if (!p.eatSlash()) break;
+        }
+        if (scratch.items.len == 0) return null;
+        const seqs = try p.addExtra(scratch.items);
+        return try p.addNode(.{ .expr = seqs });
+    }
+
+    // Sequence        <- Prefix*
+    fn parseSequence(p: *Parser) !?Node.Index {
+        var scratch: std.ArrayList(Node.Index) = .empty;
+        defer scratch.deinit(p.gpa);
+        while (try p.parsePrefix()) |primary| {
+            try scratch.append(p.gpa, primary);
+        }
+        const primaries = try p.addExtra(scratch.items);
+        return try p.addNode(.{ .seq = primaries });
+    }
+
+    // Prefix          <- AND Action
+    //                  / ( AND / NOT )? Suffix
+    fn parsePrefix(p: *Parser) !?Node.Index {
+        if (p.eatAnd()) {
+            // We only support a single hardcoded "start of file" Action
+            if (p.eat('{')) {
+                // Action          <- '{' < [^}]* > '}' Spacing
+                if (std.mem.startsWith(u8, p.source[p.i..], " (yy->__pos == 0) }")) {
+                    while (!p.eat('}')) p.i += 1;
+                    _ = p.eatSpacing();
+                    return try p.addNode(.sof);
+                }
+                return null;
+            }
+            const suffix = try p.parseSuffix() orelse return null;
+            return try p.addNode(.{ .@"&" = suffix });
+        }
+        if (p.eatNot()) {
+            const suffix = try p.parseSuffix() orelse return null;
+            return try p.addNode(.{ .@"!" = suffix });
+        }
+        return try p.parseSuffix();
+    }
+
+    // Suffix          <- Primary ( QUERY / STAR / PLUS )?
+    fn parseSuffix(p: *Parser) !?Node.Index {
+        const primary = try p.parsePrimary() orelse return null;
+        if (p.eatQuery()) {
+            return try p.addNode(.{ .@"?" = primary });
+        }
+        if (p.eatStar()) {
+            return try p.addNode(.{ .@"*" = primary });
+        }
+        if (p.eatPlus()) {
+            return try p.addNode(.{ .@"+" = primary });
+        }
+        return primary;
+    }
+
+    // Primary         <- Identifier !LEFTARROW
+    //                  / OPEN Expression CLOSE
+    //                  / Literal
+    //                  / Class
+    //                  / DOT
+    //                  / Action
+    //                  / BEGIN
+    //                  / END
+    fn parsePrimary(p: *Parser) !?Node.Index {
+        const init_pos = p.savePos();
+        if (try p.parseIdentifier()) |id| {
+            const pos = p.savePos();
+            if (!p.eatLeftArrow()) {
+                p.restorePos(pos);
+                return id;
+            }
+        }
+        p.restorePos(init_pos);
+        if (p.eatOpen()) if (try p.parseExpression()) |expr| if (p.eatClose()) return expr;
+        p.restorePos(init_pos);
+        if (try p.parseLiteral()) |literal| return literal;
+        p.restorePos(init_pos);
+        if (try p.parseClass()) |class| return class;
+        p.restorePos(init_pos);
+        if (p.eatDot()) return try p.addNode(.@".");
+        // We don't implement Action, BEGIN, and END.
+        return null;
+    }
+
+    // Identifier      <- < IdentStart IdentCont* > Spacing
+    // IdentStart      <- [a-zA-Z_]
+    // IdentCont       <- IdentStart / [0-9]
+    fn parseIdentifier(p: *Parser) !?Node.Index {
+        const start = p.i;
+        switch (p.next() orelse return null) {
+            'a'...'z', 'A'...'Z', '_' => {},
+            else => return null,
+        }
+        while (p.peek()) |cont| {
+            switch (cont) {
+                'a'...'z', 'A'...'Z', '_', '0'...'9' => p.i += 1,
+                else => break,
+            }
+        }
+        const id = p.source[start..p.i];
+        _ = p.eatSpacing();
+        return try p.addNode(.{ .id = id });
+    }
+
+    // Literal         <- ['] < ( !['] Char  )* > ['] Spacing
+    //                  / ["] < ( !["] Char  )* > ["] Spacing
+    fn parseLiteral(p: *Parser) !?Node.Index {
+        const quote: u8 = if (p.eat('\'')) '\'' else if (p.eat('"')) '"' else return null;
+        const off = p.strings.items.len;
+        while (!p.eat(quote)) {
+            const byte = p.parseChar() orelse return null;
+            try p.strings.append(p.gpa, byte);
+        }
+        _ = p.eatSpacing();
+        return try p.addNode(.{ .literal = .{
+            .off = @intCast(off),
+            .len = @intCast(p.strings.items.len - off),
+        } });
+    }
+
+    // Class           <- '[' < ( !']' Range )* > ']' Spacing
+    fn parseClass(p: *Parser) !?Node.Index {
+        var scratch: std.ArrayList(Node.Index) = .empty;
+        defer scratch.deinit(p.gpa);
+        if (!p.eat('[')) return null;
+        while (!p.eat(']')) {
+            const range = try p.parseRange() orelse return null;
+            try scratch.append(p.gpa, range);
+        }
+        _ = p.eatSpacing();
+        const ranges = try p.addExtra(scratch.items);
+        return try p.addNode(.{ .class = ranges });
+    }
+
+    // Range           <- Char '-' Char / Char
+    fn parseRange(p: *Parser) !?Node.Index {
+        const start = p.parseChar() orelse return null;
+        const end = blk: {
+            if (p.eat('-')) {
+                break :blk p.parseChar() orelse return null;
+            }
+            break :blk start;
+        };
+        return try p.addNode(.{ .range = .{
+            .start = start,
+            .end = end,
+        } });
+    }
+
+    // Char            <- '\\' [abefnrtv'"\[\]\\]
+    //                  / '\\' [0-3][0-7][0-7]
+    //                  / '\\' [0-7][0-7]?
+    //                  / '\\' '-'
+    //                  / !'\\' .
+    fn parseChar(p: *Parser) ?u8 {
+        if (p.eat('\\')) {
+            const c = p.next() orelse return null;
+            return switch (c) {
+                // Only the escape sequences actually used in the Zig grammar are implemented
+                'n' => '\n',
+                'r' => '\r',
+                't' => '\t',
+                '\'' => '\'',
+                '"' => '"',
+                '[' => '[',
+                ']' => ']',
+                '\\' => '\\',
+                '-' => '-',
+                '0'...'7' => {
+                    // octal
+                    if (c <= '3') {
+                        const c2 = p.next() orelse return null;
+                        if (c2 < '0' or c2 > '7') return null;
+                        const c3 = p.next() orelse return null;
+                        if (c3 < '0' or c3 > '7') return null;
+                        return (c - '0') * 8 * 8 + (c2 - '0') * 8 + (c3 - '0');
+                    } else {
+                        if (p.peek()) |c2| {
+                            if (c2 >= '0' and c2 <= '7') {
+                                p.i += 1;
+                                return (c - '0') * 8 + (c2 - '0');
+                            }
+                        }
+                        return (c - '0');
+                    }
+                },
+                else => null,
+            };
+        } else {
+            return p.next();
+        }
+    }
+
+    // LEFTARROW       <- '<-' Spacing
+    fn eatLeftArrow(p: *Parser) bool {
+        return p.eat('<') and p.eat('-') and p.eatSpacing();
+    }
+
+    // SLASH           <- '/' Spacing
+    fn eatSlash(p: *Parser) bool {
+        return p.eat('/') and p.eatSpacing();
+    }
+
+    // AND             <- '&' Spacing
+    fn eatAnd(p: *Parser) bool {
+        return p.eat('&') and p.eatSpacing();
+    }
+
+    // NOT             <- '!' Spacing
+    fn eatNot(p: *Parser) bool {
+        return p.eat('!') and p.eatSpacing();
+    }
+
+    // QUERY           <- '?' Spacing
+    fn eatQuery(p: *Parser) bool {
+        return p.eat('?') and p.eatSpacing();
+    }
+
+    // STAR            <- '*' Spacing
+    fn eatStar(p: *Parser) bool {
+        return p.eat('*') and p.eatSpacing();
+    }
+
+    // PLUS            <- '+' Spacing
+    fn eatPlus(p: *Parser) bool {
+        return p.eat('+') and p.eatSpacing();
+    }
+
+    // OPEN            <- '(' Spacing
+    fn eatOpen(p: *Parser) bool {
+        return p.eat('(') and p.eatSpacing();
+    }
+
+    // CLOSE           <- ')' Spacing
+    fn eatClose(p: *Parser) bool {
+        return p.eat(')') and p.eatSpacing();
+    }
+
+    // DOT             <- '.' Spacing
+    fn eatDot(p: *Parser) bool {
+        return p.eat('.') and p.eatSpacing();
+    }
+
+    // Spacing         <- ( Space / Comment )*
+    fn eatSpacing(p: *Parser) bool {
+        while (p.eatSpace() or p.eatComment()) {}
+        return true;
+    }
+
+    // Comment         <- '#' ( !EndOfLine . )* EndOfLine
+    fn eatComment(p: *Parser) bool {
+        if (!p.eat('#')) return false;
+        while (!p.eatEndOfLine()) p.i += 1;
+        return true;
+    }
+
+    // Space           <- ' ' / '\t' / EndOfLine
+    fn eatSpace(p: *Parser) bool {
+        return p.eat(' ') or p.eat('\t') or p.eatEndOfLine();
+    }
+
+    // EndOfLine       <- '\r\n' / '\n' / '\r'
+    fn eatEndOfLine(p: *Parser) bool {
+        return p.eat('\n');
+    }
+
+    fn peek(p: *Parser) ?u8 {
+        if (p.i < p.source.len) {
+            return p.source[p.i];
+        }
+        return null;
+    }
+
+    fn next(p: *Parser) ?u8 {
+        if (p.i < p.source.len) {
+            defer p.i += 1;
+            return p.source[p.i];
+        }
+        return null;
+    }
+
+    fn eat(p: *Parser, byte: u8) bool {
+        if (p.i < p.source.len and p.source[p.i] == byte) {
+            p.i += 1;
+            return true;
+        }
+        return false;
+    }
+
+    fn addNode(p: *Parser, node: Node) !Node.Index {
+        try p.nodes.append(p.gpa, node);
+        return @enumFromInt(p.nodes.items.len - 1);
+    }
+
+    fn addExtra(p: *Parser, nodes: []const Node.Index) !Node.Slice {
+        const off = p.extra.items.len;
+        try p.extra.appendSlice(p.gpa, nodes);
+        return .{ .off = @intCast(off), .len = @intCast(p.extra.items.len - off) };
+    }
+
+    const Pos = struct {
+        i: u32,
+        nodes_len: u32,
+        extra_len: u32,
+        strings_len: u32,
+    };
+
+    fn savePos(p: *const Parser) Pos {
+        return .{
+            .i = p.i,
+            .nodes_len = @intCast(p.nodes.items.len),
+            .extra_len = @intCast(p.extra.items.len),
+            .strings_len = @intCast(p.strings.items.len),
+        };
+    }
+
+    fn restorePos(p: *Parser, pos: Pos) void {
+        assert(p.i >= pos.i);
+        p.i = pos.i;
+        p.nodes.shrinkRetainingCapacity(pos.nodes_len);
+        p.extra.shrinkRetainingCapacity(pos.extra_len);
+        p.strings.shrinkRetainingCapacity(pos.strings_len);
+    }
+
+    fn getExtra(p: *const Parser, s: Node.Slice) []const Node.Index {
+        return p.extra.items[s.off..][0..s.len];
+    }
+};
diff --git a/tools/gen_spirv_spec.zig b/tools/gen_spirv_spec.zig
index fbf8fa167ae6fc0ae5dcba040a87046b66d34c5c..8258c0c464af12be489b099d7ad0105ab2c0d1c2 100644
--- a/tools/gen_spirv_spec.zig
+++ b/tools/gen_spirv_spec.zig
@@ -116,7 +116,7 @@ pub fn main(init: std.process.Init) !void {
     try allocating.writer.writeByte(0);
     const output = allocating.written()[0 .. allocating.written().len - 1 :0];
 
-    var tree = try std.zig.Ast.parse(arena, output, .zig);
+    var tree = try std.zig.Ast.parse(arena, output, .zig, .{});
 
     if (tree.errors.len != 0) {
         try std.zig.printAstErrorsToStderr(arena, io, tree, "", .auto);