authorgravatar for mail@isaacfreund.comIsaac Freund <mail@isaacfreund.com> 2026-07-09 12:22:54+02:00
committergravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2026-07-09 21:05:03+02:00
logebaa801cdcaf3fd480b4fe6f87136d8ef3a5a0d7
treea991ba585114801cbd457cc2f59a1561335a35cb
parent01b60634c7edecfd4757e12bc5f3b265a2959761

parser: delete consistently out-of-sync comments

We have collectively proved more-or-less incapable of keeping these grammar snippet comments in sync with the canonical grammar. I believe that without automation of some kind this situation will not meaningfully improve, and that the complexity cost of automation for this purpose would outweigh the benefits. Therefore, simply delete them to avoid confusion and clarify the single source of truth for the formal grammar.

1 files changed, 0 insertions(+), 266 deletions(-)

lib/std/zig/Parse.zig-266
......@@ -261,11 +261,6 @@ pub fn parseZon(p: *Parse) Allocator.Error!void {
261261 p.nodes.items(.data)[0] = .{ .node = node_index };
262262}
263263
264/// ContainerMembers <- container_doc_comment? ContainerDeclaration* (ContainerField COMMA)* (ContainerField / ContainerDeclaration*)
265///
266/// ContainerDeclaration <- TestDecl / ComptimeDecl / doc_comment? KEYWORD_pub? Decl
267///
268/// ComptimeDecl <- KEYWORD_comptime Block
269264fn parseContainerMembers(p: *Parse) Error!Members {
270265 const scratch_top = p.scratch.items.len;
271266 defer p.scratch.shrinkRetainingCapacity(scratch_top);
......@@ -613,7 +608,6 @@ fn findNextStmt(p: *Parse) void {
613608 }
614609}
615610
616/// TestDecl <- KEYWORD_test (STRINGLITERALSINGLE / IDENTIFIER)? Block
617611fn expectTestDecl(p: *Parse) Error!Node.Index {
618612 const test_token = p.assertToken(.keyword_test);
619613 const name_token: OptionalTokenIndex = switch (p.tokenTag(p.tok_i)) {
......@@ -643,10 +637,6 @@ fn expectTestDeclRecoverable(p: *Parse) error{OutOfMemory}!?Node.Index {
643637 }
644638}
645639
646/// Decl
647/// <- (KEYWORD_export / KEYWORD_inline / KEYWORD_noinline)? FnProto (SEMICOLON / Block)
648/// / KEYWORD_extern STRINGLITERALSINGLE? FnProto SEMICOLON
649/// / (KEYWORD_export / KEYWORD_extern STRINGLITERALSINGLE?)? KEYWORD_threadlocal? VarDecl
650640fn expectTopLevelDecl(p: *Parse) !?Node.Index {
651641 const extern_export_inline_token = p.nextToken();
652642 var is_extern: bool = false;
......@@ -722,7 +712,6 @@ fn expectTopLevelDeclRecoverable(p: *Parse) error{OutOfMemory}!?Node.Index {
722712 };
723713}
724714
725/// FnProto <- KEYWORD_fn IDENTIFIER? LPAREN ParamDeclList RPAREN ByteAlign? AddrSpace? LinkSection? CallConv? EXCLAMATIONMARK? TypeExpr !ExprSuffix
726715fn parseFnProto(p: *Parse) !?Node.Index {
727716 const fn_token = p.eatToken(.keyword_fn) orelse return null;
728717
......@@ -815,7 +804,6 @@ fn setVarDeclInitExpr(p: *Parse, var_decl: Node.Index, init_expr: Node.OptionalI
815804 init_expr_result.* = init_expr;
816805}
817806
818/// VarDeclProto <- (KEYWORD_const / KEYWORD_var) IDENTIFIER (COLON TypeExpr)? ByteAlign? AddrSpace? LinkSection?
819807/// Returns a `*_var_decl` node with its rhs (init expression) initialized to .none.
820808fn parseVarDeclProto(p: *Parse) !?Node.Index {
821809 const mut_token = p.eatToken(.keyword_const) orelse
......@@ -887,7 +875,6 @@ fn parseVarDeclProto(p: *Parse) !?Node.Index {
887875 }
888876}
889877
890/// GlobalVarDecl <- VarDeclProto (EQUAL Expr?) SEMICOLON
891878fn parseGlobalVarDecl(p: *Parse) !?Node.Index {
892879 const var_decl = try p.parseVarDeclProto() orelse return null;
893880
......@@ -910,7 +897,6 @@ fn parseGlobalVarDecl(p: *Parse) !?Node.Index {
910897 return var_decl;
911898}
912899
913// ContainerField <- doc_comment? KEYWORD_comptime? (IDENTIFIER COLON)? TypeExpr ByteAlign? (EQUAL Expr)?
914900fn expectContainerField(p: *Parse) !Node.Index {
915901 _ = p.eatToken(.keyword_comptime);
916902 const main_token = p.tok_i;
......@@ -952,25 +938,6 @@ fn expectContainerField(p: *Parse) !Node.Index {
952938 }
953939}
954940
955/// BlockStatement
956/// <- Statement
957/// / KEYWORD_defer BlockExprStatement
958/// / KEYWORD_errdefer BlockExprStatement
959/// / !StatementPrefix KEYWORD_comptime? VarAssignStatement
960///
961/// Statement
962/// <- IfStatement
963/// / LabeledStatement
964/// / KEYWORD_nosuspend BlockExprStatement
965/// / KEYWORD_comptime BlockExpr
966/// / KEYWORD_suspend BlockExprStatement
967/// / !StatementPrefix KEYWORD_comptime? AssignExpr SEMICOLON
968///
969/// StatementPrefix
970/// <- KEYWORD_if
971/// / BlockLabel? (LBRACE / KEYWORD_inline? (KEYWORD_for / KEYWORD_while) / KEYWORD_switch)
972/// / KEYWORD_nosuspend
973/// / KEYWORD_comptime BlockExprPrefix
974941fn expectStatement(p: *Parse, is_block_level: bool) Error!Node.Index {
975942 if (p.eatToken(.keyword_comptime)) |comptime_token| {
976943 const opt_block_expr = try p.parseBlockExpr();
......@@ -1052,7 +1019,6 @@ fn expectStatement(p: *Parse, is_block_level: bool) Error!Node.Index {
10521019 }
10531020}
10541021
1055/// VarAssignStatement <- (VarDeclProto / Expr) (COMMA (VarDeclProto / Expr))* EQUAL Expr SEMICOLON
10561022fn expectVarAssignStatement(p: *Parse, comptime_token: ?TokenIndex) !Node.Index {
10571023 const scratch_top = p.scratch.items.len;
10581024 defer p.scratch.shrinkRetainingCapacity(scratch_top);
......@@ -1182,11 +1148,6 @@ fn expectStatementRecoverable(p: *Parse) Error!?Node.Index {
11821148 }
11831149}
11841150
1185/// IfStatement
1186/// <- IfPrefix BlockExpr (KEYWORD_else Payload? Statement / !KEYWORD_else)
1187/// / IfPrefix !BlockExprPrefix AssignExpr (SEMICOLON / KEYWORD_else Payload? Statement)
1188///
1189/// IfPrefix <- KEYWORD_if LPAREN Expr RPAREN PtrPayload?
11901151fn expectIfStatement(p: *Parse) !Node.Index {
11911152 const if_token = p.assertToken(.keyword_if);
11921153 _ = try p.expectToken(.l_paren);
......@@ -1244,7 +1205,6 @@ fn expectIfStatement(p: *Parse) !Node.Index {
12441205 });
12451206}
12461207
1247/// LabeledStatement <- BlockLabel? (Block / LoopStatement / SwitchExpr)
12481208fn parseLabeledStatement(p: *Parse) !?Node.Index {
12491209 const opt_label_token = p.parseBlockLabel();
12501210
......@@ -1271,7 +1231,6 @@ fn parseLabeledStatement(p: *Parse) !?Node.Index {
12711231 return p.failMsg(.{ .tag = .expected_labelable, .token = after_colon });
12721232}
12731233
1274/// LoopStatement <- KEYWORD_inline? (ForStatement / WhileStatement)
12751234fn parseLoopStatement(p: *Parse) !?Node.Index {
12761235 const inline_token = p.eatToken(.keyword_inline);
12771236
......@@ -1284,9 +1243,6 @@ fn parseLoopStatement(p: *Parse) !?Node.Index {
12841243 return p.fail(.expected_inlinable);
12851244}
12861245
1287/// ForStatement
1288/// <- ForPrefix BlockExpr (KEYWORD_else Statement / !KEYWORD_else)
1289/// / ForPrefix !BlockExprPrefix AssignExpr (SEMICOLON / KEYWORD_else Statement)
12901246fn parseForStatement(p: *Parse) !?Node.Index {
12911247 const for_token = p.eatToken(.keyword_for) orelse return null;
12921248
......@@ -1339,11 +1295,6 @@ fn parseForStatement(p: *Parse) !?Node.Index {
13391295 });
13401296}
13411297
1342/// WhilePrefix <- KEYWORD_while LPAREN Expr RPAREN PtrPayload? WhileContinueExpr?
1343///
1344/// WhileStatement
1345/// <- WhilePrefix BlockExpr (KEYWORD_else Payload? Statement / !KEYWORD_else)
1346/// / WhilePrefix !BlockExprPrefix AssignExpr (SEMICOLON / KEYWORD_else Payload? Statement)
13471298fn parseWhileStatement(p: *Parse) !?Node.Index {
13481299 const while_token = p.eatToken(.keyword_while) orelse return null;
13491300 _ = try p.expectToken(.l_paren);
......@@ -1431,9 +1382,6 @@ fn parseWhileStatement(p: *Parse) !?Node.Index {
14311382 });
14321383}
14331384
1434/// BlockExprStatement
1435/// <- BlockExpr
1436/// / !BlockExprPrefix AssignExpr SEMICOLON
14371385fn parseBlockExprStatement(p: *Parse) !?Node.Index {
14381386 const block_expr = try p.parseBlockExpr();
14391387 if (block_expr) |expr| return expr;
......@@ -1449,7 +1397,6 @@ fn expectBlockExprStatement(p: *Parse) !Node.Index {
14491397 return try p.parseBlockExprStatement() orelse return p.fail(.expected_block_or_expr);
14501398}
14511399
1452/// BlockExpr <- BlockLabel? Block
14531400fn parseBlockExpr(p: *Parse) Error!?Node.Index {
14541401 switch (p.tokenTag(p.tok_i)) {
14551402 .identifier => {
......@@ -1467,33 +1414,11 @@ fn parseBlockExpr(p: *Parse) Error!?Node.Index {
14671414 }
14681415}
14691416
1470/// AssignExpr <- Expr (AssignOp Expr / (COMMA Expr)+ EQUAL Expr / !AssignOp !COMMA)
1471///
1472/// AssignOp
1473/// <- ASTERISKEQUAL
1474/// / ASTERISKPIPEEQUAL
1475/// / SLASHEQUAL
1476/// / PERCENTEQUAL
1477/// / PLUSEQUAL
1478/// / PLUSPIPEEQUAL
1479/// / MINUSEQUAL
1480/// / MINUSPIPEEQUAL
1481/// / LARROW2EQUAL
1482/// / LARROW2PIPEEQUAL
1483/// / RARROW2EQUAL
1484/// / AMPERSANDEQUAL
1485/// / CARETEQUAL
1486/// / PIPEEQUAL
1487/// / ASTERISKPERCENTEQUAL
1488/// / PLUSPERCENTEQUAL
1489/// / MINUSPERCENTEQUAL
1490/// / EQUAL
14911417fn parseAssignExpr(p: *Parse) !?Node.Index {
14921418 const expr = try p.parseExpr() orelse return null;
14931419 return try p.finishAssignExpr(expr);
14941420}
14951421
1496/// SingleAssignExpr <- Expr (AssignOp Expr / !AssignOp)
14971422fn parseSingleAssignExpr(p: *Parse) !?Node.Index {
14981423 const lhs = try p.parseExpr() orelse return null;
14991424 const tag = assignOpNode(p.tokenTag(p.tok_i)) orelse return lhs;
......@@ -1708,15 +1633,6 @@ fn parseExprPrecedence(p: *Parse, min_prec: i32) Error!?Node.Index {
17081633 return node;
17091634}
17101635
1711/// PrefixExpr <- PrefixOp* PrimaryExpr / !PrefixOp
1712///
1713/// PrefixOp
1714/// <- EXCLAMATIONMARK
1715/// / MINUS
1716/// / TILDE
1717/// / MINUSPERCENT
1718/// / AMPERSAND
1719/// / KEYWORD_try
17201636fn parsePrefixExpr(p: *Parse) Error!?Node.Index {
17211637 const tag: Node.Tag = switch (p.tokenTag(p.tok_i)) {
17221638 .bang => .bool_not,
......@@ -1738,28 +1654,6 @@ fn expectPrefixExpr(p: *Parse) Error!Node.Index {
17381654 return try p.parsePrefixExpr() orelse return p.fail(.expected_prefix_expr);
17391655}
17401656
1741/// TypeExpr <- PrefixTypeOp* !PrefixTypeOpPrefix ErrorUnionExpr
1742///
1743/// PrefixTypeOp
1744/// <- QUESTIONMARK
1745/// / KEYWORD_anyframe MINUSRARROW
1746/// / (ManyPtrTypeStart / SliceTypeStart) PtrMods
1747/// / SinglePtrTypeStart SinglePtrMods
1748/// / ArrayTypeStart
1749///
1750/// PrefixTypeOpPrefix
1751/// <- QUESTIONMARK
1752/// / KEYWORD_anyframe MINUSRARROW
1753/// / LBRACKET
1754/// / ASTERISK
1755///
1756/// SliceTypeStart <- LBRACKET (COLON Expr)? RBRACKET
1757///
1758/// SinglePtrTypeStart <- ASTERISK
1759///
1760/// ManyPtrTypeStart <- LBRACKET ASTERISK (LETTERC / COLON Expr)? RBRACKET
1761///
1762/// ArrayTypeStart <- LBRACKET !ASTERISK Expr (COLON Expr)? RBRACKET
17631657fn parseTypeExpr(p: *Parse) Error!?Node.Index {
17641658 switch (p.tokenTag(p.tok_i)) {
17651659 .question_mark => return try p.addNode(.{
......@@ -1957,18 +1851,6 @@ fn expectTypeExpr(p: *Parse) Error!Node.Index {
19571851 return try p.parseTypeExpr() orelse return p.fail(.expected_type_expr);
19581852}
19591853
1960/// PrimaryExpr
1961/// <- AsmExpr
1962/// / IfExpr
1963/// / KEYWORD_break BreakLabel? Expr?
1964/// / KEYWORD_comptime Expr
1965/// / KEYWORD_nosuspend Expr
1966/// / KEYWORD_continue BreakLabel? Expr?
1967/// / KEYWORD_resume Expr
1968/// / KEYWORD_return Expr?
1969/// / BlockLabel? LoopExpr
1970/// / Block
1971/// / CurlySuffixExpr
19721854fn parsePrimaryExpr(p: *Parse) !?Node.Index {
19731855 switch (p.tokenTag(p.tok_i)) {
19741856 .keyword_asm => return try p.expectAsmExpr(),
......@@ -2061,7 +1943,6 @@ fn parsePrimaryExpr(p: *Parse) !?Node.Index {
20611943 }
20621944}
20631945
2064/// Block <- LBRACE BlockStatement* RBRACE
20651946fn parseBlock(p: *Parse) !?Node.Index {
20661947 const lbrace = p.eatToken(.l_brace) orelse return null;
20671948 const scratch_top = p.scratch.items.len;
......@@ -2092,11 +1973,6 @@ fn parseBlock(p: *Parse) !?Node.Index {
20921973 }
20931974}
20941975
2095/// ForPrefix <- KEYWORD_for LPAREN ForInput (COMMA ForInput)* COMMA? RPAREN ForPayload
2096///
2097/// ForInput <- Expr (DOT2 Expr?)?
2098///
2099/// ForPayload <- PIPE ASTERISK? IDENTIFIER (COMMA ASTERISK? IDENTIFIER)* PIPE
21001976fn forPrefix(p: *Parse) Error!usize {
21011977 const start = p.scratch.items.len;
21021978 _ = try p.expectToken(.l_paren);
......@@ -2152,9 +2028,6 @@ fn forPrefix(p: *Parse) Error!usize {
21522028 return inputs;
21532029}
21542030
2155/// WhilePrefix <- KEYWORD_while LPAREN Expr RPAREN PtrPayload? WhileContinueExpr?
2156///
2157/// WhileExpr <- WhilePrefix Expr (KEYWORD_else Payload? Expr)? !ExprSuffi
21582031fn expectWhileExpr(p: *Parse) !Node.Index {
21592032 const while_token = p.assertToken(.keyword_while);
21602033 _ = try p.expectToken(.l_paren);
......@@ -2204,12 +2077,6 @@ fn expectWhileExpr(p: *Parse) !Node.Index {
22042077 });
22052078}
22062079
2207/// CurlySuffixExpr <- TypeExpr (InitList / !LBRACE)
2208///
2209/// InitList
2210/// <- LBRACE FieldInit (COMMA FieldInit)* COMMA? RBRACE
2211/// / LBRACE Expr (COMMA Expr)* COMMA? RBRACE
2212/// / LBRACE RBRACE
22132080fn parseCurlySuffixExpr(p: *Parse) !?Node.Index {
22142081 const lhs = try p.parseTypeExpr() orelse return null;
22152082 const lbrace = p.eatToken(.l_brace) orelse return lhs;
......@@ -2306,7 +2173,6 @@ fn parseCurlySuffixExpr(p: *Parse) !?Node.Index {
23062173 }
23072174}
23082175
2309/// ErrorUnionExpr <- SuffixExpr (EXCLAMATIONMARK TypeExpr / !EXCLAMATIONMARK)
23102176fn parseErrorUnionExpr(p: *Parse) !?Node.Index {
23112177 const suffix_expr = try p.parseSuffixExpr() orelse return null;
23122178 const bang = p.eatToken(.bang) orelse return suffix_expr;
......@@ -2320,7 +2186,6 @@ fn parseErrorUnionExpr(p: *Parse) !?Node.Index {
23202186 });
23212187}
23222188
2323/// SuffixExpr <- PrimaryTypeExpr SuffixOp* !SuffixOpPrefix
23242189fn parseSuffixExpr(p: *Parse) !?Node.Index {
23252190 var res = try p.parsePrimaryTypeExpr() orelse return null;
23262191 while (try p.parseSuffixOp(res)) |suffix_op| {
......@@ -2329,46 +2194,6 @@ fn parseSuffixExpr(p: *Parse) !?Node.Index {
23292194 return res;
23302195}
23312196
2332/// PrimaryTypeExpr
2333/// <- BUILTINIDENTIFIER FnCallArguments
2334/// / CHAR_LITERAL
2335/// / ContainerDecl
2336/// / DOT IDENTIFIER
2337/// / DOT InitList
2338/// / ErrorSetDecl
2339/// / FnProto
2340/// / GroupedExpr
2341/// / LabeledTypeExpr
2342/// / IDENTIFIER
2343/// / IfTypeExpr
2344/// / KEYWORD_comptime TypeExpr
2345/// / KEYWORD_error DOT IDENTIFIER
2346/// / KEYWORD_anyframe
2347/// / KEYWORD_unreachable
2348/// / NUMBERLITERAL
2349/// / STRINGLITERAL
2350///
2351/// ContainerDecl <- (KEYWORD_extern / KEYWORD_packed)? ContainerDeclAuto
2352///
2353/// ContainerDeclAuto <- ContainerDeclType LBRACE ContainerMembers RBRACE
2354///
2355/// InitList
2356/// <- LBRACE FieldInit (COMMA FieldInit)* COMMA? RBRACE
2357/// / LBRACE Expr (COMMA Expr)* COMMA? RBRACE
2358/// / LBRACE RBRACE
2359///
2360/// ErrorSetDecl <- KEYWORD_error LBRACE IdentifierList RBRACE
2361///
2362/// GroupedExpr <- LPAREN Expr RPAREN
2363///
2364/// IfTypeExpr <- IfPrefix TypeExpr (KEYWORD_else Payload? TypeExpr)? !ExprSuffix
2365///
2366/// LabeledTypeExpr
2367/// <- BlockLabel Block
2368/// / BlockLabel? LoopTypeExpr
2369/// / BlockLabel? SwitchExpr
2370///
2371/// LoopTypeExpr <- KEYWORD_inline? (ForTypeExpr / WhileTypeExpr)
23722197fn parsePrimaryTypeExpr(p: *Parse) !?Node.Index {
23732198 switch (p.tokenTag(p.tok_i)) {
23742199 .char_literal => return try p.addNode(.{
......@@ -2637,9 +2462,6 @@ fn expectPrimaryTypeExpr(p: *Parse) !Node.Index {
26372462 return try p.parsePrimaryTypeExpr() orelse return p.fail(.expected_primary_type_expr);
26382463}
26392464
2640/// WhilePrefix <- KEYWORD_while LPAREN Expr RPAREN PtrPayload? WhileContinueExpr?
2641///
2642/// WhileTypeExpr <- WhilePrefix TypeExpr (KEYWORD_else Payload? TypeExpr / !KEYWORD_else)
26432465fn expectWhileTypeExpr(p: *Parse) !Node.Index {
26442466 const while_token = p.assertToken(.keyword_while);
26452467 _ = try p.expectToken(.l_paren);
......@@ -2689,7 +2511,6 @@ fn expectWhileTypeExpr(p: *Parse) !Node.Index {
26892511 });
26902512}
26912513
2692/// SwitchExpr <- KEYWORD_switch LPAREN Expr RPAREN LBRACE SwitchProngList RBRACE
26932514fn parseSwitchExpr(p: *Parse, is_labeled: bool) !?Node.Index {
26942515 const switch_token = p.eatToken(.keyword_switch) orelse return null;
26952516 return try p.expectSwitchSuffix(if (is_labeled) switch_token - 2 else switch_token);
......@@ -2722,19 +2543,6 @@ fn expectSwitchSuffix(p: *Parse, main_token: TokenIndex) !Node.Index {
27222543 });
27232544}
27242545
2725/// AsmExpr <- KEYWORD_asm KEYWORD_volatile? LPAREN Expr AsmOutput? RPAREN
2726///
2727/// AsmOutput <- COLON AsmOutputList AsmInput?
2728///
2729/// AsmInput <- COLON AsmInputList AsmClobbers?
2730///
2731/// AsmClobbers <- COLON Expr
2732///
2733/// StringList <- (STRINGLITERAL COMMA)* STRINGLITERAL?
2734///
2735/// AsmOutputList <- (AsmOutputItem COMMA)* AsmOutputItem?
2736///
2737/// AsmInputList <- (AsmInputItem COMMA)* AsmInputItem?
27382546fn expectAsmExpr(p: *Parse) !Node.Index {
27392547 const asm_token = p.assertToken(.keyword_asm);
27402548 _ = p.eatToken(.keyword_volatile);
......@@ -2804,7 +2612,6 @@ fn expectAsmExpr(p: *Parse) !Node.Index {
28042612 });
28052613}
28062614
2807/// AsmOutputItem <- LBRACKET IDENTIFIER RBRACKET STRINGLITERALSINGLE LPAREN (MINUSRARROW TypeExpr / IDENTIFIER) RPAREN
28082615fn parseAsmOutputItem(p: *Parse) !?Node.Index {
28092616 _ = p.eatToken(.l_bracket) orelse return null;
28102617 const identifier = try p.expectToken(.identifier);
......@@ -2830,7 +2637,6 @@ fn parseAsmOutputItem(p: *Parse) !?Node.Index {
28302637 });
28312638}
28322639
2833/// AsmInputItem <- LBRACKET IDENTIFIER RBRACKET STRINGLITERALSINGLE LPAREN Expr RPAREN
28342640fn parseAsmInputItem(p: *Parse) !?Node.Index {
28352641 _ = p.eatToken(.l_bracket) orelse return null;
28362642 const identifier = try p.expectToken(.identifier);
......@@ -2849,17 +2655,14 @@ fn parseAsmInputItem(p: *Parse) !?Node.Index {
28492655 });
28502656}
28512657
2852/// BreakLabel <- COLON IDENTIFIER
28532658fn parseBreakLabel(p: *Parse) Error!OptionalTokenIndex {
28542659 return if (p.eatTokens(&.{ .colon, .identifier })) |i| .fromToken(i + 1) else .none;
28552660}
28562661
2857/// BlockLabel <- IDENTIFIER COLON
28582662fn parseBlockLabel(p: *Parse) ?TokenIndex {
28592663 return p.eatTokens(&.{ .identifier, .colon });
28602664}
28612665
2862/// FieldInit <- DOT IDENTIFIER EQUAL Expr
28632666fn parseFieldInit(p: *Parse) !?Node.Index {
28642667 if (p.eatTokens(&.{ .period, .identifier, .equal })) |_| {
28652668 return try p.expectExpr();
......@@ -2874,7 +2677,6 @@ fn expectFieldInit(p: *Parse) !Node.Index {
28742677 return p.fail(.expected_initializer);
28752678}
28762679
2877/// WhileContinueExpr <- COLON LPAREN AssignExpr RPAREN
28782680fn parseWhileContinueExpr(p: *Parse) !?Node.Index {
28792681 _ = p.eatToken(.colon) orelse return null;
28802682 _ = try p.expectToken(.l_paren);
......@@ -2883,7 +2685,6 @@ fn parseWhileContinueExpr(p: *Parse) !?Node.Index {
28832685 return node;
28842686}
28852687
2886/// LinkSection <- KEYWORD_linksection LPAREN Expr RPAREN
28872688fn parseLinkSection(p: *Parse) !?Node.Index {
28882689 _ = p.eatToken(.keyword_linksection) orelse return null;
28892690 _ = try p.expectToken(.l_paren);
......@@ -2892,7 +2693,6 @@ fn parseLinkSection(p: *Parse) !?Node.Index {
28922693 return expr_node;
28932694}
28942695
2895/// CallConv <- KEYWORD_callconv LPAREN Expr RPAREN
28962696fn parseCallconv(p: *Parse) !?Node.Index {
28972697 _ = p.eatToken(.keyword_callconv) orelse return null;
28982698 _ = try p.expectToken(.l_paren);
......@@ -2901,7 +2701,6 @@ fn parseCallconv(p: *Parse) !?Node.Index {
29012701 return expr_node;
29022702}
29032703
2904/// AddrSpace <- KEYWORD_addrspace LPAREN Expr RPAREN
29052704fn parseAddrSpace(p: *Parse) !?Node.Index {
29062705 _ = p.eatToken(.keyword_addrspace) orelse return null;
29072706 _ = try p.expectToken(.l_paren);
......@@ -2913,12 +2712,6 @@ fn parseAddrSpace(p: *Parse) !?Node.Index {
29132712/// This function can return null nodes and then still return nodes afterwards,
29142713/// such as in the case of anytype and `...`. Caller must look for rparen to find
29152714/// out when there are no more param decls left.
2916///
2917/// ParamDecl <- doc_comment? (KEYWORD_noalias / KEYWORD_comptime / !KEYWORD_comptime) (IDENTIFIER COLON / !(IDENTIFIER COLON)) ParamType
2918///
2919/// ParamType
2920/// <- KEYWORD_anytype
2921/// / TypeExpr
29222715fn expectParamDecl(p: *Parse) !?Node.Index {
29232716 _ = try p.eatDocComments();
29242717 switch (p.tokenTag(p.tok_i)) {
......@@ -2937,7 +2730,6 @@ fn expectParamDecl(p: *Parse) !?Node.Index {
29372730 }
29382731}
29392732
2940/// Payload <- PIPE IDENTIFIER PIPE
29412733fn parsePayload(p: *Parse) Error!OptionalTokenIndex {
29422734 _ = p.eatToken(.pipe) orelse return .none;
29432735 const identifier = try p.expectToken(.identifier);
......@@ -2945,7 +2737,6 @@ fn parsePayload(p: *Parse) Error!OptionalTokenIndex {
29452737 return .fromToken(identifier);
29462738}
29472739
2948/// PtrPayload <- PIPE ASTERISK? IDENTIFIER PIPE
29492740fn parsePtrPayload(p: *Parse) Error!OptionalTokenIndex {
29502741 _ = p.eatToken(.pipe) orelse return .none;
29512742 _ = p.eatToken(.asterisk);
......@@ -2955,8 +2746,6 @@ fn parsePtrPayload(p: *Parse) Error!OptionalTokenIndex {
29552746}
29562747
29572748/// Returns the first identifier token, if any.
2958///
2959/// PtrIndexPayload <- PIPE ASTERISK? IDENTIFIER (COMMA IDENTIFIER)? PIPE
29602749fn parsePtrIndexPayload(p: *Parse) Error!OptionalTokenIndex {
29612750 _ = p.eatToken(.pipe) orelse return .none;
29622751 _ = p.eatToken(.asterisk);
......@@ -2968,11 +2757,6 @@ fn parsePtrIndexPayload(p: *Parse) Error!OptionalTokenIndex {
29682757 return .fromToken(identifier);
29692758}
29702759
2971/// SwitchProng <- KEYWORD_inline? SwitchCase EQUALRARROW PtrIndexPayload? AssignExpr
2972///
2973/// SwitchCase
2974/// <- SwitchItem (COMMA SwitchItem)* COMMA?
2975/// / KEYWORD_else
29762760fn parseSwitchProng(p: *Parse) !?Node.Index {
29772761 const scratch_top = p.scratch.items.len;
29782762 defer p.scratch.shrinkRetainingCapacity(scratch_top);
......@@ -3015,7 +2799,6 @@ fn parseSwitchProng(p: *Parse) !?Node.Index {
30152799 }
30162800}
30172801
3018/// SwitchItem <- Expr (DOT3 Expr)?
30192802fn parseSwitchItem(p: *Parse) !?Node.Index {
30202803 const expr = try p.parseExpr() orelse return null;
30212804
......@@ -3043,22 +2826,6 @@ const PtrModifiers = struct {
30432826 bit_range_end: Node.OptionalIndex,
30442827};
30452828
3046/// PtrMods
3047/// <- PtrMod* ByteAlign? PtrMod* AddrSpace? PtrMod*
3048/// / PtrMod* AddrSpace? PtrMod* ByteAlign? PtrMod*
3049///
3050/// SinglePtrMods
3051/// <- PtrMod* BitAlign? PtrMod* AddrSpace? PtrMod*
3052/// / PtrMod* AddrSpace? PtrMod* BitAlign? PtrMod*
3053///
3054/// PtrMod
3055/// <- KEYWORD_allowzero
3056/// / KEYWORD_const
3057/// / KEYWORD_volatile
3058///
3059/// AddrSpace <- KEYWORD_addrspace LPAREN Expr RPAREN
3060/// ByteAlign <- KEYWORD_align LPAREN Expr RPAREN
3061/// BitAlign <- KEYWORD_align LPAREN Expr (COLON Expr COLON Expr)? RPAREN
30622829fn parsePtrModifiers(p: *Parse, align_type: enum { bit_align, byte_align }) !PtrModifiers {
30632830 var result: PtrModifiers = .{
30642831 .align_node = .none,
......@@ -3102,16 +2869,6 @@ fn parsePtrModifiers(p: *Parse, align_type: enum { bit_align, byte_align }) !Ptr
31022869 }
31032870}
31042871
3105/// SuffixOp
3106/// <- LBRACKET Expr (DOT2 Expr? (COLON Expr)?)? RBRACKET
3107/// / DOT IDENTIFIER
3108/// / DOTASTERISK
3109/// / DOT QUESTIONMARK
3110/// / FnCallArguments
3111///
3112/// FnCallArguments <- LPAREN ExprList RPAREN
3113///
3114/// ExprList <- (Expr COMMA)* Expr?
31152872fn parseSuffixOp(p: *Parse, lhs: Node.Index) !?Node.Index {
31162873 switch (p.tokenTag(p.tok_i)) {
31172874 .l_bracket => {
......@@ -3246,14 +3003,6 @@ fn parseSuffixOp(p: *Parse, lhs: Node.Index) !?Node.Index {
32463003}
32473004
32483005/// Caller must have already verified the first token.
3249///
3250/// ContainerDeclAuto <- ContainerDeclType LBRACE ContainerMembers RBRACE
3251///
3252/// ContainerDeclType
3253/// <- KEYWORD_struct (LPAREN Expr RPAREN)?
3254/// / KEYWORD_opaque
3255/// / KEYWORD_enum (LPAREN Expr RPAREN)?
3256/// / KEYWORD_union (LPAREN (KEYWORD_enum (LPAREN Expr RPAREN)? / Expr) RPAREN)?
32573006fn expectContainerDeclAuto(p: *Parse) !Node.Index {
32583007 const main_token = p.nextToken();
32593008 const arg_expr = switch (p.tokenTag(main_token)) {
......@@ -3407,8 +3156,6 @@ fn parseCStyleContainer(p: *Parse) Error!bool {
34073156}
34083157
34093158/// Holds temporary data until we are ready to construct the full ContainerDecl AST node.
3410///
3411/// ByteAlign <- KEYWORD_align LPAREN Expr RPAREN
34123159fn parseByteAlign(p: *Parse) !?Node.Index {
34133160 _ = p.eatToken(.keyword_align) orelse return null;
34143161 _ = try p.expectToken(.l_paren);
......@@ -3417,7 +3164,6 @@ fn parseByteAlign(p: *Parse) !?Node.Index {
34173164 return expr;
34183165}
34193166
3420/// SwitchProngList <- (SwitchProng COMMA)* SwitchProng?
34213167fn parseSwitchProngList(p: *Parse) !Node.SubRange {
34223168 const scratch_top = p.scratch.items.len;
34233169 defer p.scratch.shrinkRetainingCapacity(scratch_top);
......@@ -3438,7 +3184,6 @@ fn parseSwitchProngList(p: *Parse) !Node.SubRange {
34383184 return p.listToSpan(p.scratch.items[scratch_top..]);
34393185}
34403186
3441/// ParamDeclList <- (ParamDecl COMMA)* (ParamDecl / DOT3 COMMA?)?
34423187fn parseParamDeclList(p: *Parse) !SmallSpan {
34433188 _ = try p.expectToken(.l_paren);
34443189 const scratch_top = p.scratch.items.len;
......@@ -3475,9 +3220,6 @@ fn parseParamDeclList(p: *Parse) !SmallSpan {
34753220 };
34763221}
34773222
3478/// FnCallArguments <- LPAREN ExprList RPAREN
3479///
3480/// ExprList <- (Expr COMMA)* Expr?
34813223fn expectBuiltinCall(p: *Parse) !Node.Index {
34823224 const builtin_token = p.assertToken(.builtin);
34833225 _ = p.eatToken(.l_paren) orelse {
......@@ -3526,11 +3268,6 @@ fn expectBuiltinCall(p: *Parse) !Node.Index {
35263268 }
35273269}
35283270
3529/// IfExpr <- IfPrefix Expr (KEYWORD_else Payload? Expr / !KEYWORD_else)
3530///
3531/// IfTypeExpr <- IfPrefix TypeExpr (KEYWORD_else Payload? TypeExpr / !KEYWORD_else)
3532///
3533/// IfPrefix <- KEYWORD_if LPAREN Expr RPAREN PtrPayload?
35343271fn expectIf(p: *Parse, comptime bodyParseFn: fn (p: *Parse) Error!Node.Index) !Node.Index {
35353272 const if_token = p.assertToken(.keyword_if);
35363273 _ = try p.expectToken(.l_paren);
......@@ -3564,9 +3301,6 @@ fn expectIf(p: *Parse, comptime bodyParseFn: fn (p: *Parse) Error!Node.Index) !N
35643301 });
35653302}
35663303
3567/// ForExpr <- ForPrefix Expr (KEYWORD_else Expr / !KEYWORD_else)
3568///
3569/// ForTypeExpr <- ForPrefix TypeExpr (KEYWORD_else TypeExpr / !KEYWORD_else)
35703304fn expectFor(p: *Parse, comptime bodyParseFn: fn (p: *Parse) Error!Node.Index) !Node.Index {
35713305 const for_token = p.assertToken(.keyword_for);
35723306