authorgravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2018-05-13 14:20:01-04:00
committergravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2018-05-13 14:20:01-04:00
logabcd418451051fe8c3b5c283d1701d101337dde8
treeb8f9d795922a704bb6a33e55ff10e306f63193d4
parent05ecb49bac30041459ae08764edd2aced23d10eb

std.zig.parse cleanup

2 files changed, 368 insertions(+), 424 deletions(-)

std/zig/parse.zig+360-424
......@@ -17,15 +17,13 @@ pub fn parse(allocator: &mem.Allocator, source: []const u8) !ast.Tree {
1717 defer stack.deinit();
1818
1919 const arena = &tree_arena.allocator;
20 const root_node = try createNode(arena, ast.Node.Root,
21 ast.Node.Root {
22 .base = undefined,
23 .decls = ast.Node.Root.DeclList.init(arena),
24 .doc_comments = null,
25 // initialized when we get the eof token
26 .eof_token = undefined,
27 }
28 );
20 const root_node = try arena.construct(ast.Node.Root {
21 .base = ast.Node { .id = ast.Node.Id.Root },
22 .decls = ast.Node.Root.DeclList.init(arena),
23 .doc_comments = null,
24 // initialized when we get the eof token
25 .eof_token = undefined,
26 });
2927
3028 var tree = ast.Tree {
3129 .source = source,
......@@ -113,15 +111,13 @@ pub fn parse(allocator: &mem.Allocator, source: []const u8) !ast.Tree {
113111 continue;
114112 },
115113 Token.Id.Keyword_comptime => {
116 const block = try createNode(arena, ast.Node.Block,
117 ast.Node.Block {
118 .base = undefined,
119 .label = null,
120 .lbrace = undefined,
121 .statements = ast.Node.Block.StatementList.init(arena),
122 .rbrace = undefined,
123 }
124 );
114 const block = try arena.construct(ast.Node.Block {
115 .base = ast.Node {.id = ast.Node.Id.Block },
116 .label = null,
117 .lbrace = undefined,
118 .statements = ast.Node.Block.StatementList.init(arena),
119 .rbrace = undefined,
120 });
125121 const node = try arena.construct(ast.Node.Comptime {
126122 .base = ast.Node {
127123 .id = ast.Node.Id.Comptime,
......@@ -312,14 +308,12 @@ pub fn parse(allocator: &mem.Allocator, source: []const u8) !ast.Tree {
312308 continue;
313309 },
314310 Token.Id.Keyword_async => {
315 const async_node = try createNode(arena, ast.Node.AsyncAttribute,
316 ast.Node.AsyncAttribute {
317 .base = undefined,
318 .async_token = token_index,
319 .allocator_type = null,
320 .rangle_bracket = null,
321 }
322 );
311 const async_node = try arena.construct(ast.Node.AsyncAttribute {
312 .base = ast.Node {.id = ast.Node.Id.AsyncAttribute },
313 .async_token = token_index,
314 .allocator_type = null,
315 .rangle_bracket = null,
316 });
323317 fn_proto.async_attr = async_node;
324318
325319 try stack.append(State {
......@@ -396,27 +390,26 @@ pub fn parse(allocator: &mem.Allocator, source: []const u8) !ast.Tree {
396390 const token = nextToken(&tok_it, &tree);
397391 const token_index = token.index;
398392 const token_ptr = token.ptr;
399 const node = try createToCtxNode(arena, ctx.opt_ctx, ast.Node.ContainerDecl,
400 ast.Node.ContainerDecl {
401 .base = undefined,
402 .ltoken = ctx.ltoken,
403 .layout = ctx.layout,
404 .kind = switch (token_ptr.id) {
405 Token.Id.Keyword_struct => ast.Node.ContainerDecl.Kind.Struct,
406 Token.Id.Keyword_union => ast.Node.ContainerDecl.Kind.Union,
407 Token.Id.Keyword_enum => ast.Node.ContainerDecl.Kind.Enum,
408 else => {
409 *(try tree.errors.addOne()) = Error {
410 .ExpectedAggregateKw = Error.ExpectedAggregateKw { .token = token_index },
411 };
412 return tree;
413 },
393 const node = try arena.construct(ast.Node.ContainerDecl {
394 .base = ast.Node {.id = ast.Node.Id.ContainerDecl },
395 .ltoken = ctx.ltoken,
396 .layout = ctx.layout,
397 .kind = switch (token_ptr.id) {
398 Token.Id.Keyword_struct => ast.Node.ContainerDecl.Kind.Struct,
399 Token.Id.Keyword_union => ast.Node.ContainerDecl.Kind.Union,
400 Token.Id.Keyword_enum => ast.Node.ContainerDecl.Kind.Enum,
401 else => {
402 *(try tree.errors.addOne()) = Error {
403 .ExpectedAggregateKw = Error.ExpectedAggregateKw { .token = token_index },
404 };
405 return tree;
414406 },
415 .init_arg_expr = ast.Node.ContainerDecl.InitArg.None,
416 .fields_and_decls = ast.Node.ContainerDecl.DeclList.init(arena),
417 .rbrace_token = undefined,
418 }
419 );
407 },
408 .init_arg_expr = ast.Node.ContainerDecl.InitArg.None,
409 .fields_and_decls = ast.Node.ContainerDecl.DeclList.init(arena),
410 .rbrace_token = undefined,
411 });
412 ctx.opt_ctx.store(&node.base);
420413
421414 stack.append(State { .ContainerDecl = node }) catch unreachable;
422415 try stack.append(State { .ExpectToken = Token.Id.LBrace });
......@@ -844,15 +837,14 @@ pub fn parse(allocator: &mem.Allocator, source: []const u8) !ast.Tree {
844837 const token_ptr = token.ptr;
845838 switch (token_ptr.id) {
846839 Token.Id.LBrace => {
847 const block = try createToCtxNode(arena, ctx.opt_ctx, ast.Node.Block,
848 ast.Node.Block {
849 .base = undefined,
850 .label = ctx.label,
851 .lbrace = token_index,
852 .statements = ast.Node.Block.StatementList.init(arena),
853 .rbrace = undefined,
854 }
855 );
840 const block = try arena.construct(ast.Node.Block {
841 .base = ast.Node {.id = ast.Node.Id.Block},
842 .label = ctx.label,
843 .lbrace = token_index,
844 .statements = ast.Node.Block.StatementList.init(arena),
845 .rbrace = undefined,
846 });
847 ctx.opt_ctx.store(&block.base);
856848 stack.append(State { .Block = block }) catch unreachable;
857849 continue;
858850 },
......@@ -957,19 +949,18 @@ pub fn parse(allocator: &mem.Allocator, source: []const u8) !ast.Tree {
957949 }
958950 },
959951 State.While => |ctx| {
960 const node = try createToCtxNode(arena, ctx.opt_ctx, ast.Node.While,
961 ast.Node.While {
962 .base = undefined,
963 .label = ctx.label,
964 .inline_token = ctx.inline_token,
965 .while_token = ctx.loop_token,
966 .condition = undefined,
967 .payload = null,
968 .continue_expr = null,
969 .body = undefined,
970 .@"else" = null,
971 }
972 );
952 const node = try arena.construct(ast.Node.While {
953 .base = ast.Node {.id = ast.Node.Id.While },
954 .label = ctx.label,
955 .inline_token = ctx.inline_token,
956 .while_token = ctx.loop_token,
957 .condition = undefined,
958 .payload = null,
959 .continue_expr = null,
960 .body = undefined,
961 .@"else" = null,
962 });
963 ctx.opt_ctx.store(&node.base);
973964 stack.append(State { .Else = &node.@"else" }) catch unreachable;
974965 try stack.append(State { .Expression = OptionalCtx { .Required = &node.body } });
975966 try stack.append(State { .WhileContinueExpr = &node.continue_expr });
......@@ -987,18 +978,17 @@ pub fn parse(allocator: &mem.Allocator, source: []const u8) !ast.Tree {
987978 continue;
988979 },
989980 State.For => |ctx| {
990 const node = try createToCtxNode(arena, ctx.opt_ctx, ast.Node.For,
991 ast.Node.For {
992 .base = undefined,
993 .label = ctx.label,
994 .inline_token = ctx.inline_token,
995 .for_token = ctx.loop_token,
996 .array_expr = undefined,
997 .payload = null,
998 .body = undefined,
999 .@"else" = null,
1000 }
1001 );
981 const node = try arena.construct(ast.Node.For {
982 .base = ast.Node {.id = ast.Node.Id.For },
983 .label = ctx.label,
984 .inline_token = ctx.inline_token,
985 .for_token = ctx.loop_token,
986 .array_expr = undefined,
987 .payload = null,
988 .body = undefined,
989 .@"else" = null,
990 });
991 ctx.opt_ctx.store(&node.base);
1002992 stack.append(State { .Else = &node.@"else" }) catch unreachable;
1003993 try stack.append(State { .Expression = OptionalCtx { .Required = &node.body } });
1004994 try stack.append(State { .PointerIndexPayload = OptionalCtx { .Optional = &node.payload } });
......@@ -1009,14 +999,12 @@ pub fn parse(allocator: &mem.Allocator, source: []const u8) !ast.Tree {
1009999 },
10101000 State.Else => |dest| {
10111001 if (eatToken(&tok_it, &tree, Token.Id.Keyword_else)) |else_token| {
1012 const node = try createNode(arena, ast.Node.Else,
1013 ast.Node.Else {
1014 .base = undefined,
1015 .else_token = else_token,
1016 .payload = null,
1017 .body = undefined,
1018 }
1019 );
1002 const node = try arena.construct(ast.Node.Else {
1003 .base = ast.Node {.id = ast.Node.Id.Else },
1004 .else_token = else_token,
1005 .payload = null,
1006 .body = undefined,
1007 });
10201008 *dest = node;
10211009
10221010 stack.append(State { .Expression = OptionalCtx { .Required = &node.body } }) catch unreachable;
......@@ -1170,14 +1158,12 @@ pub fn parse(allocator: &mem.Allocator, source: []const u8) !ast.Tree {
11701158 continue;
11711159 }
11721160
1173 const node = try createNode(arena, ast.Node.AsmOutput,
1174 ast.Node.AsmOutput {
1175 .base = undefined,
1176 .symbolic_name = undefined,
1177 .constraint = undefined,
1178 .kind = undefined,
1179 }
1180 );
1161 const node = try arena.construct(ast.Node.AsmOutput {
1162 .base = ast.Node {.id = ast.Node.Id.AsmOutput },
1163 .symbolic_name = undefined,
1164 .constraint = undefined,
1165 .kind = undefined,
1166 });
11811167 try items.push(node);
11821168
11831169 stack.append(State { .AsmOutputItems = items }) catch unreachable;
......@@ -1223,14 +1209,12 @@ pub fn parse(allocator: &mem.Allocator, source: []const u8) !ast.Tree {
12231209 continue;
12241210 }
12251211
1226 const node = try createNode(arena, ast.Node.AsmInput,
1227 ast.Node.AsmInput {
1228 .base = undefined,
1229 .symbolic_name = undefined,
1230 .constraint = undefined,
1231 .expr = undefined,
1232 }
1233 );
1212 const node = try arena.construct(ast.Node.AsmInput {
1213 .base = ast.Node {.id = ast.Node.Id.AsmInput },
1214 .symbolic_name = undefined,
1215 .constraint = undefined,
1216 .expr = undefined,
1217 });
12341218 try items.push(node);
12351219
12361220 stack.append(State { .AsmInputItems = items }) catch unreachable;
......@@ -1668,14 +1652,13 @@ pub fn parse(allocator: &mem.Allocator, source: []const u8) !ast.Tree {
16681652 continue;
16691653 }
16701654
1671 const node = try createToCtxNode(arena, opt_ctx, ast.Node.Payload,
1672 ast.Node.Payload {
1673 .base = undefined,
1674 .lpipe = token_index,
1675 .error_symbol = undefined,
1676 .rpipe = undefined
1677 }
1678 );
1655 const node = try arena.construct(ast.Node.Payload {
1656 .base = ast.Node {.id = ast.Node.Id.Payload },
1657 .lpipe = token_index,
1658 .error_symbol = undefined,
1659 .rpipe = undefined
1660 });
1661 opt_ctx.store(&node.base);
16791662
16801663 stack.append(State {
16811664 .ExpectTokenSave = ExpectTokenSave {
......@@ -1705,15 +1688,14 @@ pub fn parse(allocator: &mem.Allocator, source: []const u8) !ast.Tree {
17051688 continue;
17061689 }
17071690
1708 const node = try createToCtxNode(arena, opt_ctx, ast.Node.PointerPayload,
1709 ast.Node.PointerPayload {
1710 .base = undefined,
1711 .lpipe = token_index,
1712 .ptr_token = null,
1713 .value_symbol = undefined,
1714 .rpipe = undefined
1715 }
1716 );
1691 const node = try arena.construct(ast.Node.PointerPayload {
1692 .base = ast.Node {.id = ast.Node.Id.PointerPayload },
1693 .lpipe = token_index,
1694 .ptr_token = null,
1695 .value_symbol = undefined,
1696 .rpipe = undefined
1697 });
1698 opt_ctx.store(&node.base);
17171699
17181700 try stack.append(State {
17191701 .ExpectTokenSave = ExpectTokenSave {
......@@ -1749,16 +1731,15 @@ pub fn parse(allocator: &mem.Allocator, source: []const u8) !ast.Tree {
17491731 continue;
17501732 }
17511733
1752 const node = try createToCtxNode(arena, opt_ctx, ast.Node.PointerIndexPayload,
1753 ast.Node.PointerIndexPayload {
1754 .base = undefined,
1755 .lpipe = token_index,
1756 .ptr_token = null,
1757 .value_symbol = undefined,
1758 .index_symbol = null,
1759 .rpipe = undefined
1760 }
1761 );
1734 const node = try arena.construct(ast.Node.PointerIndexPayload {
1735 .base = ast.Node {.id = ast.Node.Id.PointerIndexPayload },
1736 .lpipe = token_index,
1737 .ptr_token = null,
1738 .value_symbol = undefined,
1739 .index_symbol = null,
1740 .rpipe = undefined
1741 });
1742 opt_ctx.store(&node.base);
17621743
17631744 stack.append(State {
17641745 .ExpectTokenSave = ExpectTokenSave {
......@@ -1785,14 +1766,13 @@ pub fn parse(allocator: &mem.Allocator, source: []const u8) !ast.Tree {
17851766 const token_ptr = token.ptr;
17861767 switch (token_ptr.id) {
17871768 Token.Id.Keyword_return, Token.Id.Keyword_break, Token.Id.Keyword_continue => {
1788 const node = try createToCtxNode(arena, opt_ctx, ast.Node.ControlFlowExpression,
1789 ast.Node.ControlFlowExpression {
1790 .base = undefined,
1791 .ltoken = token_index,
1792 .kind = undefined,
1793 .rhs = null,
1794 }
1795 );
1769 const node = try arena.construct(ast.Node.ControlFlowExpression {
1770 .base = ast.Node {.id = ast.Node.Id.ControlFlowExpression },
1771 .ltoken = token_index,
1772 .kind = undefined,
1773 .rhs = null,
1774 });
1775 opt_ctx.store(&node.base);
17961776
17971777 stack.append(State { .Expression = OptionalCtx { .Optional = &node.rhs } }) catch unreachable;
17981778
......@@ -1815,19 +1795,18 @@ pub fn parse(allocator: &mem.Allocator, source: []const u8) !ast.Tree {
18151795 continue;
18161796 },
18171797 Token.Id.Keyword_try, Token.Id.Keyword_cancel, Token.Id.Keyword_resume => {
1818 const node = try createToCtxNode(arena, opt_ctx, ast.Node.PrefixOp,
1819 ast.Node.PrefixOp {
1820 .base = undefined,
1821 .op_token = token_index,
1822 .op = switch (token_ptr.id) {
1823 Token.Id.Keyword_try => ast.Node.PrefixOp.Op { .Try = void{} },
1824 Token.Id.Keyword_cancel => ast.Node.PrefixOp.Op { .Cancel = void{} },
1825 Token.Id.Keyword_resume => ast.Node.PrefixOp.Op { .Resume = void{} },
1826 else => unreachable,
1827 },
1828 .rhs = undefined,
1829 }
1830 );
1798 const node = try arena.construct(ast.Node.PrefixOp {
1799 .base = ast.Node {.id = ast.Node.Id.PrefixOp },
1800 .op_token = token_index,
1801 .op = switch (token_ptr.id) {
1802 Token.Id.Keyword_try => ast.Node.PrefixOp.Op { .Try = void{} },
1803 Token.Id.Keyword_cancel => ast.Node.PrefixOp.Op { .Cancel = void{} },
1804 Token.Id.Keyword_resume => ast.Node.PrefixOp.Op { .Resume = void{} },
1805 else => unreachable,
1806 },
1807 .rhs = undefined,
1808 });
1809 opt_ctx.store(&node.base);
18311810
18321811 stack.append(State { .Expression = OptionalCtx { .Required = &node.rhs } }) catch unreachable;
18331812 continue;
......@@ -1850,15 +1829,14 @@ pub fn parse(allocator: &mem.Allocator, source: []const u8) !ast.Tree {
18501829 const lhs = opt_ctx.get() ?? continue;
18511830
18521831 if (eatToken(&tok_it, &tree, Token.Id.Ellipsis3)) |ellipsis3| {
1853 const node = try createToCtxNode(arena, opt_ctx, ast.Node.InfixOp,
1854 ast.Node.InfixOp {
1855 .base = undefined,
1856 .lhs = lhs,
1857 .op_token = ellipsis3,
1858 .op = ast.Node.InfixOp.Op.Range,
1859 .rhs = undefined,
1860 }
1861 );
1832 const node = try arena.construct(ast.Node.InfixOp {
1833 .base = ast.Node {.id = ast.Node.Id.InfixOp },
1834 .lhs = lhs,
1835 .op_token = ellipsis3,
1836 .op = ast.Node.InfixOp.Op.Range,
1837 .rhs = undefined,
1838 });
1839 opt_ctx.store(&node.base);
18621840 stack.append(State { .Expression = OptionalCtx { .Required = &node.rhs } }) catch unreachable;
18631841 continue;
18641842 }
......@@ -1876,15 +1854,14 @@ pub fn parse(allocator: &mem.Allocator, source: []const u8) !ast.Tree {
18761854 const token_index = token.index;
18771855 const token_ptr = token.ptr;
18781856 if (tokenIdToAssignment(token_ptr.id)) |ass_id| {
1879 const node = try createToCtxNode(arena, opt_ctx, ast.Node.InfixOp,
1880 ast.Node.InfixOp {
1881 .base = undefined,
1882 .lhs = lhs,
1883 .op_token = token_index,
1884 .op = ass_id,
1885 .rhs = undefined,
1886 }
1887 );
1857 const node = try arena.construct(ast.Node.InfixOp {
1858 .base = ast.Node {.id = ast.Node.Id.InfixOp },
1859 .lhs = lhs,
1860 .op_token = token_index,
1861 .op = ass_id,
1862 .rhs = undefined,
1863 });
1864 opt_ctx.store(&node.base);
18881865 stack.append(State { .AssignmentExpressionEnd = opt_ctx.toRequired() }) catch unreachable;
18891866 try stack.append(State { .Expression = OptionalCtx { .Required = &node.rhs } });
18901867 continue;
......@@ -1907,15 +1884,14 @@ pub fn parse(allocator: &mem.Allocator, source: []const u8) !ast.Tree {
19071884 const token_index = token.index;
19081885 const token_ptr = token.ptr;
19091886 if (tokenIdToUnwrapExpr(token_ptr.id)) |unwrap_id| {
1910 const node = try createToCtxNode(arena, opt_ctx, ast.Node.InfixOp,
1911 ast.Node.InfixOp {
1912 .base = undefined,
1913 .lhs = lhs,
1914 .op_token = token_index,
1915 .op = unwrap_id,
1916 .rhs = undefined,
1917 }
1918 );
1887 const node = try arena.construct(ast.Node.InfixOp {
1888 .base = ast.Node {.id = ast.Node.Id.InfixOp },
1889 .lhs = lhs,
1890 .op_token = token_index,
1891 .op = unwrap_id,
1892 .rhs = undefined,
1893 });
1894 opt_ctx.store(&node.base);
19191895
19201896 stack.append(State { .UnwrapExpressionEnd = opt_ctx.toRequired() }) catch unreachable;
19211897 try stack.append(State { .Expression = OptionalCtx { .Required = &node.rhs } });
......@@ -1940,15 +1916,14 @@ pub fn parse(allocator: &mem.Allocator, source: []const u8) !ast.Tree {
19401916 const lhs = opt_ctx.get() ?? continue;
19411917
19421918 if (eatToken(&tok_it, &tree, Token.Id.Keyword_or)) |or_token| {
1943 const node = try createToCtxNode(arena, opt_ctx, ast.Node.InfixOp,
1944 ast.Node.InfixOp {
1945 .base = undefined,
1946 .lhs = lhs,
1947 .op_token = or_token,
1948 .op = ast.Node.InfixOp.Op.BoolOr,
1949 .rhs = undefined,
1950 }
1951 );
1919 const node = try arena.construct(ast.Node.InfixOp {
1920 .base = ast.Node {.id = ast.Node.Id.InfixOp },
1921 .lhs = lhs,
1922 .op_token = or_token,
1923 .op = ast.Node.InfixOp.Op.BoolOr,
1924 .rhs = undefined,
1925 });
1926 opt_ctx.store(&node.base);
19521927 stack.append(State { .BoolOrExpressionEnd = opt_ctx.toRequired() }) catch unreachable;
19531928 try stack.append(State { .BoolAndExpressionBegin = OptionalCtx { .Required = &node.rhs } });
19541929 continue;
......@@ -1965,15 +1940,14 @@ pub fn parse(allocator: &mem.Allocator, source: []const u8) !ast.Tree {
19651940 const lhs = opt_ctx.get() ?? continue;
19661941
19671942 if (eatToken(&tok_it, &tree, Token.Id.Keyword_and)) |and_token| {
1968 const node = try createToCtxNode(arena, opt_ctx, ast.Node.InfixOp,
1969 ast.Node.InfixOp {
1970 .base = undefined,
1971 .lhs = lhs,
1972 .op_token = and_token,
1973 .op = ast.Node.InfixOp.Op.BoolAnd,
1974 .rhs = undefined,
1975 }
1976 );
1943 const node = try arena.construct(ast.Node.InfixOp {
1944 .base = ast.Node {.id = ast.Node.Id.InfixOp },
1945 .lhs = lhs,
1946 .op_token = and_token,
1947 .op = ast.Node.InfixOp.Op.BoolAnd,
1948 .rhs = undefined,
1949 });
1950 opt_ctx.store(&node.base);
19771951 stack.append(State { .BoolAndExpressionEnd = opt_ctx.toRequired() }) catch unreachable;
19781952 try stack.append(State { .ComparisonExpressionBegin = OptionalCtx { .Required = &node.rhs } });
19791953 continue;
......@@ -1993,15 +1967,14 @@ pub fn parse(allocator: &mem.Allocator, source: []const u8) !ast.Tree {
19931967 const token_index = token.index;
19941968 const token_ptr = token.ptr;
19951969 if (tokenIdToComparison(token_ptr.id)) |comp_id| {
1996 const node = try createToCtxNode(arena, opt_ctx, ast.Node.InfixOp,
1997 ast.Node.InfixOp {
1998 .base = undefined,
1999 .lhs = lhs,
2000 .op_token = token_index,
2001 .op = comp_id,
2002 .rhs = undefined,
2003 }
2004 );
1970 const node = try arena.construct(ast.Node.InfixOp {
1971 .base = ast.Node {.id = ast.Node.Id.InfixOp },
1972 .lhs = lhs,
1973 .op_token = token_index,
1974 .op = comp_id,
1975 .rhs = undefined,
1976 });
1977 opt_ctx.store(&node.base);
20051978 stack.append(State { .ComparisonExpressionEnd = opt_ctx.toRequired() }) catch unreachable;
20061979 try stack.append(State { .BinaryOrExpressionBegin = OptionalCtx { .Required = &node.rhs } });
20071980 continue;
......@@ -2021,15 +1994,14 @@ pub fn parse(allocator: &mem.Allocator, source: []const u8) !ast.Tree {
20211994 const lhs = opt_ctx.get() ?? continue;
20221995
20231996 if (eatToken(&tok_it, &tree, Token.Id.Pipe)) |pipe| {
2024 const node = try createToCtxNode(arena, opt_ctx, ast.Node.InfixOp,
2025 ast.Node.InfixOp {
2026 .base = undefined,
2027 .lhs = lhs,
2028 .op_token = pipe,
2029 .op = ast.Node.InfixOp.Op.BitOr,
2030 .rhs = undefined,
2031 }
2032 );
1997 const node = try arena.construct(ast.Node.InfixOp {
1998 .base = ast.Node {.id = ast.Node.Id.InfixOp },
1999 .lhs = lhs,
2000 .op_token = pipe,
2001 .op = ast.Node.InfixOp.Op.BitOr,
2002 .rhs = undefined,
2003 });
2004 opt_ctx.store(&node.base);
20332005 stack.append(State { .BinaryOrExpressionEnd = opt_ctx.toRequired() }) catch unreachable;
20342006 try stack.append(State { .BinaryXorExpressionBegin = OptionalCtx { .Required = &node.rhs } });
20352007 continue;
......@@ -2046,15 +2018,14 @@ pub fn parse(allocator: &mem.Allocator, source: []const u8) !ast.Tree {
20462018 const lhs = opt_ctx.get() ?? continue;
20472019
20482020 if (eatToken(&tok_it, &tree, Token.Id.Caret)) |caret| {
2049 const node = try createToCtxNode(arena, opt_ctx, ast.Node.InfixOp,
2050 ast.Node.InfixOp {
2051 .base = undefined,
2052 .lhs = lhs,
2053 .op_token = caret,
2054 .op = ast.Node.InfixOp.Op.BitXor,
2055 .rhs = undefined,
2056 }
2057 );
2021 const node = try arena.construct(ast.Node.InfixOp {
2022 .base = ast.Node {.id = ast.Node.Id.InfixOp },
2023 .lhs = lhs,
2024 .op_token = caret,
2025 .op = ast.Node.InfixOp.Op.BitXor,
2026 .rhs = undefined,
2027 });
2028 opt_ctx.store(&node.base);
20582029 stack.append(State { .BinaryXorExpressionEnd = opt_ctx.toRequired() }) catch unreachable;
20592030 try stack.append(State { .BinaryAndExpressionBegin = OptionalCtx { .Required = &node.rhs } });
20602031 continue;
......@@ -2071,15 +2042,14 @@ pub fn parse(allocator: &mem.Allocator, source: []const u8) !ast.Tree {
20712042 const lhs = opt_ctx.get() ?? continue;
20722043
20732044 if (eatToken(&tok_it, &tree, Token.Id.Ampersand)) |ampersand| {
2074 const node = try createToCtxNode(arena, opt_ctx, ast.Node.InfixOp,
2075 ast.Node.InfixOp {
2076 .base = undefined,
2077 .lhs = lhs,
2078 .op_token = ampersand,
2079 .op = ast.Node.InfixOp.Op.BitAnd,
2080 .rhs = undefined,
2081 }
2082 );
2045 const node = try arena.construct(ast.Node.InfixOp {
2046 .base = ast.Node {.id = ast.Node.Id.InfixOp },
2047 .lhs = lhs,
2048 .op_token = ampersand,
2049 .op = ast.Node.InfixOp.Op.BitAnd,
2050 .rhs = undefined,
2051 });
2052 opt_ctx.store(&node.base);
20832053 stack.append(State { .BinaryAndExpressionEnd = opt_ctx.toRequired() }) catch unreachable;
20842054 try stack.append(State { .BitShiftExpressionBegin = OptionalCtx { .Required = &node.rhs } });
20852055 continue;
......@@ -2099,15 +2069,14 @@ pub fn parse(allocator: &mem.Allocator, source: []const u8) !ast.Tree {
20992069 const token_index = token.index;
21002070 const token_ptr = token.ptr;
21012071 if (tokenIdToBitShift(token_ptr.id)) |bitshift_id| {
2102 const node = try createToCtxNode(arena, opt_ctx, ast.Node.InfixOp,
2103 ast.Node.InfixOp {
2104 .base = undefined,
2105 .lhs = lhs,
2106 .op_token = token_index,
2107 .op = bitshift_id,
2108 .rhs = undefined,
2109 }
2110 );
2072 const node = try arena.construct(ast.Node.InfixOp {
2073 .base = ast.Node {.id = ast.Node.Id.InfixOp },
2074 .lhs = lhs,
2075 .op_token = token_index,
2076 .op = bitshift_id,
2077 .rhs = undefined,
2078 });
2079 opt_ctx.store(&node.base);
21112080 stack.append(State { .BitShiftExpressionEnd = opt_ctx.toRequired() }) catch unreachable;
21122081 try stack.append(State { .AdditionExpressionBegin = OptionalCtx { .Required = &node.rhs } });
21132082 continue;
......@@ -2130,15 +2099,14 @@ pub fn parse(allocator: &mem.Allocator, source: []const u8) !ast.Tree {
21302099 const token_index = token.index;
21312100 const token_ptr = token.ptr;
21322101 if (tokenIdToAddition(token_ptr.id)) |add_id| {
2133 const node = try createToCtxNode(arena, opt_ctx, ast.Node.InfixOp,
2134 ast.Node.InfixOp {
2135 .base = undefined,
2136 .lhs = lhs,
2137 .op_token = token_index,
2138 .op = add_id,
2139 .rhs = undefined,
2140 }
2141 );
2102 const node = try arena.construct(ast.Node.InfixOp {
2103 .base = ast.Node {.id = ast.Node.Id.InfixOp },
2104 .lhs = lhs,
2105 .op_token = token_index,
2106 .op = add_id,
2107 .rhs = undefined,
2108 });
2109 opt_ctx.store(&node.base);
21422110 stack.append(State { .AdditionExpressionEnd = opt_ctx.toRequired() }) catch unreachable;
21432111 try stack.append(State { .MultiplyExpressionBegin = OptionalCtx { .Required = &node.rhs } });
21442112 continue;
......@@ -2161,15 +2129,14 @@ pub fn parse(allocator: &mem.Allocator, source: []const u8) !ast.Tree {
21612129 const token_index = token.index;
21622130 const token_ptr = token.ptr;
21632131 if (tokenIdToMultiply(token_ptr.id)) |mult_id| {
2164 const node = try createToCtxNode(arena, opt_ctx, ast.Node.InfixOp,
2165 ast.Node.InfixOp {
2166 .base = undefined,
2167 .lhs = lhs,
2168 .op_token = token_index,
2169 .op = mult_id,
2170 .rhs = undefined,
2171 }
2172 );
2132 const node = try arena.construct(ast.Node.InfixOp {
2133 .base = ast.Node {.id = ast.Node.Id.InfixOp },
2134 .lhs = lhs,
2135 .op_token = token_index,
2136 .op = mult_id,
2137 .rhs = undefined,
2138 });
2139 opt_ctx.store(&node.base);
21732140 stack.append(State { .MultiplyExpressionEnd = opt_ctx.toRequired() }) catch unreachable;
21742141 try stack.append(State { .CurlySuffixExpressionBegin = OptionalCtx { .Required = &node.rhs } });
21752142 continue;
......@@ -2211,16 +2178,15 @@ pub fn parse(allocator: &mem.Allocator, source: []const u8) !ast.Tree {
22112178 continue;
22122179 }
22132180
2214 const node = try createToCtxNode(arena, opt_ctx, ast.Node.SuffixOp,
2215 ast.Node.SuffixOp {
2216 .base = undefined,
2217 .lhs = lhs,
2218 .op = ast.Node.SuffixOp.Op {
2219 .ArrayInitializer = ast.Node.SuffixOp.Op.InitList.init(arena),
2220 },
2221 .rtoken = undefined,
2222 }
2223 );
2181 const node = try arena.construct(ast.Node.SuffixOp {
2182 .base = ast.Node {.id = ast.Node.Id.SuffixOp },
2183 .lhs = lhs,
2184 .op = ast.Node.SuffixOp.Op {
2185 .ArrayInitializer = ast.Node.SuffixOp.Op.InitList.init(arena),
2186 },
2187 .rtoken = undefined,
2188 });
2189 opt_ctx.store(&node.base);
22242190 stack.append(State { .CurlySuffixExpressionEnd = opt_ctx.toRequired() }) catch unreachable;
22252191 try stack.append(State { .IfToken = Token.Id.LBrace });
22262192 try stack.append(State {
......@@ -2243,15 +2209,14 @@ pub fn parse(allocator: &mem.Allocator, source: []const u8) !ast.Tree {
22432209 const lhs = opt_ctx.get() ?? continue;
22442210
22452211 if (eatToken(&tok_it, &tree, Token.Id.Bang)) |bang| {
2246 const node = try createToCtxNode(arena, opt_ctx, ast.Node.InfixOp,
2247 ast.Node.InfixOp {
2248 .base = undefined,
2249 .lhs = lhs,
2250 .op_token = bang,
2251 .op = ast.Node.InfixOp.Op.ErrorUnion,
2252 .rhs = undefined,
2253 }
2254 );
2212 const node = try arena.construct(ast.Node.InfixOp {
2213 .base = ast.Node {.id = ast.Node.Id.InfixOp },
2214 .lhs = lhs,
2215 .op_token = bang,
2216 .op = ast.Node.InfixOp.Op.ErrorUnion,
2217 .rhs = undefined,
2218 });
2219 opt_ctx.store(&node.base);
22552220 stack.append(State { .TypeExprEnd = opt_ctx.toRequired() }) catch unreachable;
22562221 try stack.append(State { .PrefixOpExpression = OptionalCtx { .Required = &node.rhs } });
22572222 continue;
......@@ -2263,25 +2228,22 @@ pub fn parse(allocator: &mem.Allocator, source: []const u8) !ast.Tree {
22632228 const token_index = token.index;
22642229 const token_ptr = token.ptr;
22652230 if (tokenIdToPrefixOp(token_ptr.id)) |prefix_id| {
2266 var node = try createToCtxNode(arena, opt_ctx, ast.Node.PrefixOp,
2267 ast.Node.PrefixOp {
2268 .base = undefined,
2269 .op_token = token_index,
2270 .op = prefix_id,
2271 .rhs = undefined,
2272 }
2273 );
2231 var node = try arena.construct(ast.Node.PrefixOp {
2232 .base = ast.Node {.id = ast.Node.Id.PrefixOp },
2233 .op_token = token_index,
2234 .op = prefix_id,
2235 .rhs = undefined,
2236 });
2237 opt_ctx.store(&node.base);
22742238
22752239 // Treat '**' token as two derefs
22762240 if (token_ptr.id == Token.Id.AsteriskAsterisk) {
2277 const child = try createNode(arena, ast.Node.PrefixOp,
2278 ast.Node.PrefixOp {
2279 .base = undefined,
2280 .op_token = token_index,
2281 .op = prefix_id,
2282 .rhs = undefined,
2283 }
2284 );
2241 const child = try arena.construct(ast.Node.PrefixOp {
2242 .base = ast.Node {.id = ast.Node.Id.PrefixOp},
2243 .op_token = token_index,
2244 .op = prefix_id,
2245 .rhs = undefined,
2246 });
22852247 node.rhs = &child.base;
22862248 node = child;
22872249 }
......@@ -2300,14 +2262,12 @@ pub fn parse(allocator: &mem.Allocator, source: []const u8) !ast.Tree {
23002262
23012263 State.SuffixOpExpressionBegin => |opt_ctx| {
23022264 if (eatToken(&tok_it, &tree, Token.Id.Keyword_async)) |async_token| {
2303 const async_node = try createNode(arena, ast.Node.AsyncAttribute,
2304 ast.Node.AsyncAttribute {
2305 .base = undefined,
2306 .async_token = async_token,
2307 .allocator_type = null,
2308 .rangle_bracket = null,
2309 }
2310 );
2265 const async_node = try arena.construct(ast.Node.AsyncAttribute {
2266 .base = ast.Node {.id = ast.Node.Id.AsyncAttribute},
2267 .async_token = async_token,
2268 .allocator_type = null,
2269 .rangle_bracket = null,
2270 });
23112271 stack.append(State {
23122272 .AsyncEnd = AsyncEndCtx {
23132273 .ctx = opt_ctx,
......@@ -2333,19 +2293,19 @@ pub fn parse(allocator: &mem.Allocator, source: []const u8) !ast.Tree {
23332293 const token_ptr = token.ptr;
23342294 switch (token_ptr.id) {
23352295 Token.Id.LParen => {
2336 const node = try createToCtxNode(arena, opt_ctx, ast.Node.SuffixOp,
2337 ast.Node.SuffixOp {
2338 .base = undefined,
2339 .lhs = lhs,
2340 .op = ast.Node.SuffixOp.Op {
2341 .Call = ast.Node.SuffixOp.Op.Call {
2342 .params = ast.Node.SuffixOp.Op.Call.ParamList.init(arena),
2343 .async_attr = null,
2344 }
2345 },
2346 .rtoken = undefined,
2347 }
2348 );
2296 const node = try arena.construct(ast.Node.SuffixOp {
2297 .base = ast.Node {.id = ast.Node.Id.SuffixOp },
2298 .lhs = lhs,
2299 .op = ast.Node.SuffixOp.Op {
2300 .Call = ast.Node.SuffixOp.Op.Call {
2301 .params = ast.Node.SuffixOp.Op.Call.ParamList.init(arena),
2302 .async_attr = null,
2303 }
2304 },
2305 .rtoken = undefined,
2306 });
2307 opt_ctx.store(&node.base);
2308
23492309 stack.append(State { .SuffixOpExpressionEnd = opt_ctx.toRequired() }) catch unreachable;
23502310 try stack.append(State {
23512311 .ExprListItemOrEnd = ExprListCtx {
......@@ -2357,31 +2317,31 @@ pub fn parse(allocator: &mem.Allocator, source: []const u8) !ast.Tree {
23572317 continue;
23582318 },
23592319 Token.Id.LBracket => {
2360 const node = try createToCtxNode(arena, opt_ctx, ast.Node.SuffixOp,
2361 ast.Node.SuffixOp {
2362 .base = undefined,
2363 .lhs = lhs,
2364 .op = ast.Node.SuffixOp.Op {
2365 .ArrayAccess = undefined,
2366 },
2367 .rtoken = undefined
2368 }
2369 );
2320 const node = try arena.construct(ast.Node.SuffixOp {
2321 .base = ast.Node {.id = ast.Node.Id.SuffixOp },
2322 .lhs = lhs,
2323 .op = ast.Node.SuffixOp.Op {
2324 .ArrayAccess = undefined,
2325 },
2326 .rtoken = undefined
2327 });
2328 opt_ctx.store(&node.base);
2329
23702330 stack.append(State { .SuffixOpExpressionEnd = opt_ctx.toRequired() }) catch unreachable;
23712331 try stack.append(State { .SliceOrArrayAccess = node });
23722332 try stack.append(State { .Expression = OptionalCtx { .Required = &node.op.ArrayAccess }});
23732333 continue;
23742334 },
23752335 Token.Id.Period => {
2376 const node = try createToCtxNode(arena, opt_ctx, ast.Node.InfixOp,
2377 ast.Node.InfixOp {
2378 .base = undefined,
2379 .lhs = lhs,
2380 .op_token = token_index,
2381 .op = ast.Node.InfixOp.Op.Period,
2382 .rhs = undefined,
2383 }
2384 );
2336 const node = try arena.construct(ast.Node.InfixOp {
2337 .base = ast.Node {.id = ast.Node.Id.InfixOp },
2338 .lhs = lhs,
2339 .op_token = token_index,
2340 .op = ast.Node.InfixOp.Op.Period,
2341 .rhs = undefined,
2342 });
2343 opt_ctx.store(&node.base);
2344
23852345 stack.append(State { .SuffixOpExpressionEnd = opt_ctx.toRequired() }) catch unreachable;
23862346 try stack.append(State { .Identifier = OptionalCtx { .Required = &node.rhs } });
23872347 continue;
......@@ -2461,14 +2421,14 @@ pub fn parse(allocator: &mem.Allocator, source: []const u8) !ast.Tree {
24612421 continue;
24622422 },
24632423 Token.Id.LParen => {
2464 const node = try createToCtxNode(arena, opt_ctx, ast.Node.GroupedExpression,
2465 ast.Node.GroupedExpression {
2466 .base = undefined,
2467 .lparen = token.index,
2468 .expr = undefined,
2469 .rparen = undefined,
2470 }
2471 );
2424 const node = try arena.construct(ast.Node.GroupedExpression {
2425 .base = ast.Node {.id = ast.Node.Id.GroupedExpression },
2426 .lparen = token.index,
2427 .expr = undefined,
2428 .rparen = undefined,
2429 });
2430 opt_ctx.store(&node.base);
2431
24722432 stack.append(State {
24732433 .ExpectTokenSave = ExpectTokenSave {
24742434 .id = Token.Id.RParen,
......@@ -2479,14 +2439,14 @@ pub fn parse(allocator: &mem.Allocator, source: []const u8) !ast.Tree {
24792439 continue;
24802440 },
24812441 Token.Id.Builtin => {
2482 const node = try createToCtxNode(arena, opt_ctx, ast.Node.BuiltinCall,
2483 ast.Node.BuiltinCall {
2484 .base = undefined,
2485 .builtin_token = token.index,
2486 .params = ast.Node.BuiltinCall.ParamList.init(arena),
2487 .rparen_token = undefined,
2488 }
2489 );
2442 const node = try arena.construct(ast.Node.BuiltinCall {
2443 .base = ast.Node {.id = ast.Node.Id.BuiltinCall },
2444 .builtin_token = token.index,
2445 .params = ast.Node.BuiltinCall.ParamList.init(arena),
2446 .rparen_token = undefined,
2447 });
2448 opt_ctx.store(&node.base);
2449
24902450 stack.append(State {
24912451 .ExprListItemOrEnd = ExprListCtx {
24922452 .list = &node.params,
......@@ -2498,14 +2458,14 @@ pub fn parse(allocator: &mem.Allocator, source: []const u8) !ast.Tree {
24982458 continue;
24992459 },
25002460 Token.Id.LBracket => {
2501 const node = try createToCtxNode(arena, opt_ctx, ast.Node.PrefixOp,
2502 ast.Node.PrefixOp {
2503 .base = undefined,
2504 .op_token = token.index,
2505 .op = undefined,
2506 .rhs = undefined,
2507 }
2508 );
2461 const node = try arena.construct(ast.Node.PrefixOp {
2462 .base = ast.Node {.id = ast.Node.Id.PrefixOp },
2463 .op_token = token.index,
2464 .op = undefined,
2465 .rhs = undefined,
2466 });
2467 opt_ctx.store(&node.base);
2468
25092469 stack.append(State { .SliceOrArrayType = node }) catch unreachable;
25102470 continue;
25112471 },
......@@ -2611,18 +2571,18 @@ pub fn parse(allocator: &mem.Allocator, source: []const u8) !ast.Tree {
26112571 continue;
26122572 },
26132573 Token.Id.Keyword_asm => {
2614 const node = try createToCtxNode(arena, opt_ctx, ast.Node.Asm,
2615 ast.Node.Asm {
2616 .base = undefined,
2617 .asm_token = token.index,
2618 .volatile_token = null,
2619 .template = undefined,
2620 .outputs = ast.Node.Asm.OutputList.init(arena),
2621 .inputs = ast.Node.Asm.InputList.init(arena),
2622 .clobbers = ast.Node.Asm.ClobberList.init(arena),
2623 .rparen = undefined,
2624 }
2625 );
2574 const node = try arena.construct(ast.Node.Asm {
2575 .base = ast.Node {.id = ast.Node.Id.Asm },
2576 .asm_token = token.index,
2577 .volatile_token = null,
2578 .template = undefined,
2579 .outputs = ast.Node.Asm.OutputList.init(arena),
2580 .inputs = ast.Node.Asm.InputList.init(arena),
2581 .clobbers = ast.Node.Asm.ClobberList.init(arena),
2582 .rparen = undefined,
2583 });
2584 opt_ctx.store(&node.base);
2585
26262586 stack.append(State {
26272587 .ExpectTokenSave = ExpectTokenSave {
26282588 .id = Token.Id.RParen,
......@@ -3155,31 +3115,29 @@ fn parseBlockExpr(stack: &std.ArrayList(State), arena: &mem.Allocator, ctx: &con
31553115 token_ptr: &const Token, token_index: TokenIndex) !bool {
31563116 switch (token_ptr.id) {
31573117 Token.Id.Keyword_suspend => {
3158 const node = try createToCtxNode(arena, ctx, ast.Node.Suspend,
3159 ast.Node.Suspend {
3160 .base = undefined,
3161 .label = null,
3162 .suspend_token = token_index,
3163 .payload = null,
3164 .body = null,
3165 }
3166 );
3118 const node = try arena.construct(ast.Node.Suspend {
3119 .base = ast.Node {.id = ast.Node.Id.Suspend },
3120 .label = null,
3121 .suspend_token = token_index,
3122 .payload = null,
3123 .body = null,
3124 });
3125 ctx.store(&node.base);
31673126
31683127 stack.append(State { .SuspendBody = node }) catch unreachable;
31693128 try stack.append(State { .Payload = OptionalCtx { .Optional = &node.payload } });
31703129 return true;
31713130 },
31723131 Token.Id.Keyword_if => {
3173 const node = try createToCtxNode(arena, ctx, ast.Node.If,
3174 ast.Node.If {
3175 .base = undefined,
3176 .if_token = token_index,
3177 .condition = undefined,
3178 .payload = null,
3179 .body = undefined,
3180 .@"else" = null,
3181 }
3182 );
3132 const node = try arena.construct(ast.Node.If {
3133 .base = ast.Node {.id = ast.Node.Id.If },
3134 .if_token = token_index,
3135 .condition = undefined,
3136 .payload = null,
3137 .body = undefined,
3138 .@"else" = null,
3139 });
3140 ctx.store(&node.base);
31833141
31843142 stack.append(State { .Else = &node.@"else" }) catch unreachable;
31853143 try stack.append(State { .Expression = OptionalCtx { .Required = &node.body } });
......@@ -3236,14 +3194,14 @@ fn parseBlockExpr(stack: &std.ArrayList(State), arena: &mem.Allocator, ctx: &con
32363194 return true;
32373195 },
32383196 Token.Id.Keyword_comptime => {
3239 const node = try createToCtxNode(arena, ctx, ast.Node.Comptime,
3240 ast.Node.Comptime {
3241 .base = undefined,
3242 .comptime_token = token_index,
3243 .expr = undefined,
3244 .doc_comments = null,
3245 }
3246 );
3197 const node = try arena.construct(ast.Node.Comptime {
3198 .base = ast.Node {.id = ast.Node.Id.Comptime },
3199 .comptime_token = token_index,
3200 .expr = undefined,
3201 .doc_comments = null,
3202 });
3203 ctx.store(&node.base);
3204
32473205 try stack.append(State { .Expression = OptionalCtx { .Required = &node.expr } });
32483206 return true;
32493207 },
......@@ -3390,33 +3348,11 @@ fn tokenIdToPrefixOp(id: @TagType(Token.Id)) ?ast.Node.PrefixOp.Op {
33903348 };
33913349}
33923350
3393fn createNode(arena: &mem.Allocator, comptime T: type, init_to: &const T) !&T {
3394 const node = try arena.create(T);
3395 *node = *init_to;
3396 node.base = blk: {
3397 const id = ast.Node.typeToId(T);
3398 break :blk ast.Node {
3399 .id = id,
3400 };
3401 };
3402
3403 return node;
3404}
3405
3406fn createToCtxNode(arena: &mem.Allocator, opt_ctx: &const OptionalCtx, comptime T: type, init_to: &const T) !&T {
3407 const node = try createNode(arena, T, init_to);
3408 opt_ctx.store(&node.base);
3409
3410 return node;
3411}
3412
34133351fn createLiteral(arena: &mem.Allocator, comptime T: type, token_index: TokenIndex) !&T {
3414 return createNode(arena, T,
3415 T {
3416 .base = undefined,
3417 .token = token_index,
3418 }
3419 );
3352 return arena.construct(T {
3353 .base = ast.Node {.id = ast.Node.typeToId(T)},
3354 .token = token_index,
3355 });
34203356}
34213357
34223358fn createToCtxLiteral(arena: &mem.Allocator, opt_ctx: &const OptionalCtx, comptime T: type, token_index: TokenIndex) !&T {
std/zig/parser_test.zig+8
......@@ -1,3 +1,11 @@
1//test "zig fmt: same-line doc comment on variable declaration" {
2// try testCanonical(
3// \\pub const MAP_ANONYMOUS = 0x1000; /// allocated from memory, swap space
4// \\pub const MAP_FILE = 0x0000; /// map from file (default)
5// \\
6// );
7//}
8
19test "zig fmt: same-line comment after a statement" {
210 try testCanonical(
311 \\test "" {