authorgravatar for mail@isaacfreund.comIsaac Freund <mail@isaacfreund.com> 2026-06-15 11:28:11+02:00
committergravatar for mail@isaacfreund.comIsaac Freund <mail@isaacfreund.com> 2026-07-08 11:48:57+02:00
log39023329229279b6eb0ddfd4879d15ad9644375e
tree4da2d06ee95150b4c3510e03afc5d1bb5f76933d
parent5c2510ba58d2c5b0b3082244ab9b9320662d1d65
signaturelock-open Commit is signed but in an unrecognized format.

grammar: rework whitespace handling

The grammar needs to be fixed to match Parse.zig's "operator has whitespace on one side but not the other" error, which is implemented in Parse.zig using a constant lookbehind of 1. However, standard PEG does not support lookbehind, which means our approach to handling whitespace needs to be reworked. Moving the `skip` non-terminal to be processed before each "token" in the grammar rather than afterwards makes it possible to cleanly match the Parse.zig operator whitespace handling, which will be implemented in the next commit. This commit is purely a refactor, no functional changes are intended.

2 files changed, 350 insertions(+), 316 deletions(-)

doc/langref/grammar.peg+124-124
......@@ -1,4 +1,4 @@
1Root <- skip ContainerMembers eof
1Root <- ContainerMembers skip eof
22
33# *** Top level ***
44ContainerMembers <- container_doc_comment? ContainerDeclaration* (ContainerField COMMA)* (ContainerField / ContainerDeclaration*)
......@@ -430,8 +430,8 @@ string_char
430430 <- '\\"'
431431 / !["] non_control_utf8
432432
433container_doc_comment <- ('//!' non_control_utf8* newline skip)+
434doc_comment <- ('///' non_control_utf8* newline skip)+
433container_doc_comment <- (skip '//!' non_control_utf8* newline)+
434doc_comment <- (skip '///' non_control_utf8* newline)+
435435line_comment
436436 <- '//' ![!/] non_control_utf8* newline
437437 / '////' non_control_utf8* newline
......@@ -439,137 +439,137 @@ line_string <- '\\\\' non_control_utf8* newline
439439newline <- "\n" / "\r\n" / eof
440440skip <- ([ \n\t\r] / line_comment)*
441441
442CHAR_LITERAL <- ['] char_char* ['] skip
442CHAR_LITERAL <- skip ['] char_char* [']
443443
444444digit <- [_0-9A-DF-OQ-Za-df-oq-z]
445445digit_int <- digit / [eEpP]
446446digit_float <- digit / [eEpP] [-+]?
447447NUMBERLITERAL
448 <- [0-9] digit_int* '.' digit_float+ skip
449 / [0-9] digit_float* skip
448 <- skip [0-9] digit_int* '.' digit_float+
449 / skip [0-9] digit_float*
450450
451451
452STRINGLITERALSINGLE <- ["] string_char* ["] skip
452STRINGLITERALSINGLE <- skip ["] string_char* ["]
453453STRINGLITERAL
454454 <- STRINGLITERALSINGLE
455 / (line_string skip)+
455 / (skip line_string)+
456456IDENTIFIER
457 <- !keyword [A-Za-z_] [A-Za-z0-9_]* skip
458 / '@' STRINGLITERALSINGLE
459BUILTINIDENTIFIER <- '@'[A-Za-z_][A-Za-z0-9_]* skip
460
461
462AMPERSAND <- '&' ![=] skip
463AMPERSANDEQUAL <- '&=' skip
464ASTERISK <- '*' ![%=|] skip
465ASTERISKEQUAL <- '*=' skip
466ASTERISKPERCENT <- '*%' ![=] skip
467ASTERISKPERCENTEQUAL <- '*%=' skip
468ASTERISKPIPE <- '*|' ![=] skip
469ASTERISKPIPEEQUAL <- '*|=' skip
470CARET <- '^' ![=] skip
471CARETEQUAL <- '^=' skip
472COLON <- ':' skip
473COMMA <- ',' skip
474DOT <- '.' ![*.?] skip
475DOT2 <- '..' ![.] skip
476DOT3 <- '...' skip
477DOTASTERISK <- '.*' skip
478DOTQUESTIONMARK <- '.?' skip
479EQUAL <- '=' ![>=] skip
480EQUALEQUAL <- '==' skip
481EQUALRARROW <- '=>' skip
482EXCLAMATIONMARK <- '!' ![=] skip
483EXCLAMATIONMARKEQUAL <- '!=' skip
484LARROW <- '<' ![<=] skip
485LARROW2 <- '<<' ![=|] skip
486LARROW2EQUAL <- '<<=' skip
487LARROW2PIPE <- '<<|' ![=] skip
488LARROW2PIPEEQUAL <- '<<|=' skip
489LARROWEQUAL <- '<=' skip
490LBRACE <- '{' skip
491LBRACKET <- '[' skip
492LPAREN <- '(' skip
493MINUS <- '-' ![%=>|] skip
494MINUSEQUAL <- '-=' skip
495MINUSPERCENT <- '-%' ![=] skip
496MINUSPERCENTEQUAL <- '-%=' skip
497MINUSPIPE <- '-|' ![=] skip
498MINUSPIPEEQUAL <- '-|=' skip
499MINUSRARROW <- '->' skip
500PERCENT <- '%' ![=] skip
501PERCENTEQUAL <- '%=' skip
502PIPE <- '|' ![|=] skip
503PIPE2 <- '||' skip
504PIPEEQUAL <- '|=' skip
505PLUS <- '+' ![%+=|] skip
506PLUS2 <- '++' skip
507PLUSEQUAL <- '+=' skip
508PLUSPERCENT <- '+%' ![=] skip
509PLUSPERCENTEQUAL <- '+%=' skip
510PLUSPIPE <- '+|' ![=] skip
511PLUSPIPEEQUAL <- '+|=' skip
512LETTERC <- 'c' skip
513QUESTIONMARK <- '?' skip
514RARROW <- '>' ![>=] skip
515RARROW2 <- '>>' ![=] skip
516RARROW2EQUAL <- '>>=' skip
517RARROWEQUAL <- '>=' skip
518RBRACE <- '}' skip
519RBRACKET <- ']' skip
520RPAREN <- ')' skip
521SEMICOLON <- ';' skip
522SLASH <- '/' ![=] skip
523SLASHEQUAL <- '/=' skip
524TILDE <- '~' skip
525
526end_of_word <- ![a-zA-Z0-9_] skip
527KEYWORD_addrspace <- 'addrspace' end_of_word
528KEYWORD_align <- 'align' end_of_word
529KEYWORD_allowzero <- 'allowzero' end_of_word
530KEYWORD_and <- 'and' end_of_word
531KEYWORD_anyframe <- 'anyframe' end_of_word
532KEYWORD_anytype <- 'anytype' end_of_word
533KEYWORD_asm <- 'asm' end_of_word
534KEYWORD_break <- 'break' end_of_word
535KEYWORD_callconv <- 'callconv' end_of_word
536KEYWORD_catch <- 'catch' end_of_word
537KEYWORD_comptime <- 'comptime' end_of_word
538KEYWORD_const <- 'const' end_of_word
539KEYWORD_continue <- 'continue' end_of_word
540KEYWORD_defer <- 'defer' end_of_word
541KEYWORD_else <- 'else' end_of_word
542KEYWORD_enum <- 'enum' end_of_word
543KEYWORD_errdefer <- 'errdefer' end_of_word
544KEYWORD_error <- 'error' end_of_word
545KEYWORD_export <- 'export' end_of_word
546KEYWORD_extern <- 'extern' end_of_word
547KEYWORD_fn <- 'fn' end_of_word
548KEYWORD_for <- 'for' end_of_word
549KEYWORD_if <- 'if' end_of_word
550KEYWORD_inline <- 'inline' end_of_word
551KEYWORD_noalias <- 'noalias' end_of_word
552KEYWORD_nosuspend <- 'nosuspend' end_of_word
553KEYWORD_noinline <- 'noinline' end_of_word
554KEYWORD_opaque <- 'opaque' end_of_word
555KEYWORD_or <- 'or' end_of_word
556KEYWORD_orelse <- 'orelse' end_of_word
557KEYWORD_packed <- 'packed' end_of_word
558KEYWORD_pub <- 'pub' end_of_word
559KEYWORD_resume <- 'resume' end_of_word
560KEYWORD_return <- 'return' end_of_word
561KEYWORD_linksection <- 'linksection' end_of_word
562KEYWORD_struct <- 'struct' end_of_word
563KEYWORD_suspend <- 'suspend' end_of_word
564KEYWORD_switch <- 'switch' end_of_word
565KEYWORD_test <- 'test' end_of_word
566KEYWORD_threadlocal <- 'threadlocal' end_of_word
567KEYWORD_try <- 'try' end_of_word
568KEYWORD_union <- 'union' end_of_word
569KEYWORD_unreachable <- 'unreachable' end_of_word
570KEYWORD_var <- 'var' end_of_word
571KEYWORD_volatile <- 'volatile' end_of_word
572KEYWORD_while <- 'while' end_of_word
457 <- skip !keyword [A-Za-z_] [A-Za-z0-9_]*
458 / skip '@' STRINGLITERALSINGLE
459BUILTINIDENTIFIER <- skip '@'[A-Za-z_][A-Za-z0-9_]*
460
461
462AMPERSAND <- skip '&' ![=]
463AMPERSANDEQUAL <- skip '&='
464ASTERISK <- skip '*' ![%=|]
465ASTERISKEQUAL <- skip '*='
466ASTERISKPERCENT <- skip '*%' ![=]
467ASTERISKPERCENTEQUAL <- skip '*%='
468ASTERISKPIPE <- skip '*|' ![=]
469ASTERISKPIPEEQUAL <- skip '*|='
470CARET <- skip '^' ![=]
471CARETEQUAL <- skip '^='
472COLON <- skip ':'
473COMMA <- skip ','
474DOT <- skip '.' ![*.?]
475DOT2 <- skip '..' ![.]
476DOT3 <- skip '...'
477DOTASTERISK <- skip '.*'
478DOTQUESTIONMARK <- skip '.?'
479EQUAL <- skip '=' ![>=]
480EQUALEQUAL <- skip '=='
481EQUALRARROW <- skip '=>'
482EXCLAMATIONMARK <- skip '!' ![=]
483EXCLAMATIONMARKEQUAL <- skip '!='
484LARROW <- skip '<' ![<=]
485LARROW2 <- skip '<<' ![=|]
486LARROW2EQUAL <- skip '<<='
487LARROW2PIPE <- skip '<<|' ![=]
488LARROW2PIPEEQUAL <- skip '<<|='
489LARROWEQUAL <- skip '<='
490LBRACE <- skip '{'
491LBRACKET <- skip '['
492LPAREN <- skip '('
493MINUS <- skip '-' ![%=>|]
494MINUSEQUAL <- skip '-='
495MINUSPERCENT <- skip '-%' ![=]
496MINUSPERCENTEQUAL <- skip '-%='
497MINUSPIPE <- skip '-|' ![=]
498MINUSPIPEEQUAL <- skip '-|='
499MINUSRARROW <- skip '->'
500PERCENT <- skip '%' ![=]
501PERCENTEQUAL <- skip '%='
502PIPE <- skip '|' ![|=]
503PIPE2 <- skip '||'
504PIPEEQUAL <- skip '|='
505PLUS <- skip '+' ![%+=|]
506PLUS2 <- skip '++'
507PLUSEQUAL <- skip '+='
508PLUSPERCENT <- skip '+%' ![=]
509PLUSPERCENTEQUAL <- skip '+%='
510PLUSPIPE <- skip '+|' ![=]
511PLUSPIPEEQUAL <- skip '+|='
512LETTERC <- skip 'c'
513QUESTIONMARK <- skip '?'
514RARROW <- skip '>' ![>=]
515RARROW2 <- skip '>>' ![=]
516RARROW2EQUAL <- skip '>>='
517RARROWEQUAL <- skip '>='
518RBRACE <- skip '}'
519RBRACKET <- skip ']'
520RPAREN <- skip ')'
521SEMICOLON <- skip ';'
522SLASH <- skip '/' ![=]
523SLASHEQUAL <- skip '/='
524TILDE <- skip '~'
525
526end_of_word <- ![a-zA-Z0-9_]
527KEYWORD_addrspace <- skip 'addrspace' end_of_word
528KEYWORD_align <- skip 'align' end_of_word
529KEYWORD_allowzero <- skip 'allowzero' end_of_word
530KEYWORD_and <- skip 'and' end_of_word
531KEYWORD_anyframe <- skip 'anyframe' end_of_word
532KEYWORD_anytype <- skip 'anytype' end_of_word
533KEYWORD_asm <- skip 'asm' end_of_word
534KEYWORD_break <- skip 'break' end_of_word
535KEYWORD_callconv <- skip 'callconv' end_of_word
536KEYWORD_catch <- skip 'catch' end_of_word
537KEYWORD_comptime <- skip 'comptime' end_of_word
538KEYWORD_const <- skip 'const' end_of_word
539KEYWORD_continue <- skip 'continue' end_of_word
540KEYWORD_defer <- skip 'defer' end_of_word
541KEYWORD_else <- skip 'else' end_of_word
542KEYWORD_enum <- skip 'enum' end_of_word
543KEYWORD_errdefer <- skip 'errdefer' end_of_word
544KEYWORD_error <- skip 'error' end_of_word
545KEYWORD_export <- skip 'export' end_of_word
546KEYWORD_extern <- skip 'extern' end_of_word
547KEYWORD_fn <- skip 'fn' end_of_word
548KEYWORD_for <- skip 'for' end_of_word
549KEYWORD_if <- skip 'if' end_of_word
550KEYWORD_inline <- skip 'inline' end_of_word
551KEYWORD_noalias <- skip 'noalias' end_of_word
552KEYWORD_nosuspend <- skip 'nosuspend' end_of_word
553KEYWORD_noinline <- skip 'noinline' end_of_word
554KEYWORD_opaque <- skip 'opaque' end_of_word
555KEYWORD_or <- skip 'or' end_of_word
556KEYWORD_orelse <- skip 'orelse' end_of_word
557KEYWORD_packed <- skip 'packed' end_of_word
558KEYWORD_pub <- skip 'pub' end_of_word
559KEYWORD_resume <- skip 'resume' end_of_word
560KEYWORD_return <- skip 'return' end_of_word
561KEYWORD_linksection <- skip 'linksection' end_of_word
562KEYWORD_struct <- skip 'struct' end_of_word
563KEYWORD_suspend <- skip 'suspend' end_of_word
564KEYWORD_switch <- skip 'switch' end_of_word
565KEYWORD_test <- skip 'test' end_of_word
566KEYWORD_threadlocal <- skip 'threadlocal' end_of_word
567KEYWORD_try <- skip 'try' end_of_word
568KEYWORD_union <- skip 'union' end_of_word
569KEYWORD_unreachable <- skip 'unreachable' end_of_word
570KEYWORD_var <- skip 'var' end_of_word
571KEYWORD_volatile <- skip 'volatile' end_of_word
572KEYWORD_while <- skip 'while' end_of_word
573573
574574keyword <- KEYWORD_addrspace / KEYWORD_align / KEYWORD_allowzero / KEYWORD_and
575575 / KEYWORD_anyframe / KEYWORD_anytype / KEYWORD_asm
lib/std/zig/parser_generated_oracle.zig+226-192
......@@ -16,7 +16,7 @@ const Parser = struct {
1616 pub fn parseRoot(p: *Parser) bool {
1717 return blk_0: {
1818 const pos_0 = p.i;
19 if (p.parseskip() and p.parseContainerMembers() and p.parseeof()) break :blk_0 true;
19 if (p.parseContainerMembers() and p.parseskip() and p.parseeof()) break :blk_0 true;
2020 p.i = pos_0;
2121 break :blk_0 false;
2222 };
......@@ -612,6 +612,40 @@ const Parser = struct {
612612 break :blk_0 false;
613613 };
614614 }
615 pub fn parseBinOp(p: *Parser) bool {
616 return blk_0: {
617 const pos_0 = p.i;
618 if (p.parseExpr() and blk_1: {
619 while (blk_3: {
620 const pos_3 = p.i;
621 if (blk_4: {
622 var match_4 = false;
623 while (p.parsewhite()) {
624 match_4 = true;
625 }
626 break :blk_4 match_4;
627 } and blk_4: {
628 if (std.mem.startsWith(u8, p.source[p.i..], "or")) {
629 p.i += 2;
630 break :blk_4 true;
631 }
632 break :blk_4 false;
633 } and blk_4: {
634 var match_4 = false;
635 while (p.parsewhite()) {
636 match_4 = true;
637 }
638 break :blk_4 match_4;
639 } and p.parseBoolAndExpr()) break :blk_3 true;
640 p.i = pos_3;
641 break :blk_3 false;
642 }) {}
643 break :blk_1 true;
644 }) break :blk_0 true;
645 p.i = pos_0;
646 break :blk_0 false;
647 };
648 }
615649 pub fn parsePrefixExpr(p: *Parser) bool {
616650 return blk_0: {
617651 const pos_0 = p.i;
......@@ -2185,7 +2219,7 @@ const Parser = struct {
21852219 var match_1 = false;
21862220 while (blk_3: {
21872221 const pos_3 = p.i;
2188 if (blk_4: {
2222 if (p.parseskip() and blk_4: {
21892223 if (std.mem.startsWith(u8, p.source[p.i..], "//!")) {
21902224 p.i += 3;
21912225 break :blk_4 true;
......@@ -2194,7 +2228,7 @@ const Parser = struct {
21942228 } and blk_4: {
21952229 while (p.parsenon_control_utf8()) {}
21962230 break :blk_4 true;
2197 } and p.parsenewline() and p.parseskip()) break :blk_3 true;
2231 } and p.parsenewline()) break :blk_3 true;
21982232 p.i = pos_3;
21992233 break :blk_3 false;
22002234 }) {
......@@ -2213,7 +2247,7 @@ const Parser = struct {
22132247 var match_1 = false;
22142248 while (blk_3: {
22152249 const pos_3 = p.i;
2216 if (blk_4: {
2250 if (p.parseskip() and blk_4: {
22172251 if (std.mem.startsWith(u8, p.source[p.i..], "///")) {
22182252 p.i += 3;
22192253 break :blk_4 true;
......@@ -2222,7 +2256,7 @@ const Parser = struct {
22222256 } and blk_4: {
22232257 while (p.parsenon_control_utf8()) {}
22242258 break :blk_4 true;
2225 } and p.parsenewline() and p.parseskip()) break :blk_3 true;
2259 } and p.parsenewline()) break :blk_3 true;
22262260 p.i = pos_3;
22272261 break :blk_3 false;
22282262 }) {
......@@ -2347,7 +2381,7 @@ const Parser = struct {
23472381 pub fn parseCHAR_LITERAL(p: *Parser) bool {
23482382 return blk_0: {
23492383 const pos_0 = p.i;
2350 if ((p.i < p.source.len and switch (p.source[p.i]) {
2384 if (p.parseskip() and (p.i < p.source.len and switch (p.source[p.i]) {
23512385 '\''...'\'',
23522386 => blk_1: {
23532387 p.i += 1;
......@@ -2364,7 +2398,7 @@ const Parser = struct {
23642398 break :blk_1 true;
23652399 },
23662400 else => false,
2367 }) and p.parseskip()) break :blk_0 true;
2401 })) break :blk_0 true;
23682402 p.i = pos_0;
23692403 break :blk_0 false;
23702404 };
......@@ -2442,7 +2476,7 @@ const Parser = struct {
24422476 pub fn parseNUMBERLITERAL(p: *Parser) bool {
24432477 return blk_0: {
24442478 const pos_0 = p.i;
2445 if ((p.i < p.source.len and switch (p.source[p.i]) {
2479 if (p.parseskip() and (p.i < p.source.len and switch (p.source[p.i]) {
24462480 '0'...'9',
24472481 => blk_1: {
24482482 p.i += 1;
......@@ -2464,9 +2498,9 @@ const Parser = struct {
24642498 match_1 = true;
24652499 }
24662500 break :blk_1 match_1;
2467 } and p.parseskip()) break :blk_0 true;
2501 }) break :blk_0 true;
24682502 p.i = pos_0;
2469 if ((p.i < p.source.len and switch (p.source[p.i]) {
2503 if (p.parseskip() and (p.i < p.source.len and switch (p.source[p.i]) {
24702504 '0'...'9',
24712505 => blk_1: {
24722506 p.i += 1;
......@@ -2476,7 +2510,7 @@ const Parser = struct {
24762510 }) and blk_1: {
24772511 while (p.parsedigit_float()) {}
24782512 break :blk_1 true;
2479 } and p.parseskip()) break :blk_0 true;
2513 }) break :blk_0 true;
24802514 p.i = pos_0;
24812515 break :blk_0 false;
24822516 };
......@@ -2484,7 +2518,7 @@ const Parser = struct {
24842518 pub fn parseSTRINGLITERALSINGLE(p: *Parser) bool {
24852519 return blk_0: {
24862520 const pos_0 = p.i;
2487 if ((p.i < p.source.len and switch (p.source[p.i]) {
2521 if (p.parseskip() and (p.i < p.source.len and switch (p.source[p.i]) {
24882522 '"'...'"',
24892523 => blk_1: {
24902524 p.i += 1;
......@@ -2501,7 +2535,7 @@ const Parser = struct {
25012535 break :blk_1 true;
25022536 },
25032537 else => false,
2504 }) and p.parseskip()) break :blk_0 true;
2538 })) break :blk_0 true;
25052539 p.i = pos_0;
25062540 break :blk_0 false;
25072541 };
......@@ -2515,7 +2549,7 @@ const Parser = struct {
25152549 var match_1 = false;
25162550 while (blk_3: {
25172551 const pos_3 = p.i;
2518 if (p.parseline_string() and p.parseskip()) break :blk_3 true;
2552 if (p.parseskip() and p.parseline_string()) break :blk_3 true;
25192553 p.i = pos_3;
25202554 break :blk_3 false;
25212555 }) {
......@@ -2530,7 +2564,7 @@ const Parser = struct {
25302564 pub fn parseIDENTIFIER(p: *Parser) bool {
25312565 return blk_0: {
25322566 const pos_0 = p.i;
2533 if (blk_1: {
2567 if (p.parseskip() and blk_1: {
25342568 const pos_1 = p.i;
25352569 const match_1 = p.parsekeyword();
25362570 p.i = pos_1;
......@@ -2557,9 +2591,9 @@ const Parser = struct {
25572591 else => false,
25582592 })) {}
25592593 break :blk_1 true;
2560 } and p.parseskip()) break :blk_0 true;
2594 }) break :blk_0 true;
25612595 p.i = pos_0;
2562 if (blk_1: {
2596 if (p.parseskip() and blk_1: {
25632597 if (std.mem.startsWith(u8, p.source[p.i..], "@")) {
25642598 p.i += 1;
25652599 break :blk_1 true;
......@@ -2573,7 +2607,7 @@ const Parser = struct {
25732607 pub fn parseBUILTINIDENTIFIER(p: *Parser) bool {
25742608 return blk_0: {
25752609 const pos_0 = p.i;
2576 if (blk_1: {
2610 if (p.parseskip() and blk_1: {
25772611 if (std.mem.startsWith(u8, p.source[p.i..], "@")) {
25782612 p.i += 1;
25792613 break :blk_1 true;
......@@ -2601,7 +2635,7 @@ const Parser = struct {
26012635 else => false,
26022636 })) {}
26032637 break :blk_1 true;
2604 } and p.parseskip()) break :blk_0 true;
2638 }) break :blk_0 true;
26052639 p.i = pos_0;
26062640 break :blk_0 false;
26072641 };
......@@ -2609,7 +2643,7 @@ const Parser = struct {
26092643 pub fn parseAMPERSAND(p: *Parser) bool {
26102644 return blk_0: {
26112645 const pos_0 = p.i;
2612 if (blk_1: {
2646 if (p.parseskip() and blk_1: {
26132647 if (std.mem.startsWith(u8, p.source[p.i..], "&")) {
26142648 p.i += 1;
26152649 break :blk_1 true;
......@@ -2627,7 +2661,7 @@ const Parser = struct {
26272661 });
26282662 p.i = pos_1;
26292663 break :blk_1 !match_1;
2630 } and p.parseskip()) break :blk_0 true;
2664 }) break :blk_0 true;
26312665 p.i = pos_0;
26322666 break :blk_0 false;
26332667 };
......@@ -2635,13 +2669,13 @@ const Parser = struct {
26352669 pub fn parseAMPERSANDEQUAL(p: *Parser) bool {
26362670 return blk_0: {
26372671 const pos_0 = p.i;
2638 if (blk_1: {
2672 if (p.parseskip() and blk_1: {
26392673 if (std.mem.startsWith(u8, p.source[p.i..], "&=")) {
26402674 p.i += 2;
26412675 break :blk_1 true;
26422676 }
26432677 break :blk_1 false;
2644 } and p.parseskip()) break :blk_0 true;
2678 }) break :blk_0 true;
26452679 p.i = pos_0;
26462680 break :blk_0 false;
26472681 };
......@@ -2649,7 +2683,7 @@ const Parser = struct {
26492683 pub fn parseASTERISK(p: *Parser) bool {
26502684 return blk_0: {
26512685 const pos_0 = p.i;
2652 if (blk_1: {
2686 if (p.parseskip() and blk_1: {
26532687 if (std.mem.startsWith(u8, p.source[p.i..], "*")) {
26542688 p.i += 1;
26552689 break :blk_1 true;
......@@ -2669,7 +2703,7 @@ const Parser = struct {
26692703 });
26702704 p.i = pos_1;
26712705 break :blk_1 !match_1;
2672 } and p.parseskip()) break :blk_0 true;
2706 }) break :blk_0 true;
26732707 p.i = pos_0;
26742708 break :blk_0 false;
26752709 };
......@@ -2677,13 +2711,13 @@ const Parser = struct {
26772711 pub fn parseASTERISKEQUAL(p: *Parser) bool {
26782712 return blk_0: {
26792713 const pos_0 = p.i;
2680 if (blk_1: {
2714 if (p.parseskip() and blk_1: {
26812715 if (std.mem.startsWith(u8, p.source[p.i..], "*=")) {
26822716 p.i += 2;
26832717 break :blk_1 true;
26842718 }
26852719 break :blk_1 false;
2686 } and p.parseskip()) break :blk_0 true;
2720 }) break :blk_0 true;
26872721 p.i = pos_0;
26882722 break :blk_0 false;
26892723 };
......@@ -2691,7 +2725,7 @@ const Parser = struct {
26912725 pub fn parseASTERISKPERCENT(p: *Parser) bool {
26922726 return blk_0: {
26932727 const pos_0 = p.i;
2694 if (blk_1: {
2728 if (p.parseskip() and blk_1: {
26952729 if (std.mem.startsWith(u8, p.source[p.i..], "*%")) {
26962730 p.i += 2;
26972731 break :blk_1 true;
......@@ -2709,7 +2743,7 @@ const Parser = struct {
27092743 });
27102744 p.i = pos_1;
27112745 break :blk_1 !match_1;
2712 } and p.parseskip()) break :blk_0 true;
2746 }) break :blk_0 true;
27132747 p.i = pos_0;
27142748 break :blk_0 false;
27152749 };
......@@ -2717,13 +2751,13 @@ const Parser = struct {
27172751 pub fn parseASTERISKPERCENTEQUAL(p: *Parser) bool {
27182752 return blk_0: {
27192753 const pos_0 = p.i;
2720 if (blk_1: {
2754 if (p.parseskip() and blk_1: {
27212755 if (std.mem.startsWith(u8, p.source[p.i..], "*%=")) {
27222756 p.i += 3;
27232757 break :blk_1 true;
27242758 }
27252759 break :blk_1 false;
2726 } and p.parseskip()) break :blk_0 true;
2760 }) break :blk_0 true;
27272761 p.i = pos_0;
27282762 break :blk_0 false;
27292763 };
......@@ -2731,7 +2765,7 @@ const Parser = struct {
27312765 pub fn parseASTERISKPIPE(p: *Parser) bool {
27322766 return blk_0: {
27332767 const pos_0 = p.i;
2734 if (blk_1: {
2768 if (p.parseskip() and blk_1: {
27352769 if (std.mem.startsWith(u8, p.source[p.i..], "*|")) {
27362770 p.i += 2;
27372771 break :blk_1 true;
......@@ -2749,7 +2783,7 @@ const Parser = struct {
27492783 });
27502784 p.i = pos_1;
27512785 break :blk_1 !match_1;
2752 } and p.parseskip()) break :blk_0 true;
2786 }) break :blk_0 true;
27532787 p.i = pos_0;
27542788 break :blk_0 false;
27552789 };
......@@ -2757,13 +2791,13 @@ const Parser = struct {
27572791 pub fn parseASTERISKPIPEEQUAL(p: *Parser) bool {
27582792 return blk_0: {
27592793 const pos_0 = p.i;
2760 if (blk_1: {
2794 if (p.parseskip() and blk_1: {
27612795 if (std.mem.startsWith(u8, p.source[p.i..], "*|=")) {
27622796 p.i += 3;
27632797 break :blk_1 true;
27642798 }
27652799 break :blk_1 false;
2766 } and p.parseskip()) break :blk_0 true;
2800 }) break :blk_0 true;
27672801 p.i = pos_0;
27682802 break :blk_0 false;
27692803 };
......@@ -2771,7 +2805,7 @@ const Parser = struct {
27712805 pub fn parseCARET(p: *Parser) bool {
27722806 return blk_0: {
27732807 const pos_0 = p.i;
2774 if (blk_1: {
2808 if (p.parseskip() and blk_1: {
27752809 if (std.mem.startsWith(u8, p.source[p.i..], "^")) {
27762810 p.i += 1;
27772811 break :blk_1 true;
......@@ -2789,7 +2823,7 @@ const Parser = struct {
27892823 });
27902824 p.i = pos_1;
27912825 break :blk_1 !match_1;
2792 } and p.parseskip()) break :blk_0 true;
2826 }) break :blk_0 true;
27932827 p.i = pos_0;
27942828 break :blk_0 false;
27952829 };
......@@ -2797,13 +2831,13 @@ const Parser = struct {
27972831 pub fn parseCARETEQUAL(p: *Parser) bool {
27982832 return blk_0: {
27992833 const pos_0 = p.i;
2800 if (blk_1: {
2834 if (p.parseskip() and blk_1: {
28012835 if (std.mem.startsWith(u8, p.source[p.i..], "^=")) {
28022836 p.i += 2;
28032837 break :blk_1 true;
28042838 }
28052839 break :blk_1 false;
2806 } and p.parseskip()) break :blk_0 true;
2840 }) break :blk_0 true;
28072841 p.i = pos_0;
28082842 break :blk_0 false;
28092843 };
......@@ -2811,13 +2845,13 @@ const Parser = struct {
28112845 pub fn parseCOLON(p: *Parser) bool {
28122846 return blk_0: {
28132847 const pos_0 = p.i;
2814 if (blk_1: {
2848 if (p.parseskip() and blk_1: {
28152849 if (std.mem.startsWith(u8, p.source[p.i..], ":")) {
28162850 p.i += 1;
28172851 break :blk_1 true;
28182852 }
28192853 break :blk_1 false;
2820 } and p.parseskip()) break :blk_0 true;
2854 }) break :blk_0 true;
28212855 p.i = pos_0;
28222856 break :blk_0 false;
28232857 };
......@@ -2825,13 +2859,13 @@ const Parser = struct {
28252859 pub fn parseCOMMA(p: *Parser) bool {
28262860 return blk_0: {
28272861 const pos_0 = p.i;
2828 if (blk_1: {
2862 if (p.parseskip() and blk_1: {
28292863 if (std.mem.startsWith(u8, p.source[p.i..], ",")) {
28302864 p.i += 1;
28312865 break :blk_1 true;
28322866 }
28332867 break :blk_1 false;
2834 } and p.parseskip()) break :blk_0 true;
2868 }) break :blk_0 true;
28352869 p.i = pos_0;
28362870 break :blk_0 false;
28372871 };
......@@ -2839,7 +2873,7 @@ const Parser = struct {
28392873 pub fn parseDOT(p: *Parser) bool {
28402874 return blk_0: {
28412875 const pos_0 = p.i;
2842 if (blk_1: {
2876 if (p.parseskip() and blk_1: {
28432877 if (std.mem.startsWith(u8, p.source[p.i..], ".")) {
28442878 p.i += 1;
28452879 break :blk_1 true;
......@@ -2859,7 +2893,7 @@ const Parser = struct {
28592893 });
28602894 p.i = pos_1;
28612895 break :blk_1 !match_1;
2862 } and p.parseskip()) break :blk_0 true;
2896 }) break :blk_0 true;
28632897 p.i = pos_0;
28642898 break :blk_0 false;
28652899 };
......@@ -2867,7 +2901,7 @@ const Parser = struct {
28672901 pub fn parseDOT2(p: *Parser) bool {
28682902 return blk_0: {
28692903 const pos_0 = p.i;
2870 if (blk_1: {
2904 if (p.parseskip() and blk_1: {
28712905 if (std.mem.startsWith(u8, p.source[p.i..], "..")) {
28722906 p.i += 2;
28732907 break :blk_1 true;
......@@ -2885,7 +2919,7 @@ const Parser = struct {
28852919 });
28862920 p.i = pos_1;
28872921 break :blk_1 !match_1;
2888 } and p.parseskip()) break :blk_0 true;
2922 }) break :blk_0 true;
28892923 p.i = pos_0;
28902924 break :blk_0 false;
28912925 };
......@@ -2893,13 +2927,13 @@ const Parser = struct {
28932927 pub fn parseDOT3(p: *Parser) bool {
28942928 return blk_0: {
28952929 const pos_0 = p.i;
2896 if (blk_1: {
2930 if (p.parseskip() and blk_1: {
28972931 if (std.mem.startsWith(u8, p.source[p.i..], "...")) {
28982932 p.i += 3;
28992933 break :blk_1 true;
29002934 }
29012935 break :blk_1 false;
2902 } and p.parseskip()) break :blk_0 true;
2936 }) break :blk_0 true;
29032937 p.i = pos_0;
29042938 break :blk_0 false;
29052939 };
......@@ -2907,13 +2941,13 @@ const Parser = struct {
29072941 pub fn parseDOTASTERISK(p: *Parser) bool {
29082942 return blk_0: {
29092943 const pos_0 = p.i;
2910 if (blk_1: {
2944 if (p.parseskip() and blk_1: {
29112945 if (std.mem.startsWith(u8, p.source[p.i..], ".*")) {
29122946 p.i += 2;
29132947 break :blk_1 true;
29142948 }
29152949 break :blk_1 false;
2916 } and p.parseskip()) break :blk_0 true;
2950 }) break :blk_0 true;
29172951 p.i = pos_0;
29182952 break :blk_0 false;
29192953 };
......@@ -2921,13 +2955,13 @@ const Parser = struct {
29212955 pub fn parseDOTQUESTIONMARK(p: *Parser) bool {
29222956 return blk_0: {
29232957 const pos_0 = p.i;
2924 if (blk_1: {
2958 if (p.parseskip() and blk_1: {
29252959 if (std.mem.startsWith(u8, p.source[p.i..], ".?")) {
29262960 p.i += 2;
29272961 break :blk_1 true;
29282962 }
29292963 break :blk_1 false;
2930 } and p.parseskip()) break :blk_0 true;
2964 }) break :blk_0 true;
29312965 p.i = pos_0;
29322966 break :blk_0 false;
29332967 };
......@@ -2935,7 +2969,7 @@ const Parser = struct {
29352969 pub fn parseEQUAL(p: *Parser) bool {
29362970 return blk_0: {
29372971 const pos_0 = p.i;
2938 if (blk_1: {
2972 if (p.parseskip() and blk_1: {
29392973 if (std.mem.startsWith(u8, p.source[p.i..], "=")) {
29402974 p.i += 1;
29412975 break :blk_1 true;
......@@ -2954,7 +2988,7 @@ const Parser = struct {
29542988 });
29552989 p.i = pos_1;
29562990 break :blk_1 !match_1;
2957 } and p.parseskip()) break :blk_0 true;
2991 }) break :blk_0 true;
29582992 p.i = pos_0;
29592993 break :blk_0 false;
29602994 };
......@@ -2962,13 +2996,13 @@ const Parser = struct {
29622996 pub fn parseEQUALEQUAL(p: *Parser) bool {
29632997 return blk_0: {
29642998 const pos_0 = p.i;
2965 if (blk_1: {
2999 if (p.parseskip() and blk_1: {
29663000 if (std.mem.startsWith(u8, p.source[p.i..], "==")) {
29673001 p.i += 2;
29683002 break :blk_1 true;
29693003 }
29703004 break :blk_1 false;
2971 } and p.parseskip()) break :blk_0 true;
3005 }) break :blk_0 true;
29723006 p.i = pos_0;
29733007 break :blk_0 false;
29743008 };
......@@ -2976,13 +3010,13 @@ const Parser = struct {
29763010 pub fn parseEQUALRARROW(p: *Parser) bool {
29773011 return blk_0: {
29783012 const pos_0 = p.i;
2979 if (blk_1: {
3013 if (p.parseskip() and blk_1: {
29803014 if (std.mem.startsWith(u8, p.source[p.i..], "=>")) {
29813015 p.i += 2;
29823016 break :blk_1 true;
29833017 }
29843018 break :blk_1 false;
2985 } and p.parseskip()) break :blk_0 true;
3019 }) break :blk_0 true;
29863020 p.i = pos_0;
29873021 break :blk_0 false;
29883022 };
......@@ -2990,7 +3024,7 @@ const Parser = struct {
29903024 pub fn parseEXCLAMATIONMARK(p: *Parser) bool {
29913025 return blk_0: {
29923026 const pos_0 = p.i;
2993 if (blk_1: {
3027 if (p.parseskip() and blk_1: {
29943028 if (std.mem.startsWith(u8, p.source[p.i..], "!")) {
29953029 p.i += 1;
29963030 break :blk_1 true;
......@@ -3008,7 +3042,7 @@ const Parser = struct {
30083042 });
30093043 p.i = pos_1;
30103044 break :blk_1 !match_1;
3011 } and p.parseskip()) break :blk_0 true;
3045 }) break :blk_0 true;
30123046 p.i = pos_0;
30133047 break :blk_0 false;
30143048 };
......@@ -3016,13 +3050,13 @@ const Parser = struct {
30163050 pub fn parseEXCLAMATIONMARKEQUAL(p: *Parser) bool {
30173051 return blk_0: {
30183052 const pos_0 = p.i;
3019 if (blk_1: {
3053 if (p.parseskip() and blk_1: {
30203054 if (std.mem.startsWith(u8, p.source[p.i..], "!=")) {
30213055 p.i += 2;
30223056 break :blk_1 true;
30233057 }
30243058 break :blk_1 false;
3025 } and p.parseskip()) break :blk_0 true;
3059 }) break :blk_0 true;
30263060 p.i = pos_0;
30273061 break :blk_0 false;
30283062 };
......@@ -3030,7 +3064,7 @@ const Parser = struct {
30303064 pub fn parseLARROW(p: *Parser) bool {
30313065 return blk_0: {
30323066 const pos_0 = p.i;
3033 if (blk_1: {
3067 if (p.parseskip() and blk_1: {
30343068 if (std.mem.startsWith(u8, p.source[p.i..], "<")) {
30353069 p.i += 1;
30363070 break :blk_1 true;
......@@ -3049,7 +3083,7 @@ const Parser = struct {
30493083 });
30503084 p.i = pos_1;
30513085 break :blk_1 !match_1;
3052 } and p.parseskip()) break :blk_0 true;
3086 }) break :blk_0 true;
30533087 p.i = pos_0;
30543088 break :blk_0 false;
30553089 };
......@@ -3057,7 +3091,7 @@ const Parser = struct {
30573091 pub fn parseLARROW2(p: *Parser) bool {
30583092 return blk_0: {
30593093 const pos_0 = p.i;
3060 if (blk_1: {
3094 if (p.parseskip() and blk_1: {
30613095 if (std.mem.startsWith(u8, p.source[p.i..], "<<")) {
30623096 p.i += 2;
30633097 break :blk_1 true;
......@@ -3076,7 +3110,7 @@ const Parser = struct {
30763110 });
30773111 p.i = pos_1;
30783112 break :blk_1 !match_1;
3079 } and p.parseskip()) break :blk_0 true;
3113 }) break :blk_0 true;
30803114 p.i = pos_0;
30813115 break :blk_0 false;
30823116 };
......@@ -3084,13 +3118,13 @@ const Parser = struct {
30843118 pub fn parseLARROW2EQUAL(p: *Parser) bool {
30853119 return blk_0: {
30863120 const pos_0 = p.i;
3087 if (blk_1: {
3121 if (p.parseskip() and blk_1: {
30883122 if (std.mem.startsWith(u8, p.source[p.i..], "<<=")) {
30893123 p.i += 3;
30903124 break :blk_1 true;
30913125 }
30923126 break :blk_1 false;
3093 } and p.parseskip()) break :blk_0 true;
3127 }) break :blk_0 true;
30943128 p.i = pos_0;
30953129 break :blk_0 false;
30963130 };
......@@ -3098,7 +3132,7 @@ const Parser = struct {
30983132 pub fn parseLARROW2PIPE(p: *Parser) bool {
30993133 return blk_0: {
31003134 const pos_0 = p.i;
3101 if (blk_1: {
3135 if (p.parseskip() and blk_1: {
31023136 if (std.mem.startsWith(u8, p.source[p.i..], "<<|")) {
31033137 p.i += 3;
31043138 break :blk_1 true;
......@@ -3116,7 +3150,7 @@ const Parser = struct {
31163150 });
31173151 p.i = pos_1;
31183152 break :blk_1 !match_1;
3119 } and p.parseskip()) break :blk_0 true;
3153 }) break :blk_0 true;
31203154 p.i = pos_0;
31213155 break :blk_0 false;
31223156 };
......@@ -3124,13 +3158,13 @@ const Parser = struct {
31243158 pub fn parseLARROW2PIPEEQUAL(p: *Parser) bool {
31253159 return blk_0: {
31263160 const pos_0 = p.i;
3127 if (blk_1: {
3161 if (p.parseskip() and blk_1: {
31283162 if (std.mem.startsWith(u8, p.source[p.i..], "<<|=")) {
31293163 p.i += 4;
31303164 break :blk_1 true;
31313165 }
31323166 break :blk_1 false;
3133 } and p.parseskip()) break :blk_0 true;
3167 }) break :blk_0 true;
31343168 p.i = pos_0;
31353169 break :blk_0 false;
31363170 };
......@@ -3138,13 +3172,13 @@ const Parser = struct {
31383172 pub fn parseLARROWEQUAL(p: *Parser) bool {
31393173 return blk_0: {
31403174 const pos_0 = p.i;
3141 if (blk_1: {
3175 if (p.parseskip() and blk_1: {
31423176 if (std.mem.startsWith(u8, p.source[p.i..], "<=")) {
31433177 p.i += 2;
31443178 break :blk_1 true;
31453179 }
31463180 break :blk_1 false;
3147 } and p.parseskip()) break :blk_0 true;
3181 }) break :blk_0 true;
31483182 p.i = pos_0;
31493183 break :blk_0 false;
31503184 };
......@@ -3152,13 +3186,13 @@ const Parser = struct {
31523186 pub fn parseLBRACE(p: *Parser) bool {
31533187 return blk_0: {
31543188 const pos_0 = p.i;
3155 if (blk_1: {
3189 if (p.parseskip() and blk_1: {
31563190 if (std.mem.startsWith(u8, p.source[p.i..], "{")) {
31573191 p.i += 1;
31583192 break :blk_1 true;
31593193 }
31603194 break :blk_1 false;
3161 } and p.parseskip()) break :blk_0 true;
3195 }) break :blk_0 true;
31623196 p.i = pos_0;
31633197 break :blk_0 false;
31643198 };
......@@ -3166,13 +3200,13 @@ const Parser = struct {
31663200 pub fn parseLBRACKET(p: *Parser) bool {
31673201 return blk_0: {
31683202 const pos_0 = p.i;
3169 if (blk_1: {
3203 if (p.parseskip() and blk_1: {
31703204 if (std.mem.startsWith(u8, p.source[p.i..], "[")) {
31713205 p.i += 1;
31723206 break :blk_1 true;
31733207 }
31743208 break :blk_1 false;
3175 } and p.parseskip()) break :blk_0 true;
3209 }) break :blk_0 true;
31763210 p.i = pos_0;
31773211 break :blk_0 false;
31783212 };
......@@ -3180,13 +3214,13 @@ const Parser = struct {
31803214 pub fn parseLPAREN(p: *Parser) bool {
31813215 return blk_0: {
31823216 const pos_0 = p.i;
3183 if (blk_1: {
3217 if (p.parseskip() and blk_1: {
31843218 if (std.mem.startsWith(u8, p.source[p.i..], "(")) {
31853219 p.i += 1;
31863220 break :blk_1 true;
31873221 }
31883222 break :blk_1 false;
3189 } and p.parseskip()) break :blk_0 true;
3223 }) break :blk_0 true;
31903224 p.i = pos_0;
31913225 break :blk_0 false;
31923226 };
......@@ -3194,7 +3228,7 @@ const Parser = struct {
31943228 pub fn parseMINUS(p: *Parser) bool {
31953229 return blk_0: {
31963230 const pos_0 = p.i;
3197 if (blk_1: {
3231 if (p.parseskip() and blk_1: {
31983232 if (std.mem.startsWith(u8, p.source[p.i..], "-")) {
31993233 p.i += 1;
32003234 break :blk_1 true;
......@@ -3215,7 +3249,7 @@ const Parser = struct {
32153249 });
32163250 p.i = pos_1;
32173251 break :blk_1 !match_1;
3218 } and p.parseskip()) break :blk_0 true;
3252 }) break :blk_0 true;
32193253 p.i = pos_0;
32203254 break :blk_0 false;
32213255 };
......@@ -3223,13 +3257,13 @@ const Parser = struct {
32233257 pub fn parseMINUSEQUAL(p: *Parser) bool {
32243258 return blk_0: {
32253259 const pos_0 = p.i;
3226 if (blk_1: {
3260 if (p.parseskip() and blk_1: {
32273261 if (std.mem.startsWith(u8, p.source[p.i..], "-=")) {
32283262 p.i += 2;
32293263 break :blk_1 true;
32303264 }
32313265 break :blk_1 false;
3232 } and p.parseskip()) break :blk_0 true;
3266 }) break :blk_0 true;
32333267 p.i = pos_0;
32343268 break :blk_0 false;
32353269 };
......@@ -3237,7 +3271,7 @@ const Parser = struct {
32373271 pub fn parseMINUSPERCENT(p: *Parser) bool {
32383272 return blk_0: {
32393273 const pos_0 = p.i;
3240 if (blk_1: {
3274 if (p.parseskip() and blk_1: {
32413275 if (std.mem.startsWith(u8, p.source[p.i..], "-%")) {
32423276 p.i += 2;
32433277 break :blk_1 true;
......@@ -3255,7 +3289,7 @@ const Parser = struct {
32553289 });
32563290 p.i = pos_1;
32573291 break :blk_1 !match_1;
3258 } and p.parseskip()) break :blk_0 true;
3292 }) break :blk_0 true;
32593293 p.i = pos_0;
32603294 break :blk_0 false;
32613295 };
......@@ -3263,13 +3297,13 @@ const Parser = struct {
32633297 pub fn parseMINUSPERCENTEQUAL(p: *Parser) bool {
32643298 return blk_0: {
32653299 const pos_0 = p.i;
3266 if (blk_1: {
3300 if (p.parseskip() and blk_1: {
32673301 if (std.mem.startsWith(u8, p.source[p.i..], "-%=")) {
32683302 p.i += 3;
32693303 break :blk_1 true;
32703304 }
32713305 break :blk_1 false;
3272 } and p.parseskip()) break :blk_0 true;
3306 }) break :blk_0 true;
32733307 p.i = pos_0;
32743308 break :blk_0 false;
32753309 };
......@@ -3277,7 +3311,7 @@ const Parser = struct {
32773311 pub fn parseMINUSPIPE(p: *Parser) bool {
32783312 return blk_0: {
32793313 const pos_0 = p.i;
3280 if (blk_1: {
3314 if (p.parseskip() and blk_1: {
32813315 if (std.mem.startsWith(u8, p.source[p.i..], "-|")) {
32823316 p.i += 2;
32833317 break :blk_1 true;
......@@ -3295,7 +3329,7 @@ const Parser = struct {
32953329 });
32963330 p.i = pos_1;
32973331 break :blk_1 !match_1;
3298 } and p.parseskip()) break :blk_0 true;
3332 }) break :blk_0 true;
32993333 p.i = pos_0;
33003334 break :blk_0 false;
33013335 };
......@@ -3303,13 +3337,13 @@ const Parser = struct {
33033337 pub fn parseMINUSPIPEEQUAL(p: *Parser) bool {
33043338 return blk_0: {
33053339 const pos_0 = p.i;
3306 if (blk_1: {
3340 if (p.parseskip() and blk_1: {
33073341 if (std.mem.startsWith(u8, p.source[p.i..], "-|=")) {
33083342 p.i += 3;
33093343 break :blk_1 true;
33103344 }
33113345 break :blk_1 false;
3312 } and p.parseskip()) break :blk_0 true;
3346 }) break :blk_0 true;
33133347 p.i = pos_0;
33143348 break :blk_0 false;
33153349 };
......@@ -3317,13 +3351,13 @@ const Parser = struct {
33173351 pub fn parseMINUSRARROW(p: *Parser) bool {
33183352 return blk_0: {
33193353 const pos_0 = p.i;
3320 if (blk_1: {
3354 if (p.parseskip() and blk_1: {
33213355 if (std.mem.startsWith(u8, p.source[p.i..], "->")) {
33223356 p.i += 2;
33233357 break :blk_1 true;
33243358 }
33253359 break :blk_1 false;
3326 } and p.parseskip()) break :blk_0 true;
3360 }) break :blk_0 true;
33273361 p.i = pos_0;
33283362 break :blk_0 false;
33293363 };
......@@ -3331,7 +3365,7 @@ const Parser = struct {
33313365 pub fn parsePERCENT(p: *Parser) bool {
33323366 return blk_0: {
33333367 const pos_0 = p.i;
3334 if (blk_1: {
3368 if (p.parseskip() and blk_1: {
33353369 if (std.mem.startsWith(u8, p.source[p.i..], "%")) {
33363370 p.i += 1;
33373371 break :blk_1 true;
......@@ -3349,7 +3383,7 @@ const Parser = struct {
33493383 });
33503384 p.i = pos_1;
33513385 break :blk_1 !match_1;
3352 } and p.parseskip()) break :blk_0 true;
3386 }) break :blk_0 true;
33533387 p.i = pos_0;
33543388 break :blk_0 false;
33553389 };
......@@ -3357,13 +3391,13 @@ const Parser = struct {
33573391 pub fn parsePERCENTEQUAL(p: *Parser) bool {
33583392 return blk_0: {
33593393 const pos_0 = p.i;
3360 if (blk_1: {
3394 if (p.parseskip() and blk_1: {
33613395 if (std.mem.startsWith(u8, p.source[p.i..], "%=")) {
33623396 p.i += 2;
33633397 break :blk_1 true;
33643398 }
33653399 break :blk_1 false;
3366 } and p.parseskip()) break :blk_0 true;
3400 }) break :blk_0 true;
33673401 p.i = pos_0;
33683402 break :blk_0 false;
33693403 };
......@@ -3371,7 +3405,7 @@ const Parser = struct {
33713405 pub fn parsePIPE(p: *Parser) bool {
33723406 return blk_0: {
33733407 const pos_0 = p.i;
3374 if (blk_1: {
3408 if (p.parseskip() and blk_1: {
33753409 if (std.mem.startsWith(u8, p.source[p.i..], "|")) {
33763410 p.i += 1;
33773411 break :blk_1 true;
......@@ -3390,7 +3424,7 @@ const Parser = struct {
33903424 });
33913425 p.i = pos_1;
33923426 break :blk_1 !match_1;
3393 } and p.parseskip()) break :blk_0 true;
3427 }) break :blk_0 true;
33943428 p.i = pos_0;
33953429 break :blk_0 false;
33963430 };
......@@ -3398,13 +3432,13 @@ const Parser = struct {
33983432 pub fn parsePIPE2(p: *Parser) bool {
33993433 return blk_0: {
34003434 const pos_0 = p.i;
3401 if (blk_1: {
3435 if (p.parseskip() and blk_1: {
34023436 if (std.mem.startsWith(u8, p.source[p.i..], "||")) {
34033437 p.i += 2;
34043438 break :blk_1 true;
34053439 }
34063440 break :blk_1 false;
3407 } and p.parseskip()) break :blk_0 true;
3441 }) break :blk_0 true;
34083442 p.i = pos_0;
34093443 break :blk_0 false;
34103444 };
......@@ -3412,13 +3446,13 @@ const Parser = struct {
34123446 pub fn parsePIPEEQUAL(p: *Parser) bool {
34133447 return blk_0: {
34143448 const pos_0 = p.i;
3415 if (blk_1: {
3449 if (p.parseskip() and blk_1: {
34163450 if (std.mem.startsWith(u8, p.source[p.i..], "|=")) {
34173451 p.i += 2;
34183452 break :blk_1 true;
34193453 }
34203454 break :blk_1 false;
3421 } and p.parseskip()) break :blk_0 true;
3455 }) break :blk_0 true;
34223456 p.i = pos_0;
34233457 break :blk_0 false;
34243458 };
......@@ -3426,7 +3460,7 @@ const Parser = struct {
34263460 pub fn parsePLUS(p: *Parser) bool {
34273461 return blk_0: {
34283462 const pos_0 = p.i;
3429 if (blk_1: {
3463 if (p.parseskip() and blk_1: {
34303464 if (std.mem.startsWith(u8, p.source[p.i..], "+")) {
34313465 p.i += 1;
34323466 break :blk_1 true;
......@@ -3447,7 +3481,7 @@ const Parser = struct {
34473481 });
34483482 p.i = pos_1;
34493483 break :blk_1 !match_1;
3450 } and p.parseskip()) break :blk_0 true;
3484 }) break :blk_0 true;
34513485 p.i = pos_0;
34523486 break :blk_0 false;
34533487 };
......@@ -3455,13 +3489,13 @@ const Parser = struct {
34553489 pub fn parsePLUS2(p: *Parser) bool {
34563490 return blk_0: {
34573491 const pos_0 = p.i;
3458 if (blk_1: {
3492 if (p.parseskip() and blk_1: {
34593493 if (std.mem.startsWith(u8, p.source[p.i..], "++")) {
34603494 p.i += 2;
34613495 break :blk_1 true;
34623496 }
34633497 break :blk_1 false;
3464 } and p.parseskip()) break :blk_0 true;
3498 }) break :blk_0 true;
34653499 p.i = pos_0;
34663500 break :blk_0 false;
34673501 };
......@@ -3469,13 +3503,13 @@ const Parser = struct {
34693503 pub fn parsePLUSEQUAL(p: *Parser) bool {
34703504 return blk_0: {
34713505 const pos_0 = p.i;
3472 if (blk_1: {
3506 if (p.parseskip() and blk_1: {
34733507 if (std.mem.startsWith(u8, p.source[p.i..], "+=")) {
34743508 p.i += 2;
34753509 break :blk_1 true;
34763510 }
34773511 break :blk_1 false;
3478 } and p.parseskip()) break :blk_0 true;
3512 }) break :blk_0 true;
34793513 p.i = pos_0;
34803514 break :blk_0 false;
34813515 };
......@@ -3483,7 +3517,7 @@ const Parser = struct {
34833517 pub fn parsePLUSPERCENT(p: *Parser) bool {
34843518 return blk_0: {
34853519 const pos_0 = p.i;
3486 if (blk_1: {
3520 if (p.parseskip() and blk_1: {
34873521 if (std.mem.startsWith(u8, p.source[p.i..], "+%")) {
34883522 p.i += 2;
34893523 break :blk_1 true;
......@@ -3501,7 +3535,7 @@ const Parser = struct {
35013535 });
35023536 p.i = pos_1;
35033537 break :blk_1 !match_1;
3504 } and p.parseskip()) break :blk_0 true;
3538 }) break :blk_0 true;
35053539 p.i = pos_0;
35063540 break :blk_0 false;
35073541 };
......@@ -3509,13 +3543,13 @@ const Parser = struct {
35093543 pub fn parsePLUSPERCENTEQUAL(p: *Parser) bool {
35103544 return blk_0: {
35113545 const pos_0 = p.i;
3512 if (blk_1: {
3546 if (p.parseskip() and blk_1: {
35133547 if (std.mem.startsWith(u8, p.source[p.i..], "+%=")) {
35143548 p.i += 3;
35153549 break :blk_1 true;
35163550 }
35173551 break :blk_1 false;
3518 } and p.parseskip()) break :blk_0 true;
3552 }) break :blk_0 true;
35193553 p.i = pos_0;
35203554 break :blk_0 false;
35213555 };
......@@ -3523,7 +3557,7 @@ const Parser = struct {
35233557 pub fn parsePLUSPIPE(p: *Parser) bool {
35243558 return blk_0: {
35253559 const pos_0 = p.i;
3526 if (blk_1: {
3560 if (p.parseskip() and blk_1: {
35273561 if (std.mem.startsWith(u8, p.source[p.i..], "+|")) {
35283562 p.i += 2;
35293563 break :blk_1 true;
......@@ -3541,7 +3575,7 @@ const Parser = struct {
35413575 });
35423576 p.i = pos_1;
35433577 break :blk_1 !match_1;
3544 } and p.parseskip()) break :blk_0 true;
3578 }) break :blk_0 true;
35453579 p.i = pos_0;
35463580 break :blk_0 false;
35473581 };
......@@ -3549,13 +3583,13 @@ const Parser = struct {
35493583 pub fn parsePLUSPIPEEQUAL(p: *Parser) bool {
35503584 return blk_0: {
35513585 const pos_0 = p.i;
3552 if (blk_1: {
3586 if (p.parseskip() and blk_1: {
35533587 if (std.mem.startsWith(u8, p.source[p.i..], "+|=")) {
35543588 p.i += 3;
35553589 break :blk_1 true;
35563590 }
35573591 break :blk_1 false;
3558 } and p.parseskip()) break :blk_0 true;
3592 }) break :blk_0 true;
35593593 p.i = pos_0;
35603594 break :blk_0 false;
35613595 };
......@@ -3563,13 +3597,13 @@ const Parser = struct {
35633597 pub fn parseLETTERC(p: *Parser) bool {
35643598 return blk_0: {
35653599 const pos_0 = p.i;
3566 if (blk_1: {
3600 if (p.parseskip() and blk_1: {
35673601 if (std.mem.startsWith(u8, p.source[p.i..], "c")) {
35683602 p.i += 1;
35693603 break :blk_1 true;
35703604 }
35713605 break :blk_1 false;
3572 } and p.parseskip()) break :blk_0 true;
3606 }) break :blk_0 true;
35733607 p.i = pos_0;
35743608 break :blk_0 false;
35753609 };
......@@ -3577,13 +3611,13 @@ const Parser = struct {
35773611 pub fn parseQUESTIONMARK(p: *Parser) bool {
35783612 return blk_0: {
35793613 const pos_0 = p.i;
3580 if (blk_1: {
3614 if (p.parseskip() and blk_1: {
35813615 if (std.mem.startsWith(u8, p.source[p.i..], "?")) {
35823616 p.i += 1;
35833617 break :blk_1 true;
35843618 }
35853619 break :blk_1 false;
3586 } and p.parseskip()) break :blk_0 true;
3620 }) break :blk_0 true;
35873621 p.i = pos_0;
35883622 break :blk_0 false;
35893623 };
......@@ -3591,7 +3625,7 @@ const Parser = struct {
35913625 pub fn parseRARROW(p: *Parser) bool {
35923626 return blk_0: {
35933627 const pos_0 = p.i;
3594 if (blk_1: {
3628 if (p.parseskip() and blk_1: {
35953629 if (std.mem.startsWith(u8, p.source[p.i..], ">")) {
35963630 p.i += 1;
35973631 break :blk_1 true;
......@@ -3610,7 +3644,7 @@ const Parser = struct {
36103644 });
36113645 p.i = pos_1;
36123646 break :blk_1 !match_1;
3613 } and p.parseskip()) break :blk_0 true;
3647 }) break :blk_0 true;
36143648 p.i = pos_0;
36153649 break :blk_0 false;
36163650 };
......@@ -3618,7 +3652,7 @@ const Parser = struct {
36183652 pub fn parseRARROW2(p: *Parser) bool {
36193653 return blk_0: {
36203654 const pos_0 = p.i;
3621 if (blk_1: {
3655 if (p.parseskip() and blk_1: {
36223656 if (std.mem.startsWith(u8, p.source[p.i..], ">>")) {
36233657 p.i += 2;
36243658 break :blk_1 true;
......@@ -3636,7 +3670,7 @@ const Parser = struct {
36363670 });
36373671 p.i = pos_1;
36383672 break :blk_1 !match_1;
3639 } and p.parseskip()) break :blk_0 true;
3673 }) break :blk_0 true;
36403674 p.i = pos_0;
36413675 break :blk_0 false;
36423676 };
......@@ -3644,13 +3678,13 @@ const Parser = struct {
36443678 pub fn parseRARROW2EQUAL(p: *Parser) bool {
36453679 return blk_0: {
36463680 const pos_0 = p.i;
3647 if (blk_1: {
3681 if (p.parseskip() and blk_1: {
36483682 if (std.mem.startsWith(u8, p.source[p.i..], ">>=")) {
36493683 p.i += 3;
36503684 break :blk_1 true;
36513685 }
36523686 break :blk_1 false;
3653 } and p.parseskip()) break :blk_0 true;
3687 }) break :blk_0 true;
36543688 p.i = pos_0;
36553689 break :blk_0 false;
36563690 };
......@@ -3658,13 +3692,13 @@ const Parser = struct {
36583692 pub fn parseRARROWEQUAL(p: *Parser) bool {
36593693 return blk_0: {
36603694 const pos_0 = p.i;
3661 if (blk_1: {
3695 if (p.parseskip() and blk_1: {
36623696 if (std.mem.startsWith(u8, p.source[p.i..], ">=")) {
36633697 p.i += 2;
36643698 break :blk_1 true;
36653699 }
36663700 break :blk_1 false;
3667 } and p.parseskip()) break :blk_0 true;
3701 }) break :blk_0 true;
36683702 p.i = pos_0;
36693703 break :blk_0 false;
36703704 };
......@@ -3672,13 +3706,13 @@ const Parser = struct {
36723706 pub fn parseRBRACE(p: *Parser) bool {
36733707 return blk_0: {
36743708 const pos_0 = p.i;
3675 if (blk_1: {
3709 if (p.parseskip() and blk_1: {
36763710 if (std.mem.startsWith(u8, p.source[p.i..], "}")) {
36773711 p.i += 1;
36783712 break :blk_1 true;
36793713 }
36803714 break :blk_1 false;
3681 } and p.parseskip()) break :blk_0 true;
3715 }) break :blk_0 true;
36823716 p.i = pos_0;
36833717 break :blk_0 false;
36843718 };
......@@ -3686,13 +3720,13 @@ const Parser = struct {
36863720 pub fn parseRBRACKET(p: *Parser) bool {
36873721 return blk_0: {
36883722 const pos_0 = p.i;
3689 if (blk_1: {
3723 if (p.parseskip() and blk_1: {
36903724 if (std.mem.startsWith(u8, p.source[p.i..], "]")) {
36913725 p.i += 1;
36923726 break :blk_1 true;
36933727 }
36943728 break :blk_1 false;
3695 } and p.parseskip()) break :blk_0 true;
3729 }) break :blk_0 true;
36963730 p.i = pos_0;
36973731 break :blk_0 false;
36983732 };
......@@ -3700,13 +3734,13 @@ const Parser = struct {
37003734 pub fn parseRPAREN(p: *Parser) bool {
37013735 return blk_0: {
37023736 const pos_0 = p.i;
3703 if (blk_1: {
3737 if (p.parseskip() and blk_1: {
37043738 if (std.mem.startsWith(u8, p.source[p.i..], ")")) {
37053739 p.i += 1;
37063740 break :blk_1 true;
37073741 }
37083742 break :blk_1 false;
3709 } and p.parseskip()) break :blk_0 true;
3743 }) break :blk_0 true;
37103744 p.i = pos_0;
37113745 break :blk_0 false;
37123746 };
......@@ -3714,13 +3748,13 @@ const Parser = struct {
37143748 pub fn parseSEMICOLON(p: *Parser) bool {
37153749 return blk_0: {
37163750 const pos_0 = p.i;
3717 if (blk_1: {
3751 if (p.parseskip() and blk_1: {
37183752 if (std.mem.startsWith(u8, p.source[p.i..], ";")) {
37193753 p.i += 1;
37203754 break :blk_1 true;
37213755 }
37223756 break :blk_1 false;
3723 } and p.parseskip()) break :blk_0 true;
3757 }) break :blk_0 true;
37243758 p.i = pos_0;
37253759 break :blk_0 false;
37263760 };
......@@ -3728,7 +3762,7 @@ const Parser = struct {
37283762 pub fn parseSLASH(p: *Parser) bool {
37293763 return blk_0: {
37303764 const pos_0 = p.i;
3731 if (blk_1: {
3765 if (p.parseskip() and blk_1: {
37323766 if (std.mem.startsWith(u8, p.source[p.i..], "/")) {
37333767 p.i += 1;
37343768 break :blk_1 true;
......@@ -3746,7 +3780,7 @@ const Parser = struct {
37463780 });
37473781 p.i = pos_1;
37483782 break :blk_1 !match_1;
3749 } and p.parseskip()) break :blk_0 true;
3783 }) break :blk_0 true;
37503784 p.i = pos_0;
37513785 break :blk_0 false;
37523786 };
......@@ -3754,13 +3788,13 @@ const Parser = struct {
37543788 pub fn parseSLASHEQUAL(p: *Parser) bool {
37553789 return blk_0: {
37563790 const pos_0 = p.i;
3757 if (blk_1: {
3791 if (p.parseskip() and blk_1: {
37583792 if (std.mem.startsWith(u8, p.source[p.i..], "/=")) {
37593793 p.i += 2;
37603794 break :blk_1 true;
37613795 }
37623796 break :blk_1 false;
3763 } and p.parseskip()) break :blk_0 true;
3797 }) break :blk_0 true;
37643798 p.i = pos_0;
37653799 break :blk_0 false;
37663800 };
......@@ -3768,13 +3802,13 @@ const Parser = struct {
37683802 pub fn parseTILDE(p: *Parser) bool {
37693803 return blk_0: {
37703804 const pos_0 = p.i;
3771 if (blk_1: {
3805 if (p.parseskip() and blk_1: {
37723806 if (std.mem.startsWith(u8, p.source[p.i..], "~")) {
37733807 p.i += 1;
37743808 break :blk_1 true;
37753809 }
37763810 break :blk_1 false;
3777 } and p.parseskip()) break :blk_0 true;
3811 }) break :blk_0 true;
37783812 p.i = pos_0;
37793813 break :blk_0 false;
37803814 };
......@@ -3797,7 +3831,7 @@ const Parser = struct {
37973831 });
37983832 p.i = pos_1;
37993833 break :blk_1 !match_1;
3800 } and p.parseskip()) break :blk_0 true;
3834 }) break :blk_0 true;
38013835 p.i = pos_0;
38023836 break :blk_0 false;
38033837 };
......@@ -3805,7 +3839,7 @@ const Parser = struct {
38053839 pub fn parseKEYWORD_addrspace(p: *Parser) bool {
38063840 return blk_0: {
38073841 const pos_0 = p.i;
3808 if (blk_1: {
3842 if (p.parseskip() and blk_1: {
38093843 if (std.mem.startsWith(u8, p.source[p.i..], "addrspace")) {
38103844 p.i += 9;
38113845 break :blk_1 true;
......@@ -3819,7 +3853,7 @@ const Parser = struct {
38193853 pub fn parseKEYWORD_align(p: *Parser) bool {
38203854 return blk_0: {
38213855 const pos_0 = p.i;
3822 if (blk_1: {
3856 if (p.parseskip() and blk_1: {
38233857 if (std.mem.startsWith(u8, p.source[p.i..], "align")) {
38243858 p.i += 5;
38253859 break :blk_1 true;
......@@ -3833,7 +3867,7 @@ const Parser = struct {
38333867 pub fn parseKEYWORD_allowzero(p: *Parser) bool {
38343868 return blk_0: {
38353869 const pos_0 = p.i;
3836 if (blk_1: {
3870 if (p.parseskip() and blk_1: {
38373871 if (std.mem.startsWith(u8, p.source[p.i..], "allowzero")) {
38383872 p.i += 9;
38393873 break :blk_1 true;
......@@ -3847,7 +3881,7 @@ const Parser = struct {
38473881 pub fn parseKEYWORD_and(p: *Parser) bool {
38483882 return blk_0: {
38493883 const pos_0 = p.i;
3850 if (blk_1: {
3884 if (p.parseskip() and blk_1: {
38513885 if (std.mem.startsWith(u8, p.source[p.i..], "and")) {
38523886 p.i += 3;
38533887 break :blk_1 true;
......@@ -3861,7 +3895,7 @@ const Parser = struct {
38613895 pub fn parseKEYWORD_anyframe(p: *Parser) bool {
38623896 return blk_0: {
38633897 const pos_0 = p.i;
3864 if (blk_1: {
3898 if (p.parseskip() and blk_1: {
38653899 if (std.mem.startsWith(u8, p.source[p.i..], "anyframe")) {
38663900 p.i += 8;
38673901 break :blk_1 true;
......@@ -3875,7 +3909,7 @@ const Parser = struct {
38753909 pub fn parseKEYWORD_anytype(p: *Parser) bool {
38763910 return blk_0: {
38773911 const pos_0 = p.i;
3878 if (blk_1: {
3912 if (p.parseskip() and blk_1: {
38793913 if (std.mem.startsWith(u8, p.source[p.i..], "anytype")) {
38803914 p.i += 7;
38813915 break :blk_1 true;
......@@ -3889,7 +3923,7 @@ const Parser = struct {
38893923 pub fn parseKEYWORD_asm(p: *Parser) bool {
38903924 return blk_0: {
38913925 const pos_0 = p.i;
3892 if (blk_1: {
3926 if (p.parseskip() and blk_1: {
38933927 if (std.mem.startsWith(u8, p.source[p.i..], "asm")) {
38943928 p.i += 3;
38953929 break :blk_1 true;
......@@ -3903,7 +3937,7 @@ const Parser = struct {
39033937 pub fn parseKEYWORD_break(p: *Parser) bool {
39043938 return blk_0: {
39053939 const pos_0 = p.i;
3906 if (blk_1: {
3940 if (p.parseskip() and blk_1: {
39073941 if (std.mem.startsWith(u8, p.source[p.i..], "break")) {
39083942 p.i += 5;
39093943 break :blk_1 true;
......@@ -3917,7 +3951,7 @@ const Parser = struct {
39173951 pub fn parseKEYWORD_callconv(p: *Parser) bool {
39183952 return blk_0: {
39193953 const pos_0 = p.i;
3920 if (blk_1: {
3954 if (p.parseskip() and blk_1: {
39213955 if (std.mem.startsWith(u8, p.source[p.i..], "callconv")) {
39223956 p.i += 8;
39233957 break :blk_1 true;
......@@ -3931,7 +3965,7 @@ const Parser = struct {
39313965 pub fn parseKEYWORD_catch(p: *Parser) bool {
39323966 return blk_0: {
39333967 const pos_0 = p.i;
3934 if (blk_1: {
3968 if (p.parseskip() and blk_1: {
39353969 if (std.mem.startsWith(u8, p.source[p.i..], "catch")) {
39363970 p.i += 5;
39373971 break :blk_1 true;
......@@ -3945,7 +3979,7 @@ const Parser = struct {
39453979 pub fn parseKEYWORD_comptime(p: *Parser) bool {
39463980 return blk_0: {
39473981 const pos_0 = p.i;
3948 if (blk_1: {
3982 if (p.parseskip() and blk_1: {
39493983 if (std.mem.startsWith(u8, p.source[p.i..], "comptime")) {
39503984 p.i += 8;
39513985 break :blk_1 true;
......@@ -3959,7 +3993,7 @@ const Parser = struct {
39593993 pub fn parseKEYWORD_const(p: *Parser) bool {
39603994 return blk_0: {
39613995 const pos_0 = p.i;
3962 if (blk_1: {
3996 if (p.parseskip() and blk_1: {
39633997 if (std.mem.startsWith(u8, p.source[p.i..], "const")) {
39643998 p.i += 5;
39653999 break :blk_1 true;
......@@ -3973,7 +4007,7 @@ const Parser = struct {
39734007 pub fn parseKEYWORD_continue(p: *Parser) bool {
39744008 return blk_0: {
39754009 const pos_0 = p.i;
3976 if (blk_1: {
4010 if (p.parseskip() and blk_1: {
39774011 if (std.mem.startsWith(u8, p.source[p.i..], "continue")) {
39784012 p.i += 8;
39794013 break :blk_1 true;
......@@ -3987,7 +4021,7 @@ const Parser = struct {
39874021 pub fn parseKEYWORD_defer(p: *Parser) bool {
39884022 return blk_0: {
39894023 const pos_0 = p.i;
3990 if (blk_1: {
4024 if (p.parseskip() and blk_1: {
39914025 if (std.mem.startsWith(u8, p.source[p.i..], "defer")) {
39924026 p.i += 5;
39934027 break :blk_1 true;
......@@ -4001,7 +4035,7 @@ const Parser = struct {
40014035 pub fn parseKEYWORD_else(p: *Parser) bool {
40024036 return blk_0: {
40034037 const pos_0 = p.i;
4004 if (blk_1: {
4038 if (p.parseskip() and blk_1: {
40054039 if (std.mem.startsWith(u8, p.source[p.i..], "else")) {
40064040 p.i += 4;
40074041 break :blk_1 true;
......@@ -4015,7 +4049,7 @@ const Parser = struct {
40154049 pub fn parseKEYWORD_enum(p: *Parser) bool {
40164050 return blk_0: {
40174051 const pos_0 = p.i;
4018 if (blk_1: {
4052 if (p.parseskip() and blk_1: {
40194053 if (std.mem.startsWith(u8, p.source[p.i..], "enum")) {
40204054 p.i += 4;
40214055 break :blk_1 true;
......@@ -4029,7 +4063,7 @@ const Parser = struct {
40294063 pub fn parseKEYWORD_errdefer(p: *Parser) bool {
40304064 return blk_0: {
40314065 const pos_0 = p.i;
4032 if (blk_1: {
4066 if (p.parseskip() and blk_1: {
40334067 if (std.mem.startsWith(u8, p.source[p.i..], "errdefer")) {
40344068 p.i += 8;
40354069 break :blk_1 true;
......@@ -4043,7 +4077,7 @@ const Parser = struct {
40434077 pub fn parseKEYWORD_error(p: *Parser) bool {
40444078 return blk_0: {
40454079 const pos_0 = p.i;
4046 if (blk_1: {
4080 if (p.parseskip() and blk_1: {
40474081 if (std.mem.startsWith(u8, p.source[p.i..], "error")) {
40484082 p.i += 5;
40494083 break :blk_1 true;
......@@ -4057,7 +4091,7 @@ const Parser = struct {
40574091 pub fn parseKEYWORD_export(p: *Parser) bool {
40584092 return blk_0: {
40594093 const pos_0 = p.i;
4060 if (blk_1: {
4094 if (p.parseskip() and blk_1: {
40614095 if (std.mem.startsWith(u8, p.source[p.i..], "export")) {
40624096 p.i += 6;
40634097 break :blk_1 true;
......@@ -4071,7 +4105,7 @@ const Parser = struct {
40714105 pub fn parseKEYWORD_extern(p: *Parser) bool {
40724106 return blk_0: {
40734107 const pos_0 = p.i;
4074 if (blk_1: {
4108 if (p.parseskip() and blk_1: {
40754109 if (std.mem.startsWith(u8, p.source[p.i..], "extern")) {
40764110 p.i += 6;
40774111 break :blk_1 true;
......@@ -4085,7 +4119,7 @@ const Parser = struct {
40854119 pub fn parseKEYWORD_fn(p: *Parser) bool {
40864120 return blk_0: {
40874121 const pos_0 = p.i;
4088 if (blk_1: {
4122 if (p.parseskip() and blk_1: {
40894123 if (std.mem.startsWith(u8, p.source[p.i..], "fn")) {
40904124 p.i += 2;
40914125 break :blk_1 true;
......@@ -4099,7 +4133,7 @@ const Parser = struct {
40994133 pub fn parseKEYWORD_for(p: *Parser) bool {
41004134 return blk_0: {
41014135 const pos_0 = p.i;
4102 if (blk_1: {
4136 if (p.parseskip() and blk_1: {
41034137 if (std.mem.startsWith(u8, p.source[p.i..], "for")) {
41044138 p.i += 3;
41054139 break :blk_1 true;
......@@ -4113,7 +4147,7 @@ const Parser = struct {
41134147 pub fn parseKEYWORD_if(p: *Parser) bool {
41144148 return blk_0: {
41154149 const pos_0 = p.i;
4116 if (blk_1: {
4150 if (p.parseskip() and blk_1: {
41174151 if (std.mem.startsWith(u8, p.source[p.i..], "if")) {
41184152 p.i += 2;
41194153 break :blk_1 true;
......@@ -4127,7 +4161,7 @@ const Parser = struct {
41274161 pub fn parseKEYWORD_inline(p: *Parser) bool {
41284162 return blk_0: {
41294163 const pos_0 = p.i;
4130 if (blk_1: {
4164 if (p.parseskip() and blk_1: {
41314165 if (std.mem.startsWith(u8, p.source[p.i..], "inline")) {
41324166 p.i += 6;
41334167 break :blk_1 true;
......@@ -4141,7 +4175,7 @@ const Parser = struct {
41414175 pub fn parseKEYWORD_noalias(p: *Parser) bool {
41424176 return blk_0: {
41434177 const pos_0 = p.i;
4144 if (blk_1: {
4178 if (p.parseskip() and blk_1: {
41454179 if (std.mem.startsWith(u8, p.source[p.i..], "noalias")) {
41464180 p.i += 7;
41474181 break :blk_1 true;
......@@ -4155,7 +4189,7 @@ const Parser = struct {
41554189 pub fn parseKEYWORD_nosuspend(p: *Parser) bool {
41564190 return blk_0: {
41574191 const pos_0 = p.i;
4158 if (blk_1: {
4192 if (p.parseskip() and blk_1: {
41594193 if (std.mem.startsWith(u8, p.source[p.i..], "nosuspend")) {
41604194 p.i += 9;
41614195 break :blk_1 true;
......@@ -4169,7 +4203,7 @@ const Parser = struct {
41694203 pub fn parseKEYWORD_noinline(p: *Parser) bool {
41704204 return blk_0: {
41714205 const pos_0 = p.i;
4172 if (blk_1: {
4206 if (p.parseskip() and blk_1: {
41734207 if (std.mem.startsWith(u8, p.source[p.i..], "noinline")) {
41744208 p.i += 8;
41754209 break :blk_1 true;
......@@ -4183,7 +4217,7 @@ const Parser = struct {
41834217 pub fn parseKEYWORD_opaque(p: *Parser) bool {
41844218 return blk_0: {
41854219 const pos_0 = p.i;
4186 if (blk_1: {
4220 if (p.parseskip() and blk_1: {
41874221 if (std.mem.startsWith(u8, p.source[p.i..], "opaque")) {
41884222 p.i += 6;
41894223 break :blk_1 true;
......@@ -4197,7 +4231,7 @@ const Parser = struct {
41974231 pub fn parseKEYWORD_or(p: *Parser) bool {
41984232 return blk_0: {
41994233 const pos_0 = p.i;
4200 if (blk_1: {
4234 if (p.parseskip() and blk_1: {
42014235 if (std.mem.startsWith(u8, p.source[p.i..], "or")) {
42024236 p.i += 2;
42034237 break :blk_1 true;
......@@ -4211,7 +4245,7 @@ const Parser = struct {
42114245 pub fn parseKEYWORD_orelse(p: *Parser) bool {
42124246 return blk_0: {
42134247 const pos_0 = p.i;
4214 if (blk_1: {
4248 if (p.parseskip() and blk_1: {
42154249 if (std.mem.startsWith(u8, p.source[p.i..], "orelse")) {
42164250 p.i += 6;
42174251 break :blk_1 true;
......@@ -4225,7 +4259,7 @@ const Parser = struct {
42254259 pub fn parseKEYWORD_packed(p: *Parser) bool {
42264260 return blk_0: {
42274261 const pos_0 = p.i;
4228 if (blk_1: {
4262 if (p.parseskip() and blk_1: {
42294263 if (std.mem.startsWith(u8, p.source[p.i..], "packed")) {
42304264 p.i += 6;
42314265 break :blk_1 true;
......@@ -4239,7 +4273,7 @@ const Parser = struct {
42394273 pub fn parseKEYWORD_pub(p: *Parser) bool {
42404274 return blk_0: {
42414275 const pos_0 = p.i;
4242 if (blk_1: {
4276 if (p.parseskip() and blk_1: {
42434277 if (std.mem.startsWith(u8, p.source[p.i..], "pub")) {
42444278 p.i += 3;
42454279 break :blk_1 true;
......@@ -4253,7 +4287,7 @@ const Parser = struct {
42534287 pub fn parseKEYWORD_resume(p: *Parser) bool {
42544288 return blk_0: {
42554289 const pos_0 = p.i;
4256 if (blk_1: {
4290 if (p.parseskip() and blk_1: {
42574291 if (std.mem.startsWith(u8, p.source[p.i..], "resume")) {
42584292 p.i += 6;
42594293 break :blk_1 true;
......@@ -4267,7 +4301,7 @@ const Parser = struct {
42674301 pub fn parseKEYWORD_return(p: *Parser) bool {
42684302 return blk_0: {
42694303 const pos_0 = p.i;
4270 if (blk_1: {
4304 if (p.parseskip() and blk_1: {
42714305 if (std.mem.startsWith(u8, p.source[p.i..], "return")) {
42724306 p.i += 6;
42734307 break :blk_1 true;
......@@ -4281,7 +4315,7 @@ const Parser = struct {
42814315 pub fn parseKEYWORD_linksection(p: *Parser) bool {
42824316 return blk_0: {
42834317 const pos_0 = p.i;
4284 if (blk_1: {
4318 if (p.parseskip() and blk_1: {
42854319 if (std.mem.startsWith(u8, p.source[p.i..], "linksection")) {
42864320 p.i += 11;
42874321 break :blk_1 true;
......@@ -4295,7 +4329,7 @@ const Parser = struct {
42954329 pub fn parseKEYWORD_struct(p: *Parser) bool {
42964330 return blk_0: {
42974331 const pos_0 = p.i;
4298 if (blk_1: {
4332 if (p.parseskip() and blk_1: {
42994333 if (std.mem.startsWith(u8, p.source[p.i..], "struct")) {
43004334 p.i += 6;
43014335 break :blk_1 true;
......@@ -4309,7 +4343,7 @@ const Parser = struct {
43094343 pub fn parseKEYWORD_suspend(p: *Parser) bool {
43104344 return blk_0: {
43114345 const pos_0 = p.i;
4312 if (blk_1: {
4346 if (p.parseskip() and blk_1: {
43134347 if (std.mem.startsWith(u8, p.source[p.i..], "suspend")) {
43144348 p.i += 7;
43154349 break :blk_1 true;
......@@ -4323,7 +4357,7 @@ const Parser = struct {
43234357 pub fn parseKEYWORD_switch(p: *Parser) bool {
43244358 return blk_0: {
43254359 const pos_0 = p.i;
4326 if (blk_1: {
4360 if (p.parseskip() and blk_1: {
43274361 if (std.mem.startsWith(u8, p.source[p.i..], "switch")) {
43284362 p.i += 6;
43294363 break :blk_1 true;
......@@ -4337,7 +4371,7 @@ const Parser = struct {
43374371 pub fn parseKEYWORD_test(p: *Parser) bool {
43384372 return blk_0: {
43394373 const pos_0 = p.i;
4340 if (blk_1: {
4374 if (p.parseskip() and blk_1: {
43414375 if (std.mem.startsWith(u8, p.source[p.i..], "test")) {
43424376 p.i += 4;
43434377 break :blk_1 true;
......@@ -4351,7 +4385,7 @@ const Parser = struct {
43514385 pub fn parseKEYWORD_threadlocal(p: *Parser) bool {
43524386 return blk_0: {
43534387 const pos_0 = p.i;
4354 if (blk_1: {
4388 if (p.parseskip() and blk_1: {
43554389 if (std.mem.startsWith(u8, p.source[p.i..], "threadlocal")) {
43564390 p.i += 11;
43574391 break :blk_1 true;
......@@ -4365,7 +4399,7 @@ const Parser = struct {
43654399 pub fn parseKEYWORD_try(p: *Parser) bool {
43664400 return blk_0: {
43674401 const pos_0 = p.i;
4368 if (blk_1: {
4402 if (p.parseskip() and blk_1: {
43694403 if (std.mem.startsWith(u8, p.source[p.i..], "try")) {
43704404 p.i += 3;
43714405 break :blk_1 true;
......@@ -4379,7 +4413,7 @@ const Parser = struct {
43794413 pub fn parseKEYWORD_union(p: *Parser) bool {
43804414 return blk_0: {
43814415 const pos_0 = p.i;
4382 if (blk_1: {
4416 if (p.parseskip() and blk_1: {
43834417 if (std.mem.startsWith(u8, p.source[p.i..], "union")) {
43844418 p.i += 5;
43854419 break :blk_1 true;
......@@ -4393,7 +4427,7 @@ const Parser = struct {
43934427 pub fn parseKEYWORD_unreachable(p: *Parser) bool {
43944428 return blk_0: {
43954429 const pos_0 = p.i;
4396 if (blk_1: {
4430 if (p.parseskip() and blk_1: {
43974431 if (std.mem.startsWith(u8, p.source[p.i..], "unreachable")) {
43984432 p.i += 11;
43994433 break :blk_1 true;
......@@ -4407,7 +4441,7 @@ const Parser = struct {
44074441 pub fn parseKEYWORD_var(p: *Parser) bool {
44084442 return blk_0: {
44094443 const pos_0 = p.i;
4410 if (blk_1: {
4444 if (p.parseskip() and blk_1: {
44114445 if (std.mem.startsWith(u8, p.source[p.i..], "var")) {
44124446 p.i += 3;
44134447 break :blk_1 true;
......@@ -4421,7 +4455,7 @@ const Parser = struct {
44214455 pub fn parseKEYWORD_volatile(p: *Parser) bool {
44224456 return blk_0: {
44234457 const pos_0 = p.i;
4424 if (blk_1: {
4458 if (p.parseskip() and blk_1: {
44254459 if (std.mem.startsWith(u8, p.source[p.i..], "volatile")) {
44264460 p.i += 8;
44274461 break :blk_1 true;
......@@ -4435,7 +4469,7 @@ const Parser = struct {
44354469 pub fn parseKEYWORD_while(p: *Parser) bool {
44364470 return blk_0: {
44374471 const pos_0 = p.i;
4438 if (blk_1: {
4472 if (p.parseskip() and blk_1: {
44394473 if (std.mem.startsWith(u8, p.source[p.i..], "while")) {
44404474 p.i += 5;
44414475 break :blk_1 true;