authorgravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2018-04-20 02:15:09-04:00
committergravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2018-04-20 02:15:09-04:00
log6e57243a79b08f37b80122f0eb24d073d6e2e95c
treec1b95d61998034b50b558c94f81141eaae8409e0
parentcc35f085cad8a8da1b08ecaf6681f097aca7b604

zig fmt: preserve comments in front of test blocks

* refactor std.zig.parser * fix compiler crashing for some compile errors * take advantage of @field in std.zig.ast * move ast.NodeFoo to ast.Node.Foo * comment preservation is more explicit See #911

3 files changed, 1820 insertions(+), 1852 deletions(-)

src/ir.cpp+4
......@@ -6523,6 +6523,8 @@ static IrInstruction *ir_gen_node_raw(IrBuilder *irb, AstNode *node, Scope *scop
65236523 case NodeTypeFieldAccessExpr:
65246524 {
65256525 IrInstruction *ptr_instruction = ir_gen_field_access(irb, scope, node);
6526 if (ptr_instruction == irb->codegen->invalid_instruction)
6527 return ptr_instruction;
65266528 if (lval.is_ptr)
65276529 return ptr_instruction;
65286530
......@@ -15556,6 +15558,8 @@ static TypeTableEntry *ir_analyze_instruction_field_parent_ptr(IrAnalyze *ira,
1555615558 }
1555715559
1555815560 ensure_complete_type(ira->codegen, container_type);
15561 if (type_is_invalid(container_type))
15562 return ira->codegen->builtin_types.entry_invalid;
1555915563
1556015564 TypeStructField *field = find_struct_type_field(container_type, field_name);
1556115565 if (field == nullptr) {
std/zig/ast.zig+1314-1379
......@@ -6,7 +6,6 @@ const mem = std.mem;
66
77pub const Node = struct {
88 id: Id,
9 comment: ?&NodeLineComment,
109
1110 pub const Id = enum {
1211 // Top level
......@@ -74,1750 +73,1686 @@ pub const Node = struct {
7473 FieldInitializer,
7574 };
7675
77 const IdTypePair = struct {
78 id: Id,
79 Type: type,
80 };
81
82 // TODO: When @field exists, we could generate this by iterating over all members of `Id`,
83 // and making an array of `IdTypePair { .id = @field(Id, @memberName(Id, i)), .Type = @field(ast, "Node" ++ @memberName(Id, i)) }`
84 const idTypeTable = []IdTypePair {
85 IdTypePair { .id = Id.Root, .Type = NodeRoot },
86 IdTypePair { .id = Id.Use, .Type = NodeUse },
87 IdTypePair { .id = Id.TestDecl, .Type = NodeTestDecl },
88
89 IdTypePair { .id = Id.VarDecl, .Type = NodeVarDecl },
90 IdTypePair { .id = Id.Defer, .Type = NodeDefer },
91
92 IdTypePair { .id = Id.InfixOp, .Type = NodeInfixOp },
93 IdTypePair { .id = Id.PrefixOp, .Type = NodePrefixOp },
94 IdTypePair { .id = Id.SuffixOp, .Type = NodeSuffixOp },
95
96 IdTypePair { .id = Id.Switch, .Type = NodeSwitch },
97 IdTypePair { .id = Id.While, .Type = NodeWhile },
98 IdTypePair { .id = Id.For, .Type = NodeFor },
99 IdTypePair { .id = Id.If, .Type = NodeIf },
100 IdTypePair { .id = Id.ControlFlowExpression, .Type = NodeControlFlowExpression },
101 IdTypePair { .id = Id.Suspend, .Type = NodeSuspend },
102
103 IdTypePair { .id = Id.VarType, .Type = NodeVarType },
104 IdTypePair { .id = Id.ErrorType, .Type = NodeErrorType },
105 IdTypePair { .id = Id.FnProto, .Type = NodeFnProto },
106
107 IdTypePair { .id = Id.IntegerLiteral, .Type = NodeIntegerLiteral },
108 IdTypePair { .id = Id.FloatLiteral, .Type = NodeFloatLiteral },
109 IdTypePair { .id = Id.StringLiteral, .Type = NodeStringLiteral },
110 IdTypePair { .id = Id.MultilineStringLiteral, .Type = NodeMultilineStringLiteral },
111 IdTypePair { .id = Id.CharLiteral, .Type = NodeCharLiteral },
112 IdTypePair { .id = Id.BoolLiteral, .Type = NodeBoolLiteral },
113 IdTypePair { .id = Id.NullLiteral, .Type = NodeNullLiteral },
114 IdTypePair { .id = Id.UndefinedLiteral, .Type = NodeUndefinedLiteral },
115 IdTypePair { .id = Id.ThisLiteral, .Type = NodeThisLiteral },
116 IdTypePair { .id = Id.Unreachable, .Type = NodeUnreachable },
117 IdTypePair { .id = Id.Identifier, .Type = NodeIdentifier },
118 IdTypePair { .id = Id.GroupedExpression, .Type = NodeGroupedExpression },
119 IdTypePair { .id = Id.BuiltinCall, .Type = NodeBuiltinCall },
120 IdTypePair { .id = Id.ErrorSetDecl, .Type = NodeErrorSetDecl },
121 IdTypePair { .id = Id.ContainerDecl, .Type = NodeContainerDecl },
122 IdTypePair { .id = Id.Asm, .Type = NodeAsm },
123 IdTypePair { .id = Id.Comptime, .Type = NodeComptime },
124 IdTypePair { .id = Id.Block, .Type = NodeBlock },
125
126 IdTypePair { .id = Id.LineComment, .Type = NodeLineComment },
127 IdTypePair { .id = Id.SwitchCase, .Type = NodeSwitchCase },
128 IdTypePair { .id = Id.SwitchElse, .Type = NodeSwitchElse },
129 IdTypePair { .id = Id.Else, .Type = NodeElse },
130 IdTypePair { .id = Id.Payload, .Type = NodePayload },
131 IdTypePair { .id = Id.PointerPayload, .Type = NodePointerPayload },
132 IdTypePair { .id = Id.PointerIndexPayload, .Type = NodePointerIndexPayload },
133 IdTypePair { .id = Id.StructField, .Type = NodeStructField },
134 IdTypePair { .id = Id.UnionTag, .Type = NodeUnionTag },
135 IdTypePair { .id = Id.EnumTag, .Type = NodeEnumTag },
136 IdTypePair { .id = Id.AsmInput, .Type = NodeAsmInput },
137 IdTypePair { .id = Id.AsmOutput, .Type = NodeAsmOutput },
138 IdTypePair { .id = Id.AsyncAttribute, .Type = NodeAsyncAttribute },
139 IdTypePair { .id = Id.ParamDecl, .Type = NodeParamDecl },
140 IdTypePair { .id = Id.FieldInitializer, .Type = NodeFieldInitializer },
141 };
142
143 pub fn IdToType(comptime id: Id) type {
144 inline for (idTypeTable) |id_type_pair| {
145 if (id == id_type_pair.id)
146 return id_type_pair.Type;
147 }
148
149 unreachable;
150 }
151
152 pub fn typeToId(comptime T: type) Id {
153 inline for (idTypeTable) |id_type_pair| {
154 if (T == id_type_pair.Type)
155 return id_type_pair.id;
156 }
157
158 unreachable;
159 }
160
16176 pub fn iterate(base: &Node, index: usize) ?&Node {
162 inline for (idTypeTable) |id_type_pair| {
163 if (base.id == id_type_pair.id)
164 return @fieldParentPtr(id_type_pair.Type, "base", base).iterate(index);
77 comptime var i = 0;
78 inline while (i < @memberCount(Id)) : (i += 1) {
79 if (base.id == @field(Id, @memberName(Id, i))) {
80 const T = @field(Node, @memberName(Id, i));
81 return @fieldParentPtr(T, "base", base).iterate(index);
82 }
16583 }
166
16784 unreachable;
16885 }
16986
17087 pub fn firstToken(base: &Node) Token {
171 inline for (idTypeTable) |id_type_pair| {
172 if (base.id == id_type_pair.id)
173 return @fieldParentPtr(id_type_pair.Type, "base", base).firstToken();
88 comptime var i = 0;
89 inline while (i < @memberCount(Id)) : (i += 1) {
90 if (base.id == @field(Id, @memberName(Id, i))) {
91 const T = @field(Node, @memberName(Id, i));
92 return @fieldParentPtr(T, "base", base).firstToken();
93 }
17494 }
175
17695 unreachable;
17796 }
17897
17998 pub fn lastToken(base: &Node) Token {
180 inline for (idTypeTable) |id_type_pair| {
181 if (base.id == id_type_pair.id)
182 return @fieldParentPtr(id_type_pair.Type, "base", base).lastToken();
99 comptime var i = 0;
100 inline while (i < @memberCount(Id)) : (i += 1) {
101 if (base.id == @field(Id, @memberName(Id, i))) {
102 const T = @field(Node, @memberName(Id, i));
103 return @fieldParentPtr(T, "base", base).lastToken();
104 }
183105 }
184
185106 unreachable;
186107 }
187};
188108
189pub const NodeRoot = struct {
190 base: Node,
191 decls: ArrayList(&Node),
192 eof_token: Token,
193
194 pub fn iterate(self: &NodeRoot, index: usize) ?&Node {
195 if (index < self.decls.len) {
196 return self.decls.items[self.decls.len - index - 1];
109 pub fn typeToId(comptime T: type) Id {
110 comptime var i = 0;
111 inline while (i < @memberCount(Id)) : (i += 1) {
112 if (T == @field(Node, @memberName(Id, i))) {
113 return @field(Id, @memberName(Id, i));
114 }
197115 }
198 return null;
199 }
200
201 pub fn firstToken(self: &NodeRoot) Token {
202 return if (self.decls.len == 0) self.eof_token else self.decls.at(0).firstToken();
116 unreachable;
203117 }
204118
205 pub fn lastToken(self: &NodeRoot) Token {
206 return if (self.decls.len == 0) self.eof_token else self.decls.at(self.decls.len - 1).lastToken();
207 }
208};
119 pub const Root = struct {
120 base: Node,
121 decls: ArrayList(&Node),
122 eof_token: Token,
209123
210pub const NodeVarDecl = struct {
211 base: Node,
212 visib_token: ?Token,
213 name_token: Token,
214 eq_token: Token,
215 mut_token: Token,
216 comptime_token: ?Token,
217 extern_export_token: ?Token,
218 lib_name: ?&Node,
219 type_node: ?&Node,
220 align_node: ?&Node,
221 init_node: ?&Node,
222 semicolon_token: Token,
223
224 pub fn iterate(self: &NodeVarDecl, index: usize) ?&Node {
225 var i = index;
226
227 if (self.type_node) |type_node| {
228 if (i < 1) return type_node;
229 i -= 1;
124 pub fn iterate(self: &Root, index: usize) ?&Node {
125 if (index < self.decls.len) {
126 return self.decls.items[self.decls.len - index - 1];
127 }
128 return null;
230129 }
231130
232 if (self.align_node) |align_node| {
233 if (i < 1) return align_node;
234 i -= 1;
131 pub fn firstToken(self: &Root) Token {
132 return if (self.decls.len == 0) self.eof_token else self.decls.at(0).firstToken();
235133 }
236134
237 if (self.init_node) |init_node| {
238 if (i < 1) return init_node;
239 i -= 1;
135 pub fn lastToken(self: &Root) Token {
136 return if (self.decls.len == 0) self.eof_token else self.decls.at(self.decls.len - 1).lastToken();
240137 }
138 };
241139
242 return null;
243 }
244
245 pub fn firstToken(self: &NodeVarDecl) Token {
246 if (self.visib_token) |visib_token| return visib_token;
247 if (self.comptime_token) |comptime_token| return comptime_token;
248 if (self.extern_export_token) |extern_export_token| return extern_export_token;
249 assert(self.lib_name == null);
250 return self.mut_token;
251 }
252
253 pub fn lastToken(self: &NodeVarDecl) Token {
254 return self.semicolon_token;
255 }
256};
257
258pub const NodeUse = struct {
259 base: Node,
260 visib_token: ?Token,
261 expr: &Node,
262 semicolon_token: Token,
263
264 pub fn iterate(self: &NodeUse, index: usize) ?&Node {
265 var i = index;
140 pub const VarDecl = struct {
141 base: Node,
142 comments: ?&LineComment,
143 visib_token: ?Token,
144 name_token: Token,
145 eq_token: Token,
146 mut_token: Token,
147 comptime_token: ?Token,
148 extern_export_token: ?Token,
149 lib_name: ?&Node,
150 type_node: ?&Node,
151 align_node: ?&Node,
152 init_node: ?&Node,
153 semicolon_token: Token,
154
155 pub fn iterate(self: &VarDecl, index: usize) ?&Node {
156 var i = index;
157
158 if (self.type_node) |type_node| {
159 if (i < 1) return type_node;
160 i -= 1;
161 }
266162
267 if (i < 1) return self.expr;
268 i -= 1;
163 if (self.align_node) |align_node| {
164 if (i < 1) return align_node;
165 i -= 1;
166 }
269167
270 return null;
271 }
168 if (self.init_node) |init_node| {
169 if (i < 1) return init_node;
170 i -= 1;
171 }
272172
273 pub fn firstToken(self: &NodeUse) Token {
274 if (self.visib_token) |visib_token| return visib_token;
275 return self.expr.firstToken();
276 }
173 return null;
174 }
277175
278 pub fn lastToken(self: &NodeUse) Token {
279 return self.semicolon_token;
280 }
281};
176 pub fn firstToken(self: &VarDecl) Token {
177 if (self.visib_token) |visib_token| return visib_token;
178 if (self.comptime_token) |comptime_token| return comptime_token;
179 if (self.extern_export_token) |extern_export_token| return extern_export_token;
180 assert(self.lib_name == null);
181 return self.mut_token;
182 }
282183
283pub const NodeErrorSetDecl = struct {
284 base: Node,
285 error_token: Token,
286 decls: ArrayList(&Node),
287 rbrace_token: Token,
184 pub fn lastToken(self: &VarDecl) Token {
185 return self.semicolon_token;
186 }
187 };
288188
289 pub fn iterate(self: &NodeErrorSetDecl, index: usize) ?&Node {
290 var i = index;
189 pub const Use = struct {
190 base: Node,
191 visib_token: ?Token,
192 expr: &Node,
193 semicolon_token: Token,
291194
292 if (i < self.decls.len) return self.decls.at(i);
293 i -= self.decls.len;
195 pub fn iterate(self: &Use, index: usize) ?&Node {
196 var i = index;
294197
295 return null;
296 }
198 if (i < 1) return self.expr;
199 i -= 1;
297200
298 pub fn firstToken(self: &NodeErrorSetDecl) Token {
299 return self.error_token;
300 }
201 return null;
202 }
301203
302 pub fn lastToken(self: &NodeErrorSetDecl) Token {
303 return self.rbrace_token;
304 }
305};
204 pub fn firstToken(self: &Use) Token {
205 if (self.visib_token) |visib_token| return visib_token;
206 return self.expr.firstToken();
207 }
306208
307pub const NodeContainerDecl = struct {
308 base: Node,
309 ltoken: Token,
310 layout: Layout,
311 kind: Kind,
312 init_arg_expr: InitArg,
313 fields_and_decls: ArrayList(&Node),
314 rbrace_token: Token,
315
316 const Layout = enum {
317 Auto,
318 Extern,
319 Packed,
209 pub fn lastToken(self: &Use) Token {
210 return self.semicolon_token;
211 }
320212 };
321213
322 const Kind = enum {
323 Struct,
324 Enum,
325 Union,
326 };
214 pub const ErrorSetDecl = struct {
215 base: Node,
216 error_token: Token,
217 decls: ArrayList(&Node),
218 rbrace_token: Token,
327219
328 const InitArg = union(enum) {
329 None,
330 Enum,
331 Type: &Node,
332 };
220 pub fn iterate(self: &ErrorSetDecl, index: usize) ?&Node {
221 var i = index;
333222
334 pub fn iterate(self: &NodeContainerDecl, index: usize) ?&Node {
335 var i = index;
223 if (i < self.decls.len) return self.decls.at(i);
224 i -= self.decls.len;
336225
337 switch (self.init_arg_expr) {
338 InitArg.Type => |t| {
339 if (i < 1) return t;
340 i -= 1;
341 },
342 InitArg.None,
343 InitArg.Enum => { }
226 return null;
344227 }
345228
346 if (i < self.fields_and_decls.len) return self.fields_and_decls.at(i);
347 i -= self.fields_and_decls.len;
229 pub fn firstToken(self: &ErrorSetDecl) Token {
230 return self.error_token;
231 }
348232
349 return null;
350 }
233 pub fn lastToken(self: &ErrorSetDecl) Token {
234 return self.rbrace_token;
235 }
236 };
351237
352 pub fn firstToken(self: &NodeContainerDecl) Token {
353 return self.ltoken;
354 }
238 pub const ContainerDecl = struct {
239 base: Node,
240 ltoken: Token,
241 layout: Layout,
242 kind: Kind,
243 init_arg_expr: InitArg,
244 fields_and_decls: ArrayList(&Node),
245 rbrace_token: Token,
246
247 const Layout = enum {
248 Auto,
249 Extern,
250 Packed,
251 };
355252
356 pub fn lastToken(self: &NodeContainerDecl) Token {
357 return self.rbrace_token;
358 }
359};
253 const Kind = enum {
254 Struct,
255 Enum,
256 Union,
257 };
258
259 const InitArg = union(enum) {
260 None,
261 Enum,
262 Type: &Node,
263 };
360264
361pub const NodeStructField = struct {
362 base: Node,
363 visib_token: ?Token,
364 name_token: Token,
365 type_expr: &Node,
265 pub fn iterate(self: &ContainerDecl, index: usize) ?&Node {
266 var i = index;
366267
367 pub fn iterate(self: &NodeStructField, index: usize) ?&Node {
368 var i = index;
268 switch (self.init_arg_expr) {
269 InitArg.Type => |t| {
270 if (i < 1) return t;
271 i -= 1;
272 },
273 InitArg.None,
274 InitArg.Enum => { }
275 }
369276
370 if (i < 1) return self.type_expr;
371 i -= 1;
277 if (i < self.fields_and_decls.len) return self.fields_and_decls.at(i);
278 i -= self.fields_and_decls.len;
372279
373 return null;
374 }
280 return null;
281 }
375282
376 pub fn firstToken(self: &NodeStructField) Token {
377 if (self.visib_token) |visib_token| return visib_token;
378 return self.name_token;
379 }
283 pub fn firstToken(self: &ContainerDecl) Token {
284 return self.ltoken;
285 }
380286
381 pub fn lastToken(self: &NodeStructField) Token {
382 return self.type_expr.lastToken();
383 }
384};
287 pub fn lastToken(self: &ContainerDecl) Token {
288 return self.rbrace_token;
289 }
290 };
385291
386pub const NodeUnionTag = struct {
387 base: Node,
388 name_token: Token,
389 type_expr: ?&Node,
292 pub const StructField = struct {
293 base: Node,
294 visib_token: ?Token,
295 name_token: Token,
296 type_expr: &Node,
390297
391 pub fn iterate(self: &NodeUnionTag, index: usize) ?&Node {
392 var i = index;
298 pub fn iterate(self: &StructField, index: usize) ?&Node {
299 var i = index;
393300
394 if (self.type_expr) |type_expr| {
395 if (i < 1) return type_expr;
301 if (i < 1) return self.type_expr;
396302 i -= 1;
397 }
398303
399 return null;
400 }
304 return null;
305 }
401306
402 pub fn firstToken(self: &NodeUnionTag) Token {
403 return self.name_token;
404 }
307 pub fn firstToken(self: &StructField) Token {
308 if (self.visib_token) |visib_token| return visib_token;
309 return self.name_token;
310 }
405311
406 pub fn lastToken(self: &NodeUnionTag) Token {
407 if (self.type_expr) |type_expr| {
408 return type_expr.lastToken();
312 pub fn lastToken(self: &StructField) Token {
313 return self.type_expr.lastToken();
409314 }
315 };
410316
411 return self.name_token;
412 }
413};
317 pub const UnionTag = struct {
318 base: Node,
319 name_token: Token,
320 type_expr: ?&Node,
414321
415pub const NodeEnumTag = struct {
416 base: Node,
417 name_token: Token,
418 value: ?&Node,
322 pub fn iterate(self: &UnionTag, index: usize) ?&Node {
323 var i = index;
419324
420 pub fn iterate(self: &NodeEnumTag, index: usize) ?&Node {
421 var i = index;
325 if (self.type_expr) |type_expr| {
326 if (i < 1) return type_expr;
327 i -= 1;
328 }
422329
423 if (self.value) |value| {
424 if (i < 1) return value;
425 i -= 1;
330 return null;
426331 }
427332
428 return null;
429 }
333 pub fn firstToken(self: &UnionTag) Token {
334 return self.name_token;
335 }
430336
431 pub fn firstToken(self: &NodeEnumTag) Token {
432 return self.name_token;
433 }
337 pub fn lastToken(self: &UnionTag) Token {
338 if (self.type_expr) |type_expr| {
339 return type_expr.lastToken();
340 }
434341
435 pub fn lastToken(self: &NodeEnumTag) Token {
436 if (self.value) |value| {
437 return value.lastToken();
342 return self.name_token;
438343 }
344 };
439345
440 return self.name_token;
441 }
442};
443
444pub const NodeIdentifier = struct {
445 base: Node,
446 token: Token,
346 pub const EnumTag = struct {
347 base: Node,
348 name_token: Token,
349 value: ?&Node,
447350
448 pub fn iterate(self: &NodeIdentifier, index: usize) ?&Node {
449 return null;
450 }
351 pub fn iterate(self: &EnumTag, index: usize) ?&Node {
352 var i = index;
451353
452 pub fn firstToken(self: &NodeIdentifier) Token {
453 return self.token;
454 }
354 if (self.value) |value| {
355 if (i < 1) return value;
356 i -= 1;
357 }
455358
456 pub fn lastToken(self: &NodeIdentifier) Token {
457 return self.token;
458 }
459};
359 return null;
360 }
460361
461pub const NodeAsyncAttribute = struct {
462 base: Node,
463 async_token: Token,
464 allocator_type: ?&Node,
465 rangle_bracket: ?Token,
362 pub fn firstToken(self: &EnumTag) Token {
363 return self.name_token;
364 }
466365
467 pub fn iterate(self: &NodeAsyncAttribute, index: usize) ?&Node {
468 var i = index;
366 pub fn lastToken(self: &EnumTag) Token {
367 if (self.value) |value| {
368 return value.lastToken();
369 }
469370
470 if (self.allocator_type) |allocator_type| {
471 if (i < 1) return allocator_type;
472 i -= 1;
371 return self.name_token;
473372 }
373 };
474374
475 return null;
476 }
477
478 pub fn firstToken(self: &NodeAsyncAttribute) Token {
479 return self.async_token;
480 }
375 pub const Identifier = struct {
376 base: Node,
377 token: Token,
481378
482 pub fn lastToken(self: &NodeAsyncAttribute) Token {
483 if (self.rangle_bracket) |rangle_bracket| {
484 return rangle_bracket;
379 pub fn iterate(self: &Identifier, index: usize) ?&Node {
380 return null;
485381 }
486382
487 return self.async_token;
488 }
489};
383 pub fn firstToken(self: &Identifier) Token {
384 return self.token;
385 }
490386
491pub const NodeFnProto = struct {
492 base: Node,
493 visib_token: ?Token,
494 fn_token: Token,
495 name_token: ?Token,
496 params: ArrayList(&Node),
497 return_type: ReturnType,
498 var_args_token: ?Token,
499 extern_export_inline_token: ?Token,
500 cc_token: ?Token,
501 async_attr: ?&NodeAsyncAttribute,
502 body_node: ?&Node,
503 lib_name: ?&Node, // populated if this is an extern declaration
504 align_expr: ?&Node, // populated if align(A) is present
505
506 pub const ReturnType = union(enum) {
507 Explicit: &Node,
508 InferErrorSet: &Node,
387 pub fn lastToken(self: &Identifier) Token {
388 return self.token;
389 }
509390 };
510391
511 pub fn iterate(self: &NodeFnProto, index: usize) ?&Node {
512 var i = index;
392 pub const AsyncAttribute = struct {
393 base: Node,
394 async_token: Token,
395 allocator_type: ?&Node,
396 rangle_bracket: ?Token,
513397
514 if (self.body_node) |body_node| {
515 if (i < 1) return body_node;
516 i -= 1;
517 }
398 pub fn iterate(self: &AsyncAttribute, index: usize) ?&Node {
399 var i = index;
518400
519 switch (self.return_type) {
520 // TODO allow this and next prong to share bodies since the types are the same
521 ReturnType.Explicit => |node| {
522 if (i < 1) return node;
401 if (self.allocator_type) |allocator_type| {
402 if (i < 1) return allocator_type;
523403 i -= 1;
524 },
525 ReturnType.InferErrorSet => |node| {
526 if (i < 1) return node;
527 i -= 1;
528 },
404 }
405
406 return null;
529407 }
530408
531 if (self.align_expr) |align_expr| {
532 if (i < 1) return align_expr;
533 i -= 1;
409 pub fn firstToken(self: &AsyncAttribute) Token {
410 return self.async_token;
534411 }
535412
536 if (i < self.params.len) return self.params.items[self.params.len - i - 1];
537 i -= self.params.len;
413 pub fn lastToken(self: &AsyncAttribute) Token {
414 if (self.rangle_bracket) |rangle_bracket| {
415 return rangle_bracket;
416 }
538417
539 if (self.lib_name) |lib_name| {
540 if (i < 1) return lib_name;
541 i -= 1;
418 return self.async_token;
542419 }
420 };
543421
544 return null;
545 }
422 pub const FnProto = struct {
423 base: Node,
424 comments: ?&LineComment,
425 visib_token: ?Token,
426 fn_token: Token,
427 name_token: ?Token,
428 params: ArrayList(&Node),
429 return_type: ReturnType,
430 var_args_token: ?Token,
431 extern_export_inline_token: ?Token,
432 cc_token: ?Token,
433 async_attr: ?&AsyncAttribute,
434 body_node: ?&Node,
435 lib_name: ?&Node, // populated if this is an extern declaration
436 align_expr: ?&Node, // populated if align(A) is present
437
438 pub const ReturnType = union(enum) {
439 Explicit: &Node,
440 InferErrorSet: &Node,
441 };
546442
547 pub fn firstToken(self: &NodeFnProto) Token {
548 if (self.visib_token) |visib_token| return visib_token;
549 if (self.extern_export_inline_token) |extern_export_inline_token| return extern_export_inline_token;
550 assert(self.lib_name == null);
551 if (self.cc_token) |cc_token| return cc_token;
552 return self.fn_token;
553 }
443 pub fn iterate(self: &FnProto, index: usize) ?&Node {
444 var i = index;
554445
555 pub fn lastToken(self: &NodeFnProto) Token {
556 if (self.body_node) |body_node| return body_node.lastToken();
557 switch (self.return_type) {
558 // TODO allow this and next prong to share bodies since the types are the same
559 ReturnType.Explicit => |node| return node.lastToken(),
560 ReturnType.InferErrorSet => |node| return node.lastToken(),
561 }
562 }
563};
446 if (self.body_node) |body_node| {
447 if (i < 1) return body_node;
448 i -= 1;
449 }
564450
565pub const NodeParamDecl = struct {
566 base: Node,
567 comptime_token: ?Token,
568 noalias_token: ?Token,
569 name_token: ?Token,
570 type_node: &Node,
571 var_args_token: ?Token,
451 switch (self.return_type) {
452 // TODO allow this and next prong to share bodies since the types are the same
453 ReturnType.Explicit => |node| {
454 if (i < 1) return node;
455 i -= 1;
456 },
457 ReturnType.InferErrorSet => |node| {
458 if (i < 1) return node;
459 i -= 1;
460 },
461 }
572462
573 pub fn iterate(self: &NodeParamDecl, index: usize) ?&Node {
574 var i = index;
463 if (self.align_expr) |align_expr| {
464 if (i < 1) return align_expr;
465 i -= 1;
466 }
575467
576 if (i < 1) return self.type_node;
577 i -= 1;
468 if (i < self.params.len) return self.params.items[self.params.len - i - 1];
469 i -= self.params.len;
578470
579 return null;
580 }
471 if (self.lib_name) |lib_name| {
472 if (i < 1) return lib_name;
473 i -= 1;
474 }
581475
582 pub fn firstToken(self: &NodeParamDecl) Token {
583 if (self.comptime_token) |comptime_token| return comptime_token;
584 if (self.noalias_token) |noalias_token| return noalias_token;
585 if (self.name_token) |name_token| return name_token;
586 return self.type_node.firstToken();
587 }
476 return null;
477 }
588478
589 pub fn lastToken(self: &NodeParamDecl) Token {
590 if (self.var_args_token) |var_args_token| return var_args_token;
591 return self.type_node.lastToken();
592 }
593};
479 pub fn firstToken(self: &FnProto) Token {
480 if (self.visib_token) |visib_token| return visib_token;
481 if (self.extern_export_inline_token) |extern_export_inline_token| return extern_export_inline_token;
482 assert(self.lib_name == null);
483 if (self.cc_token) |cc_token| return cc_token;
484 return self.fn_token;
485 }
594486
595pub const NodeBlock = struct {
596 base: Node,
597 label: ?Token,
598 lbrace: Token,
599 statements: ArrayList(&Node),
600 rbrace: Token,
487 pub fn lastToken(self: &FnProto) Token {
488 if (self.body_node) |body_node| return body_node.lastToken();
489 switch (self.return_type) {
490 // TODO allow this and next prong to share bodies since the types are the same
491 ReturnType.Explicit => |node| return node.lastToken(),
492 ReturnType.InferErrorSet => |node| return node.lastToken(),
493 }
494 }
495 };
601496
602 pub fn iterate(self: &NodeBlock, index: usize) ?&Node {
603 var i = index;
497 pub const ParamDecl = struct {
498 base: Node,
499 comptime_token: ?Token,
500 noalias_token: ?Token,
501 name_token: ?Token,
502 type_node: &Node,
503 var_args_token: ?Token,
604504
605 if (i < self.statements.len) return self.statements.items[i];
606 i -= self.statements.len;
505 pub fn iterate(self: &ParamDecl, index: usize) ?&Node {
506 var i = index;
607507
608 return null;
609 }
508 if (i < 1) return self.type_node;
509 i -= 1;
610510
611 pub fn firstToken(self: &NodeBlock) Token {
612 if (self.label) |label| {
613 return label;
511 return null;
614512 }
615513
616 return self.lbrace;
617 }
514 pub fn firstToken(self: &ParamDecl) Token {
515 if (self.comptime_token) |comptime_token| return comptime_token;
516 if (self.noalias_token) |noalias_token| return noalias_token;
517 if (self.name_token) |name_token| return name_token;
518 return self.type_node.firstToken();
519 }
618520
619 pub fn lastToken(self: &NodeBlock) Token {
620 return self.rbrace;
621 }
622};
521 pub fn lastToken(self: &ParamDecl) Token {
522 if (self.var_args_token) |var_args_token| return var_args_token;
523 return self.type_node.lastToken();
524 }
525 };
623526
624pub const NodeDefer = struct {
625 base: Node,
626 defer_token: Token,
627 kind: Kind,
628 expr: &Node,
527 pub const Block = struct {
528 base: Node,
529 label: ?Token,
530 lbrace: Token,
531 statements: ArrayList(&Node),
532 rbrace: Token,
629533
630 const Kind = enum {
631 Error,
632 Unconditional,
633 };
534 pub fn iterate(self: &Block, index: usize) ?&Node {
535 var i = index;
634536
635 pub fn iterate(self: &NodeDefer, index: usize) ?&Node {
636 var i = index;
537 if (i < self.statements.len) return self.statements.items[i];
538 i -= self.statements.len;
637539
638 if (i < 1) return self.expr;
639 i -= 1;
540 return null;
541 }
640542
641 return null;
642 }
543 pub fn firstToken(self: &Block) Token {
544 if (self.label) |label| {
545 return label;
546 }
643547
644 pub fn firstToken(self: &NodeDefer) Token {
645 return self.defer_token;
646 }
548 return self.lbrace;
549 }
647550
648 pub fn lastToken(self: &NodeDefer) Token {
649 return self.expr.lastToken();
650 }
651};
551 pub fn lastToken(self: &Block) Token {
552 return self.rbrace;
553 }
554 };
652555
653pub const NodeComptime = struct {
654 base: Node,
655 comptime_token: Token,
656 expr: &Node,
556 pub const Defer = struct {
557 base: Node,
558 defer_token: Token,
559 kind: Kind,
560 expr: &Node,
657561
658 pub fn iterate(self: &NodeComptime, index: usize) ?&Node {
659 var i = index;
562 const Kind = enum {
563 Error,
564 Unconditional,
565 };
660566
661 if (i < 1) return self.expr;
662 i -= 1;
567 pub fn iterate(self: &Defer, index: usize) ?&Node {
568 var i = index;
663569
664 return null;
665 }
570 if (i < 1) return self.expr;
571 i -= 1;
666572
667 pub fn firstToken(self: &NodeComptime) Token {
668 return self.comptime_token;
669 }
573 return null;
574 }
670575
671 pub fn lastToken(self: &NodeComptime) Token {
672 return self.expr.lastToken();
673 }
674};
576 pub fn firstToken(self: &Defer) Token {
577 return self.defer_token;
578 }
675579
676pub const NodePayload = struct {
677 base: Node,
678 lpipe: Token,
679 error_symbol: &Node,
680 rpipe: Token,
580 pub fn lastToken(self: &Defer) Token {
581 return self.expr.lastToken();
582 }
583 };
681584
682 pub fn iterate(self: &NodePayload, index: usize) ?&Node {
683 var i = index;
585 pub const Comptime = struct {
586 base: Node,
587 comptime_token: Token,
588 expr: &Node,
684589
685 if (i < 1) return self.error_symbol;
686 i -= 1;
590 pub fn iterate(self: &Comptime, index: usize) ?&Node {
591 var i = index;
687592
688 return null;
689 }
593 if (i < 1) return self.expr;
594 i -= 1;
690595
691 pub fn firstToken(self: &NodePayload) Token {
692 return self.lpipe;
693 }
596 return null;
597 }
694598
695 pub fn lastToken(self: &NodePayload) Token {
696 return self.rpipe;
697 }
698};
599 pub fn firstToken(self: &Comptime) Token {
600 return self.comptime_token;
601 }
699602
700pub const NodePointerPayload = struct {
701 base: Node,
702 lpipe: Token,
703 ptr_token: ?Token,
704 value_symbol: &Node,
705 rpipe: Token,
603 pub fn lastToken(self: &Comptime) Token {
604 return self.expr.lastToken();
605 }
606 };
706607
707 pub fn iterate(self: &NodePointerPayload, index: usize) ?&Node {
708 var i = index;
608 pub const Payload = struct {
609 base: Node,
610 lpipe: Token,
611 error_symbol: &Node,
612 rpipe: Token,
709613
710 if (i < 1) return self.value_symbol;
711 i -= 1;
614 pub fn iterate(self: &Payload, index: usize) ?&Node {
615 var i = index;
712616
713 return null;
714 }
617 if (i < 1) return self.error_symbol;
618 i -= 1;
715619
716 pub fn firstToken(self: &NodePointerPayload) Token {
717 return self.lpipe;
718 }
620 return null;
621 }
719622
720 pub fn lastToken(self: &NodePointerPayload) Token {
721 return self.rpipe;
722 }
723};
623 pub fn firstToken(self: &Payload) Token {
624 return self.lpipe;
625 }
724626
725pub const NodePointerIndexPayload = struct {
726 base: Node,
727 lpipe: Token,
728 ptr_token: ?Token,
729 value_symbol: &Node,
730 index_symbol: ?&Node,
731 rpipe: Token,
627 pub fn lastToken(self: &Payload) Token {
628 return self.rpipe;
629 }
630 };
732631
733 pub fn iterate(self: &NodePointerIndexPayload, index: usize) ?&Node {
734 var i = index;
632 pub const PointerPayload = struct {
633 base: Node,
634 lpipe: Token,
635 ptr_token: ?Token,
636 value_symbol: &Node,
637 rpipe: Token,
735638
736 if (i < 1) return self.value_symbol;
737 i -= 1;
639 pub fn iterate(self: &PointerPayload, index: usize) ?&Node {
640 var i = index;
738641
739 if (self.index_symbol) |index_symbol| {
740 if (i < 1) return index_symbol;
642 if (i < 1) return self.value_symbol;
741643 i -= 1;
742 }
743644
744 return null;
745 }
645 return null;
646 }
746647
747 pub fn firstToken(self: &NodePointerIndexPayload) Token {
748 return self.lpipe;
749 }
648 pub fn firstToken(self: &PointerPayload) Token {
649 return self.lpipe;
650 }
750651
751 pub fn lastToken(self: &NodePointerIndexPayload) Token {
752 return self.rpipe;
753 }
754};
652 pub fn lastToken(self: &PointerPayload) Token {
653 return self.rpipe;
654 }
655 };
755656
756pub const NodeElse = struct {
757 base: Node,
758 else_token: Token,
759 payload: ?&Node,
760 body: &Node,
657 pub const PointerIndexPayload = struct {
658 base: Node,
659 lpipe: Token,
660 ptr_token: ?Token,
661 value_symbol: &Node,
662 index_symbol: ?&Node,
663 rpipe: Token,
761664
762 pub fn iterate(self: &NodeElse, index: usize) ?&Node {
763 var i = index;
665 pub fn iterate(self: &PointerIndexPayload, index: usize) ?&Node {
666 var i = index;
764667
765 if (self.payload) |payload| {
766 if (i < 1) return payload;
668 if (i < 1) return self.value_symbol;
767669 i -= 1;
768 }
769670
770 if (i < 1) return self.body;
771 i -= 1;
772
773 return null;
774 }
671 if (self.index_symbol) |index_symbol| {
672 if (i < 1) return index_symbol;
673 i -= 1;
674 }
775675
776 pub fn firstToken(self: &NodeElse) Token {
777 return self.else_token;
778 }
676 return null;
677 }
779678
780 pub fn lastToken(self: &NodeElse) Token {
781 return self.body.lastToken();
782 }
783};
679 pub fn firstToken(self: &PointerIndexPayload) Token {
680 return self.lpipe;
681 }
784682
785pub const NodeSwitch = struct {
786 base: Node,
787 switch_token: Token,
788 expr: &Node,
789 cases: ArrayList(&NodeSwitchCase),
790 rbrace: Token,
683 pub fn lastToken(self: &PointerIndexPayload) Token {
684 return self.rpipe;
685 }
686 };
791687
792 pub fn iterate(self: &NodeSwitch, index: usize) ?&Node {
793 var i = index;
688 pub const Else = struct {
689 base: Node,
690 else_token: Token,
691 payload: ?&Node,
692 body: &Node,
794693
795 if (i < 1) return self.expr;
796 i -= 1;
694 pub fn iterate(self: &Else, index: usize) ?&Node {
695 var i = index;
797696
798 if (i < self.cases.len) return &self.cases.at(i).base;
799 i -= self.cases.len;
697 if (self.payload) |payload| {
698 if (i < 1) return payload;
699 i -= 1;
700 }
800701
801 return null;
802 }
702 if (i < 1) return self.body;
703 i -= 1;
803704
804 pub fn firstToken(self: &NodeSwitch) Token {
805 return self.switch_token;
806 }
705 return null;
706 }
807707
808 pub fn lastToken(self: &NodeSwitch) Token {
809 return self.rbrace;
810 }
811};
708 pub fn firstToken(self: &Else) Token {
709 return self.else_token;
710 }
812711
813pub const NodeSwitchCase = struct {
814 base: Node,
815 items: ArrayList(&Node),
816 payload: ?&Node,
817 expr: &Node,
712 pub fn lastToken(self: &Else) Token {
713 return self.body.lastToken();
714 }
715 };
818716
819 pub fn iterate(self: &NodeSwitchCase, index: usize) ?&Node {
820 var i = index;
717 pub const Switch = struct {
718 base: Node,
719 switch_token: Token,
720 expr: &Node,
721 cases: ArrayList(&SwitchCase),
722 rbrace: Token,
821723
822 if (i < self.items.len) return self.items.at(i);
823 i -= self.items.len;
724 pub fn iterate(self: &Switch, index: usize) ?&Node {
725 var i = index;
824726
825 if (self.payload) |payload| {
826 if (i < 1) return payload;
727 if (i < 1) return self.expr;
827728 i -= 1;
828 }
829729
830 if (i < 1) return self.expr;
831 i -= 1;
730 if (i < self.cases.len) return &self.cases.at(i).base;
731 i -= self.cases.len;
832732
833 return null;
834 }
733 return null;
734 }
835735
836 pub fn firstToken(self: &NodeSwitchCase) Token {
837 return self.items.at(0).firstToken();
838 }
736 pub fn firstToken(self: &Switch) Token {
737 return self.switch_token;
738 }
839739
840 pub fn lastToken(self: &NodeSwitchCase) Token {
841 return self.expr.lastToken();
842 }
843};
740 pub fn lastToken(self: &Switch) Token {
741 return self.rbrace;
742 }
743 };
844744
845pub const NodeSwitchElse = struct {
846 base: Node,
847 token: Token,
745 pub const SwitchCase = struct {
746 base: Node,
747 items: ArrayList(&Node),
748 payload: ?&Node,
749 expr: &Node,
848750
849 pub fn iterate(self: &NodeSwitchElse, index: usize) ?&Node {
850 return null;
851 }
751 pub fn iterate(self: &SwitchCase, index: usize) ?&Node {
752 var i = index;
852753
853 pub fn firstToken(self: &NodeSwitchElse) Token {
854 return self.token;
855 }
754 if (i < self.items.len) return self.items.at(i);
755 i -= self.items.len;
856756
857 pub fn lastToken(self: &NodeSwitchElse) Token {
858 return self.token;
859 }
860};
757 if (self.payload) |payload| {
758 if (i < 1) return payload;
759 i -= 1;
760 }
861761
862pub const NodeWhile = struct {
863 base: Node,
864 label: ?Token,
865 inline_token: ?Token,
866 while_token: Token,
867 condition: &Node,
868 payload: ?&Node,
869 continue_expr: ?&Node,
870 body: &Node,
871 @"else": ?&NodeElse,
872
873 pub fn iterate(self: &NodeWhile, index: usize) ?&Node {
874 var i = index;
875
876 if (i < 1) return self.condition;
877 i -= 1;
878
879 if (self.payload) |payload| {
880 if (i < 1) return payload;
762 if (i < 1) return self.expr;
881763 i -= 1;
882 }
883764
884 if (self.continue_expr) |continue_expr| {
885 if (i < 1) return continue_expr;
886 i -= 1;
765 return null;
887766 }
888767
889 if (i < 1) return self.body;
890 i -= 1;
768 pub fn firstToken(self: &SwitchCase) Token {
769 return self.items.at(0).firstToken();
770 }
891771
892 if (self.@"else") |@"else"| {
893 if (i < 1) return &@"else".base;
894 i -= 1;
772 pub fn lastToken(self: &SwitchCase) Token {
773 return self.expr.lastToken();
895774 }
775 };
896776
897 return null;
898 }
777 pub const SwitchElse = struct {
778 base: Node,
779 token: Token,
899780
900 pub fn firstToken(self: &NodeWhile) Token {
901 if (self.label) |label| {
902 return label;
781 pub fn iterate(self: &SwitchElse, index: usize) ?&Node {
782 return null;
903783 }
904784
905 if (self.inline_token) |inline_token| {
906 return inline_token;
785 pub fn firstToken(self: &SwitchElse) Token {
786 return self.token;
907787 }
908788
909 return self.while_token;
910 }
911
912 pub fn lastToken(self: &NodeWhile) Token {
913 if (self.@"else") |@"else"| {
914 return @"else".body.lastToken();
789 pub fn lastToken(self: &SwitchElse) Token {
790 return self.token;
915791 }
792 };
916793
917 return self.body.lastToken();
918 }
919};
920
921pub const NodeFor = struct {
922 base: Node,
923 label: ?Token,
924 inline_token: ?Token,
925 for_token: Token,
926 array_expr: &Node,
927 payload: ?&Node,
928 body: &Node,
929 @"else": ?&NodeElse,
794 pub const While = struct {
795 base: Node,
796 label: ?Token,
797 inline_token: ?Token,
798 while_token: Token,
799 condition: &Node,
800 payload: ?&Node,
801 continue_expr: ?&Node,
802 body: &Node,
803 @"else": ?&Else,
804
805 pub fn iterate(self: &While, index: usize) ?&Node {
806 var i = index;
807
808 if (i < 1) return self.condition;
809 i -= 1;
930810
931 pub fn iterate(self: &NodeFor, index: usize) ?&Node {
932 var i = index;
811 if (self.payload) |payload| {
812 if (i < 1) return payload;
813 i -= 1;
814 }
933815
934 if (i < 1) return self.array_expr;
935 i -= 1;
816 if (self.continue_expr) |continue_expr| {
817 if (i < 1) return continue_expr;
818 i -= 1;
819 }
936820
937 if (self.payload) |payload| {
938 if (i < 1) return payload;
821 if (i < 1) return self.body;
939822 i -= 1;
940 }
941823
942 if (i < 1) return self.body;
943 i -= 1;
824 if (self.@"else") |@"else"| {
825 if (i < 1) return &@"else".base;
826 i -= 1;
827 }
944828
945 if (self.@"else") |@"else"| {
946 if (i < 1) return &@"else".base;
947 i -= 1;
829 return null;
948830 }
949831
950 return null;
951 }
832 pub fn firstToken(self: &While) Token {
833 if (self.label) |label| {
834 return label;
835 }
952836
953 pub fn firstToken(self: &NodeFor) Token {
954 if (self.label) |label| {
955 return label;
956 }
837 if (self.inline_token) |inline_token| {
838 return inline_token;
839 }
957840
958 if (self.inline_token) |inline_token| {
959 return inline_token;
841 return self.while_token;
960842 }
961843
962 return self.for_token;
963 }
844 pub fn lastToken(self: &While) Token {
845 if (self.@"else") |@"else"| {
846 return @"else".body.lastToken();
847 }
964848
965 pub fn lastToken(self: &NodeFor) Token {
966 if (self.@"else") |@"else"| {
967 return @"else".body.lastToken();
849 return self.body.lastToken();
968850 }
851 };
969852
970 return self.body.lastToken();
971 }
972};
853 pub const For = struct {
854 base: Node,
855 label: ?Token,
856 inline_token: ?Token,
857 for_token: Token,
858 array_expr: &Node,
859 payload: ?&Node,
860 body: &Node,
861 @"else": ?&Else,
973862
974pub const NodeIf = struct {
975 base: Node,
976 if_token: Token,
977 condition: &Node,
978 payload: ?&Node,
979 body: &Node,
980 @"else": ?&NodeElse,
863 pub fn iterate(self: &For, index: usize) ?&Node {
864 var i = index;
981865
982 pub fn iterate(self: &NodeIf, index: usize) ?&Node {
983 var i = index;
866 if (i < 1) return self.array_expr;
867 i -= 1;
984868
985 if (i < 1) return self.condition;
986 i -= 1;
869 if (self.payload) |payload| {
870 if (i < 1) return payload;
871 i -= 1;
872 }
987873
988 if (self.payload) |payload| {
989 if (i < 1) return payload;
874 if (i < 1) return self.body;
990875 i -= 1;
991 }
992876
993 if (i < 1) return self.body;
994 i -= 1;
877 if (self.@"else") |@"else"| {
878 if (i < 1) return &@"else".base;
879 i -= 1;
880 }
995881
996 if (self.@"else") |@"else"| {
997 if (i < 1) return &@"else".base;
998 i -= 1;
882 return null;
999883 }
1000884
1001 return null;
1002 }
885 pub fn firstToken(self: &For) Token {
886 if (self.label) |label| {
887 return label;
888 }
1003889
1004 pub fn firstToken(self: &NodeIf) Token {
1005 return self.if_token;
1006 }
890 if (self.inline_token) |inline_token| {
891 return inline_token;
892 }
1007893
1008 pub fn lastToken(self: &NodeIf) Token {
1009 if (self.@"else") |@"else"| {
1010 return @"else".body.lastToken();
894 return self.for_token;
1011895 }
1012896
1013 return self.body.lastToken();
1014 }
1015};
897 pub fn lastToken(self: &For) Token {
898 if (self.@"else") |@"else"| {
899 return @"else".body.lastToken();
900 }
1016901
1017pub const NodeInfixOp = struct {
1018 base: Node,
1019 op_token: Token,
1020 lhs: &Node,
1021 op: InfixOp,
1022 rhs: &Node,
1023
1024 const InfixOp = union(enum) {
1025 Add,
1026 AddWrap,
1027 ArrayCat,
1028 ArrayMult,
1029 Assign,
1030 AssignBitAnd,
1031 AssignBitOr,
1032 AssignBitShiftLeft,
1033 AssignBitShiftRight,
1034 AssignBitXor,
1035 AssignDiv,
1036 AssignMinus,
1037 AssignMinusWrap,
1038 AssignMod,
1039 AssignPlus,
1040 AssignPlusWrap,
1041 AssignTimes,
1042 AssignTimesWarp,
1043 BangEqual,
1044 BitAnd,
1045 BitOr,
1046 BitShiftLeft,
1047 BitShiftRight,
1048 BitXor,
1049 BoolAnd,
1050 BoolOr,
1051 Catch: ?&Node,
1052 Div,
1053 EqualEqual,
1054 ErrorUnion,
1055 GreaterOrEqual,
1056 GreaterThan,
1057 LessOrEqual,
1058 LessThan,
1059 MergeErrorSets,
1060 Mod,
1061 Mult,
1062 MultWrap,
1063 Period,
1064 Range,
1065 Sub,
1066 SubWrap,
1067 UnwrapMaybe,
902 return self.body.lastToken();
903 }
1068904 };
1069905
1070 pub fn iterate(self: &NodeInfixOp, index: usize) ?&Node {
1071 var i = index;
906 pub const If = struct {
907 base: Node,
908 if_token: Token,
909 condition: &Node,
910 payload: ?&Node,
911 body: &Node,
912 @"else": ?&Else,
1072913
1073 if (i < 1) return self.lhs;
1074 i -= 1;
914 pub fn iterate(self: &If, index: usize) ?&Node {
915 var i = index;
1075916
1076 switch (self.op) {
1077 InfixOp.Catch => |maybe_payload| {
1078 if (maybe_payload) |payload| {
1079 if (i < 1) return payload;
1080 i -= 1;
1081 }
1082 },
1083
1084 InfixOp.Add,
1085 InfixOp.AddWrap,
1086 InfixOp.ArrayCat,
1087 InfixOp.ArrayMult,
1088 InfixOp.Assign,
1089 InfixOp.AssignBitAnd,
1090 InfixOp.AssignBitOr,
1091 InfixOp.AssignBitShiftLeft,
1092 InfixOp.AssignBitShiftRight,
1093 InfixOp.AssignBitXor,
1094 InfixOp.AssignDiv,
1095 InfixOp.AssignMinus,
1096 InfixOp.AssignMinusWrap,
1097 InfixOp.AssignMod,
1098 InfixOp.AssignPlus,
1099 InfixOp.AssignPlusWrap,
1100 InfixOp.AssignTimes,
1101 InfixOp.AssignTimesWarp,
1102 InfixOp.BangEqual,
1103 InfixOp.BitAnd,
1104 InfixOp.BitOr,
1105 InfixOp.BitShiftLeft,
1106 InfixOp.BitShiftRight,
1107 InfixOp.BitXor,
1108 InfixOp.BoolAnd,
1109 InfixOp.BoolOr,
1110 InfixOp.Div,
1111 InfixOp.EqualEqual,
1112 InfixOp.ErrorUnion,
1113 InfixOp.GreaterOrEqual,
1114 InfixOp.GreaterThan,
1115 InfixOp.LessOrEqual,
1116 InfixOp.LessThan,
1117 InfixOp.MergeErrorSets,
1118 InfixOp.Mod,
1119 InfixOp.Mult,
1120 InfixOp.MultWrap,
1121 InfixOp.Period,
1122 InfixOp.Range,
1123 InfixOp.Sub,
1124 InfixOp.SubWrap,
1125 InfixOp.UnwrapMaybe => {},
1126 }
1127
1128 if (i < 1) return self.rhs;
1129 i -= 1;
1130
1131 return null;
1132 }
917 if (i < 1) return self.condition;
918 i -= 1;
1133919
1134 pub fn firstToken(self: &NodeInfixOp) Token {
1135 return self.lhs.firstToken();
1136 }
920 if (self.payload) |payload| {
921 if (i < 1) return payload;
922 i -= 1;
923 }
1137924
1138 pub fn lastToken(self: &NodeInfixOp) Token {
1139 return self.rhs.lastToken();
1140 }
1141};
925 if (i < 1) return self.body;
926 i -= 1;
1142927
1143pub const NodePrefixOp = struct {
1144 base: Node,
1145 op_token: Token,
1146 op: PrefixOp,
1147 rhs: &Node,
1148
1149 const PrefixOp = union(enum) {
1150 AddrOf: AddrOfInfo,
1151 ArrayType: &Node,
1152 Await,
1153 BitNot,
1154 BoolNot,
1155 Cancel,
1156 Deref,
1157 MaybeType,
1158 Negation,
1159 NegationWrap,
1160 Resume,
1161 SliceType: AddrOfInfo,
1162 Try,
1163 UnwrapMaybe,
1164 };
928 if (self.@"else") |@"else"| {
929 if (i < 1) return &@"else".base;
930 i -= 1;
931 }
1165932
1166 const AddrOfInfo = struct {
1167 align_expr: ?&Node,
1168 bit_offset_start_token: ?Token,
1169 bit_offset_end_token: ?Token,
1170 const_token: ?Token,
1171 volatile_token: ?Token,
1172 };
933 return null;
934 }
1173935
1174 pub fn iterate(self: &NodePrefixOp, index: usize) ?&Node {
1175 var i = index;
936 pub fn firstToken(self: &If) Token {
937 return self.if_token;
938 }
1176939
1177 switch (self.op) {
1178 PrefixOp.SliceType => |addr_of_info| {
1179 if (addr_of_info.align_expr) |align_expr| {
1180 if (i < 1) return align_expr;
1181 i -= 1;
1182 }
1183 },
1184 PrefixOp.AddrOf => |addr_of_info| {
1185 if (addr_of_info.align_expr) |align_expr| {
1186 if (i < 1) return align_expr;
1187 i -= 1;
1188 }
1189 },
1190 PrefixOp.ArrayType => |size_expr| {
1191 if (i < 1) return size_expr;
1192 i -= 1;
1193 },
1194 PrefixOp.Await,
1195 PrefixOp.BitNot,
1196 PrefixOp.BoolNot,
1197 PrefixOp.Cancel,
1198 PrefixOp.Deref,
1199 PrefixOp.MaybeType,
1200 PrefixOp.Negation,
1201 PrefixOp.NegationWrap,
1202 PrefixOp.Try,
1203 PrefixOp.Resume,
1204 PrefixOp.UnwrapMaybe => {},
1205 }
1206
1207 if (i < 1) return self.rhs;
1208 i -= 1;
1209
1210 return null;
1211 }
940 pub fn lastToken(self: &If) Token {
941 if (self.@"else") |@"else"| {
942 return @"else".body.lastToken();
943 }
1212944
1213 pub fn firstToken(self: &NodePrefixOp) Token {
1214 return self.op_token;
1215 }
945 return self.body.lastToken();
946 }
947 };
1216948
1217 pub fn lastToken(self: &NodePrefixOp) Token {
1218 return self.rhs.lastToken();
1219 }
1220};
949 pub const InfixOp = struct {
950 base: Node,
951 op_token: Token,
952 lhs: &Node,
953 op: Op,
954 rhs: &Node,
955
956 pub const Op = union(enum) {
957 Add,
958 AddWrap,
959 ArrayCat,
960 ArrayMult,
961 Assign,
962 AssignBitAnd,
963 AssignBitOr,
964 AssignBitShiftLeft,
965 AssignBitShiftRight,
966 AssignBitXor,
967 AssignDiv,
968 AssignMinus,
969 AssignMinusWrap,
970 AssignMod,
971 AssignPlus,
972 AssignPlusWrap,
973 AssignTimes,
974 AssignTimesWarp,
975 BangEqual,
976 BitAnd,
977 BitOr,
978 BitShiftLeft,
979 BitShiftRight,
980 BitXor,
981 BoolAnd,
982 BoolOr,
983 Catch: ?&Node,
984 Div,
985 EqualEqual,
986 ErrorUnion,
987 GreaterOrEqual,
988 GreaterThan,
989 LessOrEqual,
990 LessThan,
991 MergeErrorSets,
992 Mod,
993 Mult,
994 MultWrap,
995 Period,
996 Range,
997 Sub,
998 SubWrap,
999 UnwrapMaybe,
1000 };
12211001
1222pub const NodeFieldInitializer = struct {
1223 base: Node,
1224 period_token: Token,
1225 name_token: Token,
1226 expr: &Node,
1002 pub fn iterate(self: &InfixOp, index: usize) ?&Node {
1003 var i = index;
12271004
1228 pub fn iterate(self: &NodeFieldInitializer, index: usize) ?&Node {
1229 var i = index;
1005 if (i < 1) return self.lhs;
1006 i -= 1;
12301007
1231 if (i < 1) return self.expr;
1232 i -= 1;
1008 switch (self.op) {
1009 Op.Catch => |maybe_payload| {
1010 if (maybe_payload) |payload| {
1011 if (i < 1) return payload;
1012 i -= 1;
1013 }
1014 },
1015
1016 Op.Add,
1017 Op.AddWrap,
1018 Op.ArrayCat,
1019 Op.ArrayMult,
1020 Op.Assign,
1021 Op.AssignBitAnd,
1022 Op.AssignBitOr,
1023 Op.AssignBitShiftLeft,
1024 Op.AssignBitShiftRight,
1025 Op.AssignBitXor,
1026 Op.AssignDiv,
1027 Op.AssignMinus,
1028 Op.AssignMinusWrap,
1029 Op.AssignMod,
1030 Op.AssignPlus,
1031 Op.AssignPlusWrap,
1032 Op.AssignTimes,
1033 Op.AssignTimesWarp,
1034 Op.BangEqual,
1035 Op.BitAnd,
1036 Op.BitOr,
1037 Op.BitShiftLeft,
1038 Op.BitShiftRight,
1039 Op.BitXor,
1040 Op.BoolAnd,
1041 Op.BoolOr,
1042 Op.Div,
1043 Op.EqualEqual,
1044 Op.ErrorUnion,
1045 Op.GreaterOrEqual,
1046 Op.GreaterThan,
1047 Op.LessOrEqual,
1048 Op.LessThan,
1049 Op.MergeErrorSets,
1050 Op.Mod,
1051 Op.Mult,
1052 Op.MultWrap,
1053 Op.Period,
1054 Op.Range,
1055 Op.Sub,
1056 Op.SubWrap,
1057 Op.UnwrapMaybe => {},
1058 }
12331059
1234 return null;
1235 }
1060 if (i < 1) return self.rhs;
1061 i -= 1;
12361062
1237 pub fn firstToken(self: &NodeFieldInitializer) Token {
1238 return self.period_token;
1239 }
1063 return null;
1064 }
12401065
1241 pub fn lastToken(self: &NodeFieldInitializer) Token {
1242 return self.expr.lastToken();
1243 }
1244};
1066 pub fn firstToken(self: &InfixOp) Token {
1067 return self.lhs.firstToken();
1068 }
12451069
1246pub const NodeSuffixOp = struct {
1247 base: Node,
1248 lhs: &Node,
1249 op: SuffixOp,
1250 rtoken: Token,
1251
1252 const SuffixOp = union(enum) {
1253 Call: CallInfo,
1254 ArrayAccess: &Node,
1255 Slice: SliceRange,
1256 ArrayInitializer: ArrayList(&Node),
1257 StructInitializer: ArrayList(&NodeFieldInitializer),
1070 pub fn lastToken(self: &InfixOp) Token {
1071 return self.rhs.lastToken();
1072 }
12581073 };
12591074
1260 const CallInfo = struct {
1261 params: ArrayList(&Node),
1262 async_attr: ?&NodeAsyncAttribute,
1263 };
1075 pub const PrefixOp = struct {
1076 base: Node,
1077 op_token: Token,
1078 op: Op,
1079 rhs: &Node,
1080
1081 const Op = union(enum) {
1082 AddrOf: AddrOfInfo,
1083 ArrayType: &Node,
1084 Await,
1085 BitNot,
1086 BoolNot,
1087 Cancel,
1088 Deref,
1089 MaybeType,
1090 Negation,
1091 NegationWrap,
1092 Resume,
1093 SliceType: AddrOfInfo,
1094 Try,
1095 UnwrapMaybe,
1096 };
12641097
1265 const SliceRange = struct {
1266 start: &Node,
1267 end: ?&Node,
1268 };
1098 const AddrOfInfo = struct {
1099 align_expr: ?&Node,
1100 bit_offset_start_token: ?Token,
1101 bit_offset_end_token: ?Token,
1102 const_token: ?Token,
1103 volatile_token: ?Token,
1104 };
12691105
1270 pub fn iterate(self: &NodeSuffixOp, index: usize) ?&Node {
1271 var i = index;
1106 pub fn iterate(self: &PrefixOp, index: usize) ?&Node {
1107 var i = index;
1108
1109 switch (self.op) {
1110 Op.SliceType => |addr_of_info| {
1111 if (addr_of_info.align_expr) |align_expr| {
1112 if (i < 1) return align_expr;
1113 i -= 1;
1114 }
1115 },
1116 Op.AddrOf => |addr_of_info| {
1117 if (addr_of_info.align_expr) |align_expr| {
1118 if (i < 1) return align_expr;
1119 i -= 1;
1120 }
1121 },
1122 Op.ArrayType => |size_expr| {
1123 if (i < 1) return size_expr;
1124 i -= 1;
1125 },
1126 Op.Await,
1127 Op.BitNot,
1128 Op.BoolNot,
1129 Op.Cancel,
1130 Op.Deref,
1131 Op.MaybeType,
1132 Op.Negation,
1133 Op.NegationWrap,
1134 Op.Try,
1135 Op.Resume,
1136 Op.UnwrapMaybe => {},
1137 }
12721138
1273 if (i < 1) return self.lhs;
1274 i -= 1;
1139 if (i < 1) return self.rhs;
1140 i -= 1;
12751141
1276 switch (self.op) {
1277 SuffixOp.Call => |call_info| {
1278 if (i < call_info.params.len) return call_info.params.at(i);
1279 i -= call_info.params.len;
1280 },
1281 SuffixOp.ArrayAccess => |index_expr| {
1282 if (i < 1) return index_expr;
1283 i -= 1;
1284 },
1285 SuffixOp.Slice => |range| {
1286 if (i < 1) return range.start;
1287 i -= 1;
1142 return null;
1143 }
12881144
1289 if (range.end) |end| {
1290 if (i < 1) return end;
1291 i -= 1;
1292 }
1293 },
1294 SuffixOp.ArrayInitializer => |exprs| {
1295 if (i < exprs.len) return exprs.at(i);
1296 i -= exprs.len;
1297 },
1298 SuffixOp.StructInitializer => |fields| {
1299 if (i < fields.len) return &fields.at(i).base;
1300 i -= fields.len;
1301 },
1302 }
1303
1304 return null;
1305 }
1145 pub fn firstToken(self: &PrefixOp) Token {
1146 return self.op_token;
1147 }
13061148
1307 pub fn firstToken(self: &NodeSuffixOp) Token {
1308 return self.lhs.firstToken();
1309 }
1149 pub fn lastToken(self: &PrefixOp) Token {
1150 return self.rhs.lastToken();
1151 }
1152 };
13101153
1311 pub fn lastToken(self: &NodeSuffixOp) Token {
1312 return self.rtoken;
1313 }
1314};
1154 pub const FieldInitializer = struct {
1155 base: Node,
1156 period_token: Token,
1157 name_token: Token,
1158 expr: &Node,
13151159
1316pub const NodeGroupedExpression = struct {
1317 base: Node,
1318 lparen: Token,
1319 expr: &Node,
1320 rparen: Token,
1160 pub fn iterate(self: &FieldInitializer, index: usize) ?&Node {
1161 var i = index;
13211162
1322 pub fn iterate(self: &NodeGroupedExpression, index: usize) ?&Node {
1323 var i = index;
1163 if (i < 1) return self.expr;
1164 i -= 1;
13241165
1325 if (i < 1) return self.expr;
1326 i -= 1;
1166 return null;
1167 }
13271168
1328 return null;
1329 }
1169 pub fn firstToken(self: &FieldInitializer) Token {
1170 return self.period_token;
1171 }
13301172
1331 pub fn firstToken(self: &NodeGroupedExpression) Token {
1332 return self.lparen;
1333 }
1173 pub fn lastToken(self: &FieldInitializer) Token {
1174 return self.expr.lastToken();
1175 }
1176 };
13341177
1335 pub fn lastToken(self: &NodeGroupedExpression) Token {
1336 return self.rparen;
1337 }
1338};
1178 pub const SuffixOp = struct {
1179 base: Node,
1180 lhs: &Node,
1181 op: Op,
1182 rtoken: Token,
1183
1184 const Op = union(enum) {
1185 Call: CallInfo,
1186 ArrayAccess: &Node,
1187 Slice: SliceRange,
1188 ArrayInitializer: ArrayList(&Node),
1189 StructInitializer: ArrayList(&FieldInitializer),
1190 };
1191
1192 const CallInfo = struct {
1193 params: ArrayList(&Node),
1194 async_attr: ?&AsyncAttribute,
1195 };
13391196
1340pub const NodeControlFlowExpression = struct {
1341 base: Node,
1342 ltoken: Token,
1343 kind: Kind,
1344 rhs: ?&Node,
1197 const SliceRange = struct {
1198 start: &Node,
1199 end: ?&Node,
1200 };
13451201
1346 const Kind = union(enum) {
1347 Break: ?&Node,
1348 Continue: ?&Node,
1349 Return,
1350 };
1202 pub fn iterate(self: &SuffixOp, index: usize) ?&Node {
1203 var i = index;
13511204
1352 pub fn iterate(self: &NodeControlFlowExpression, index: usize) ?&Node {
1353 var i = index;
1205 if (i < 1) return self.lhs;
1206 i -= 1;
13541207
1355 switch (self.kind) {
1356 Kind.Break => |maybe_label| {
1357 if (maybe_label) |label| {
1358 if (i < 1) return label;
1208 switch (self.op) {
1209 Op.Call => |call_info| {
1210 if (i < call_info.params.len) return call_info.params.at(i);
1211 i -= call_info.params.len;
1212 },
1213 Op.ArrayAccess => |index_expr| {
1214 if (i < 1) return index_expr;
13591215 i -= 1;
1360 }
1361 },
1362 Kind.Continue => |maybe_label| {
1363 if (maybe_label) |label| {
1364 if (i < 1) return label;
1216 },
1217 Op.Slice => |range| {
1218 if (i < 1) return range.start;
13651219 i -= 1;
1366 }
1367 },
1368 Kind.Return => {},
1220
1221 if (range.end) |end| {
1222 if (i < 1) return end;
1223 i -= 1;
1224 }
1225 },
1226 Op.ArrayInitializer => |exprs| {
1227 if (i < exprs.len) return exprs.at(i);
1228 i -= exprs.len;
1229 },
1230 Op.StructInitializer => |fields| {
1231 if (i < fields.len) return &fields.at(i).base;
1232 i -= fields.len;
1233 },
1234 }
1235
1236 return null;
13691237 }
13701238
1371 if (self.rhs) |rhs| {
1372 if (i < 1) return rhs;
1373 i -= 1;
1239 pub fn firstToken(self: &SuffixOp) Token {
1240 return self.lhs.firstToken();
13741241 }
13751242
1376 return null;
1377 }
1243 pub fn lastToken(self: &SuffixOp) Token {
1244 return self.rtoken;
1245 }
1246 };
13781247
1379 pub fn firstToken(self: &NodeControlFlowExpression) Token {
1380 return self.ltoken;
1381 }
1248 pub const GroupedExpression = struct {
1249 base: Node,
1250 lparen: Token,
1251 expr: &Node,
1252 rparen: Token,
1253
1254 pub fn iterate(self: &GroupedExpression, index: usize) ?&Node {
1255 var i = index;
13821256
1383 pub fn lastToken(self: &NodeControlFlowExpression) Token {
1384 if (self.rhs) |rhs| {
1385 return rhs.lastToken();
1257 if (i < 1) return self.expr;
1258 i -= 1;
1259
1260 return null;
13861261 }
13871262
1388 switch (self.kind) {
1389 Kind.Break => |maybe_label| {
1390 if (maybe_label) |label| {
1391 return label.lastToken();
1392 }
1393 },
1394 Kind.Continue => |maybe_label| {
1395 if (maybe_label) |label| {
1396 return label.lastToken();
1397 }
1398 },
1399 Kind.Return => return self.ltoken,
1263 pub fn firstToken(self: &GroupedExpression) Token {
1264 return self.lparen;
14001265 }
14011266
1402 return self.ltoken;
1403 }
1404};
1267 pub fn lastToken(self: &GroupedExpression) Token {
1268 return self.rparen;
1269 }
1270 };
14051271
1406pub const NodeSuspend = struct {
1407 base: Node,
1408 suspend_token: Token,
1409 payload: ?&Node,
1410 body: ?&Node,
1272 pub const ControlFlowExpression = struct {
1273 base: Node,
1274 ltoken: Token,
1275 kind: Kind,
1276 rhs: ?&Node,
14111277
1412 pub fn iterate(self: &NodeSuspend, index: usize) ?&Node {
1413 var i = index;
1278 const Kind = union(enum) {
1279 Break: ?&Node,
1280 Continue: ?&Node,
1281 Return,
1282 };
14141283
1415 if (self.payload) |payload| {
1416 if (i < 1) return payload;
1417 i -= 1;
1284 pub fn iterate(self: &ControlFlowExpression, index: usize) ?&Node {
1285 var i = index;
1286
1287 switch (self.kind) {
1288 Kind.Break => |maybe_label| {
1289 if (maybe_label) |label| {
1290 if (i < 1) return label;
1291 i -= 1;
1292 }
1293 },
1294 Kind.Continue => |maybe_label| {
1295 if (maybe_label) |label| {
1296 if (i < 1) return label;
1297 i -= 1;
1298 }
1299 },
1300 Kind.Return => {},
1301 }
1302
1303 if (self.rhs) |rhs| {
1304 if (i < 1) return rhs;
1305 i -= 1;
1306 }
1307
1308 return null;
14181309 }
14191310
1420 if (self.body) |body| {
1421 if (i < 1) return body;
1422 i -= 1;
1311 pub fn firstToken(self: &ControlFlowExpression) Token {
1312 return self.ltoken;
14231313 }
14241314
1425 return null;
1426 }
1315 pub fn lastToken(self: &ControlFlowExpression) Token {
1316 if (self.rhs) |rhs| {
1317 return rhs.lastToken();
1318 }
14271319
1428 pub fn firstToken(self: &NodeSuspend) Token {
1429 return self.suspend_token;
1430 }
1320 switch (self.kind) {
1321 Kind.Break => |maybe_label| {
1322 if (maybe_label) |label| {
1323 return label.lastToken();
1324 }
1325 },
1326 Kind.Continue => |maybe_label| {
1327 if (maybe_label) |label| {
1328 return label.lastToken();
1329 }
1330 },
1331 Kind.Return => return self.ltoken,
1332 }
14311333
1432 pub fn lastToken(self: &NodeSuspend) Token {
1433 if (self.body) |body| {
1434 return body.lastToken();
1334 return self.ltoken;
14351335 }
1336 };
1337
1338 pub const Suspend = struct {
1339 base: Node,
1340 suspend_token: Token,
1341 payload: ?&Node,
1342 body: ?&Node,
1343
1344 pub fn iterate(self: &Suspend, index: usize) ?&Node {
1345 var i = index;
1346
1347 if (self.payload) |payload| {
1348 if (i < 1) return payload;
1349 i -= 1;
1350 }
14361351
1437 if (self.payload) |payload| {
1438 return payload.lastToken();
1352 if (self.body) |body| {
1353 if (i < 1) return body;
1354 i -= 1;
1355 }
1356
1357 return null;
14391358 }
14401359
1441 return self.suspend_token;
1442 }
1443};
1360 pub fn firstToken(self: &Suspend) Token {
1361 return self.suspend_token;
1362 }
14441363
1445pub const NodeIntegerLiteral = struct {
1446 base: Node,
1447 token: Token,
1364 pub fn lastToken(self: &Suspend) Token {
1365 if (self.body) |body| {
1366 return body.lastToken();
1367 }
14481368
1449 pub fn iterate(self: &NodeIntegerLiteral, index: usize) ?&Node {
1450 return null;
1451 }
1369 if (self.payload) |payload| {
1370 return payload.lastToken();
1371 }
14521372
1453 pub fn firstToken(self: &NodeIntegerLiteral) Token {
1454 return self.token;
1455 }
1373 return self.suspend_token;
1374 }
1375 };
14561376
1457 pub fn lastToken(self: &NodeIntegerLiteral) Token {
1458 return self.token;
1459 }
1460};
1377 pub const IntegerLiteral = struct {
1378 base: Node,
1379 token: Token,
14611380
1462pub const NodeFloatLiteral = struct {
1463 base: Node,
1464 token: Token,
1381 pub fn iterate(self: &IntegerLiteral, index: usize) ?&Node {
1382 return null;
1383 }
14651384
1466 pub fn iterate(self: &NodeFloatLiteral, index: usize) ?&Node {
1467 return null;
1468 }
1385 pub fn firstToken(self: &IntegerLiteral) Token {
1386 return self.token;
1387 }
14691388
1470 pub fn firstToken(self: &NodeFloatLiteral) Token {
1471 return self.token;
1472 }
1389 pub fn lastToken(self: &IntegerLiteral) Token {
1390 return self.token;
1391 }
1392 };
14731393
1474 pub fn lastToken(self: &NodeFloatLiteral) Token {
1475 return self.token;
1476 }
1477};
1394 pub const FloatLiteral = struct {
1395 base: Node,
1396 token: Token,
14781397
1479pub const NodeBuiltinCall = struct {
1480 base: Node,
1481 builtin_token: Token,
1482 params: ArrayList(&Node),
1483 rparen_token: Token,
1398 pub fn iterate(self: &FloatLiteral, index: usize) ?&Node {
1399 return null;
1400 }
14841401
1485 pub fn iterate(self: &NodeBuiltinCall, index: usize) ?&Node {
1486 var i = index;
1402 pub fn firstToken(self: &FloatLiteral) Token {
1403 return self.token;
1404 }
14871405
1488 if (i < self.params.len) return self.params.at(i);
1489 i -= self.params.len;
1406 pub fn lastToken(self: &FloatLiteral) Token {
1407 return self.token;
1408 }
1409 };
14901410
1491 return null;
1492 }
1411 pub const BuiltinCall = struct {
1412 base: Node,
1413 builtin_token: Token,
1414 params: ArrayList(&Node),
1415 rparen_token: Token,
14931416
1494 pub fn firstToken(self: &NodeBuiltinCall) Token {
1495 return self.builtin_token;
1496 }
1417 pub fn iterate(self: &BuiltinCall, index: usize) ?&Node {
1418 var i = index;
14971419
1498 pub fn lastToken(self: &NodeBuiltinCall) Token {
1499 return self.rparen_token;
1500 }
1501};
1420 if (i < self.params.len) return self.params.at(i);
1421 i -= self.params.len;
15021422
1503pub const NodeStringLiteral = struct {
1504 base: Node,
1505 token: Token,
1423 return null;
1424 }
15061425
1507 pub fn iterate(self: &NodeStringLiteral, index: usize) ?&Node {
1508 return null;
1509 }
1426 pub fn firstToken(self: &BuiltinCall) Token {
1427 return self.builtin_token;
1428 }
15101429
1511 pub fn firstToken(self: &NodeStringLiteral) Token {
1512 return self.token;
1513 }
1430 pub fn lastToken(self: &BuiltinCall) Token {
1431 return self.rparen_token;
1432 }
1433 };
15141434
1515 pub fn lastToken(self: &NodeStringLiteral) Token {
1516 return self.token;
1517 }
1518};
1435 pub const StringLiteral = struct {
1436 base: Node,
1437 token: Token,
15191438
1520pub const NodeMultilineStringLiteral = struct {
1521 base: Node,
1522 tokens: ArrayList(Token),
1439 pub fn iterate(self: &StringLiteral, index: usize) ?&Node {
1440 return null;
1441 }
15231442
1524 pub fn iterate(self: &NodeMultilineStringLiteral, index: usize) ?&Node {
1525 return null;
1526 }
1443 pub fn firstToken(self: &StringLiteral) Token {
1444 return self.token;
1445 }
15271446
1528 pub fn firstToken(self: &NodeMultilineStringLiteral) Token {
1529 return self.tokens.at(0);
1530 }
1447 pub fn lastToken(self: &StringLiteral) Token {
1448 return self.token;
1449 }
1450 };
15311451
1532 pub fn lastToken(self: &NodeMultilineStringLiteral) Token {
1533 return self.tokens.at(self.tokens.len - 1);
1534 }
1535};
1452 pub const MultilineStringLiteral = struct {
1453 base: Node,
1454 tokens: ArrayList(Token),
15361455
1537pub const NodeCharLiteral = struct {
1538 base: Node,
1539 token: Token,
1456 pub fn iterate(self: &MultilineStringLiteral, index: usize) ?&Node {
1457 return null;
1458 }
15401459
1541 pub fn iterate(self: &NodeCharLiteral, index: usize) ?&Node {
1542 return null;
1543 }
1460 pub fn firstToken(self: &MultilineStringLiteral) Token {
1461 return self.tokens.at(0);
1462 }
15441463
1545 pub fn firstToken(self: &NodeCharLiteral) Token {
1546 return self.token;
1547 }
1464 pub fn lastToken(self: &MultilineStringLiteral) Token {
1465 return self.tokens.at(self.tokens.len - 1);
1466 }
1467 };
15481468
1549 pub fn lastToken(self: &NodeCharLiteral) Token {
1550 return self.token;
1551 }
1552};
1469 pub const CharLiteral = struct {
1470 base: Node,
1471 token: Token,
15531472
1554pub const NodeBoolLiteral = struct {
1555 base: Node,
1556 token: Token,
1473 pub fn iterate(self: &CharLiteral, index: usize) ?&Node {
1474 return null;
1475 }
15571476
1558 pub fn iterate(self: &NodeBoolLiteral, index: usize) ?&Node {
1559 return null;
1560 }
1477 pub fn firstToken(self: &CharLiteral) Token {
1478 return self.token;
1479 }
15611480
1562 pub fn firstToken(self: &NodeBoolLiteral) Token {
1563 return self.token;
1564 }
1481 pub fn lastToken(self: &CharLiteral) Token {
1482 return self.token;
1483 }
1484 };
15651485
1566 pub fn lastToken(self: &NodeBoolLiteral) Token {
1567 return self.token;
1568 }
1569};
1486 pub const BoolLiteral = struct {
1487 base: Node,
1488 token: Token,
15701489
1571pub const NodeNullLiteral = struct {
1572 base: Node,
1573 token: Token,
1490 pub fn iterate(self: &BoolLiteral, index: usize) ?&Node {
1491 return null;
1492 }
15741493
1575 pub fn iterate(self: &NodeNullLiteral, index: usize) ?&Node {
1576 return null;
1577 }
1494 pub fn firstToken(self: &BoolLiteral) Token {
1495 return self.token;
1496 }
15781497
1579 pub fn firstToken(self: &NodeNullLiteral) Token {
1580 return self.token;
1581 }
1498 pub fn lastToken(self: &BoolLiteral) Token {
1499 return self.token;
1500 }
1501 };
15821502
1583 pub fn lastToken(self: &NodeNullLiteral) Token {
1584 return self.token;
1585 }
1586};
1503 pub const NullLiteral = struct {
1504 base: Node,
1505 token: Token,
15871506
1588pub const NodeUndefinedLiteral = struct {
1589 base: Node,
1590 token: Token,
1507 pub fn iterate(self: &NullLiteral, index: usize) ?&Node {
1508 return null;
1509 }
15911510
1592 pub fn iterate(self: &NodeUndefinedLiteral, index: usize) ?&Node {
1593 return null;
1594 }
1511 pub fn firstToken(self: &NullLiteral) Token {
1512 return self.token;
1513 }
15951514
1596 pub fn firstToken(self: &NodeUndefinedLiteral) Token {
1597 return self.token;
1598 }
1515 pub fn lastToken(self: &NullLiteral) Token {
1516 return self.token;
1517 }
1518 };
15991519
1600 pub fn lastToken(self: &NodeUndefinedLiteral) Token {
1601 return self.token;
1602 }
1603};
1520 pub const UndefinedLiteral = struct {
1521 base: Node,
1522 token: Token,
16041523
1605pub const NodeThisLiteral = struct {
1606 base: Node,
1607 token: Token,
1524 pub fn iterate(self: &UndefinedLiteral, index: usize) ?&Node {
1525 return null;
1526 }
16081527
1609 pub fn iterate(self: &NodeThisLiteral, index: usize) ?&Node {
1610 return null;
1611 }
1528 pub fn firstToken(self: &UndefinedLiteral) Token {
1529 return self.token;
1530 }
16121531
1613 pub fn firstToken(self: &NodeThisLiteral) Token {
1614 return self.token;
1615 }
1532 pub fn lastToken(self: &UndefinedLiteral) Token {
1533 return self.token;
1534 }
1535 };
16161536
1617 pub fn lastToken(self: &NodeThisLiteral) Token {
1618 return self.token;
1619 }
1620};
1537 pub const ThisLiteral = struct {
1538 base: Node,
1539 token: Token,
16211540
1622pub const NodeAsmOutput = struct {
1623 base: Node,
1624 symbolic_name: &Node,
1625 constraint: &Node,
1626 kind: Kind,
1541 pub fn iterate(self: &ThisLiteral, index: usize) ?&Node {
1542 return null;
1543 }
16271544
1628 const Kind = union(enum) {
1629 Variable: &NodeIdentifier,
1630 Return: &Node
1545 pub fn firstToken(self: &ThisLiteral) Token {
1546 return self.token;
1547 }
1548
1549 pub fn lastToken(self: &ThisLiteral) Token {
1550 return self.token;
1551 }
16311552 };
16321553
1633 pub fn iterate(self: &NodeAsmOutput, index: usize) ?&Node {
1634 var i = index;
1554 pub const AsmOutput = struct {
1555 base: Node,
1556 symbolic_name: &Node,
1557 constraint: &Node,
1558 kind: Kind,
16351559
1636 if (i < 1) return self.symbolic_name;
1637 i -= 1;
1560 const Kind = union(enum) {
1561 Variable: &Identifier,
1562 Return: &Node
1563 };
16381564
1639 if (i < 1) return self.constraint;
1640 i -= 1;
1565 pub fn iterate(self: &AsmOutput, index: usize) ?&Node {
1566 var i = index;
16411567
1642 switch (self.kind) {
1643 Kind.Variable => |variable_name| {
1644 if (i < 1) return &variable_name.base;
1645 i -= 1;
1646 },
1647 Kind.Return => |return_type| {
1648 if (i < 1) return return_type;
1649 i -= 1;
1568 if (i < 1) return self.symbolic_name;
1569 i -= 1;
1570
1571 if (i < 1) return self.constraint;
1572 i -= 1;
1573
1574 switch (self.kind) {
1575 Kind.Variable => |variable_name| {
1576 if (i < 1) return &variable_name.base;
1577 i -= 1;
1578 },
1579 Kind.Return => |return_type| {
1580 if (i < 1) return return_type;
1581 i -= 1;
1582 }
16501583 }
1651 }
16521584
1653 return null;
1654 }
1585 return null;
1586 }
16551587
1656 pub fn firstToken(self: &NodeAsmOutput) Token {
1657 return self.symbolic_name.firstToken();
1658 }
1588 pub fn firstToken(self: &AsmOutput) Token {
1589 return self.symbolic_name.firstToken();
1590 }
16591591
1660 pub fn lastToken(self: &NodeAsmOutput) Token {
1661 return switch (self.kind) {
1662 Kind.Variable => |variable_name| variable_name.lastToken(),
1663 Kind.Return => |return_type| return_type.lastToken(),
1664 };
1665 }
1666};
1592 pub fn lastToken(self: &AsmOutput) Token {
1593 return switch (self.kind) {
1594 Kind.Variable => |variable_name| variable_name.lastToken(),
1595 Kind.Return => |return_type| return_type.lastToken(),
1596 };
1597 }
1598 };
16671599
1668pub const NodeAsmInput = struct {
1669 base: Node,
1670 symbolic_name: &Node,
1671 constraint: &Node,
1672 expr: &Node,
1600 pub const AsmInput = struct {
1601 base: Node,
1602 symbolic_name: &Node,
1603 constraint: &Node,
1604 expr: &Node,
16731605
1674 pub fn iterate(self: &NodeAsmInput, index: usize) ?&Node {
1675 var i = index;
1606 pub fn iterate(self: &AsmInput, index: usize) ?&Node {
1607 var i = index;
16761608
1677 if (i < 1) return self.symbolic_name;
1678 i -= 1;
1609 if (i < 1) return self.symbolic_name;
1610 i -= 1;
16791611
1680 if (i < 1) return self.constraint;
1681 i -= 1;
1612 if (i < 1) return self.constraint;
1613 i -= 1;
16821614
1683 if (i < 1) return self.expr;
1684 i -= 1;
1615 if (i < 1) return self.expr;
1616 i -= 1;
16851617
1686 return null;
1687 }
1618 return null;
1619 }
16881620
1689 pub fn firstToken(self: &NodeAsmInput) Token {
1690 return self.symbolic_name.firstToken();
1691 }
1621 pub fn firstToken(self: &AsmInput) Token {
1622 return self.symbolic_name.firstToken();
1623 }
16921624
1693 pub fn lastToken(self: &NodeAsmInput) Token {
1694 return self.expr.lastToken();
1695 }
1696};
1625 pub fn lastToken(self: &AsmInput) Token {
1626 return self.expr.lastToken();
1627 }
1628 };
16971629
1698pub const NodeAsm = struct {
1699 base: Node,
1700 asm_token: Token,
1701 volatile_token: ?Token,
1702 template: &Node,
1703 //tokens: ArrayList(AsmToken),
1704 outputs: ArrayList(&NodeAsmOutput),
1705 inputs: ArrayList(&NodeAsmInput),
1706 cloppers: ArrayList(&Node),
1707 rparen: Token,
1630 pub const Asm = struct {
1631 base: Node,
1632 asm_token: Token,
1633 volatile_token: ?Token,
1634 template: &Node,
1635 //tokens: ArrayList(AsmToken),
1636 outputs: ArrayList(&AsmOutput),
1637 inputs: ArrayList(&AsmInput),
1638 cloppers: ArrayList(&Node),
1639 rparen: Token,
17081640
1709 pub fn iterate(self: &NodeAsm, index: usize) ?&Node {
1710 var i = index;
1641 pub fn iterate(self: &Asm, index: usize) ?&Node {
1642 var i = index;
17111643
1712 if (i < self.outputs.len) return &self.outputs.at(index).base;
1713 i -= self.outputs.len;
1644 if (i < self.outputs.len) return &self.outputs.at(index).base;
1645 i -= self.outputs.len;
17141646
1715 if (i < self.inputs.len) return &self.inputs.at(index).base;
1716 i -= self.inputs.len;
1647 if (i < self.inputs.len) return &self.inputs.at(index).base;
1648 i -= self.inputs.len;
17171649
1718 if (i < self.cloppers.len) return self.cloppers.at(index);
1719 i -= self.cloppers.len;
1650 if (i < self.cloppers.len) return self.cloppers.at(index);
1651 i -= self.cloppers.len;
17201652
1721 return null;
1722 }
1653 return null;
1654 }
17231655
1724 pub fn firstToken(self: &NodeAsm) Token {
1725 return self.asm_token;
1726 }
1656 pub fn firstToken(self: &Asm) Token {
1657 return self.asm_token;
1658 }
17271659
1728 pub fn lastToken(self: &NodeAsm) Token {
1729 return self.rparen;
1730 }
1731};
1660 pub fn lastToken(self: &Asm) Token {
1661 return self.rparen;
1662 }
1663 };
17321664
1733pub const NodeUnreachable = struct {
1734 base: Node,
1735 token: Token,
1665 pub const Unreachable = struct {
1666 base: Node,
1667 token: Token,
17361668
1737 pub fn iterate(self: &NodeUnreachable, index: usize) ?&Node {
1738 return null;
1739 }
1669 pub fn iterate(self: &Unreachable, index: usize) ?&Node {
1670 return null;
1671 }
17401672
1741 pub fn firstToken(self: &NodeUnreachable) Token {
1742 return self.token;
1743 }
1673 pub fn firstToken(self: &Unreachable) Token {
1674 return self.token;
1675 }
17441676
1745 pub fn lastToken(self: &NodeUnreachable) Token {
1746 return self.token;
1747 }
1748};
1677 pub fn lastToken(self: &Unreachable) Token {
1678 return self.token;
1679 }
1680 };
17491681
1750pub const NodeErrorType = struct {
1751 base: Node,
1752 token: Token,
1682 pub const ErrorType = struct {
1683 base: Node,
1684 token: Token,
17531685
1754 pub fn iterate(self: &NodeErrorType, index: usize) ?&Node {
1755 return null;
1756 }
1686 pub fn iterate(self: &ErrorType, index: usize) ?&Node {
1687 return null;
1688 }
17571689
1758 pub fn firstToken(self: &NodeErrorType) Token {
1759 return self.token;
1760 }
1690 pub fn firstToken(self: &ErrorType) Token {
1691 return self.token;
1692 }
17611693
1762 pub fn lastToken(self: &NodeErrorType) Token {
1763 return self.token;
1764 }
1765};
1694 pub fn lastToken(self: &ErrorType) Token {
1695 return self.token;
1696 }
1697 };
17661698
1767pub const NodeVarType = struct {
1768 base: Node,
1769 token: Token,
1699 pub const VarType = struct {
1700 base: Node,
1701 token: Token,
17701702
1771 pub fn iterate(self: &NodeVarType, index: usize) ?&Node {
1772 return null;
1773 }
1703 pub fn iterate(self: &VarType, index: usize) ?&Node {
1704 return null;
1705 }
17741706
1775 pub fn firstToken(self: &NodeVarType) Token {
1776 return self.token;
1777 }
1707 pub fn firstToken(self: &VarType) Token {
1708 return self.token;
1709 }
17781710
1779 pub fn lastToken(self: &NodeVarType) Token {
1780 return self.token;
1781 }
1782};
1711 pub fn lastToken(self: &VarType) Token {
1712 return self.token;
1713 }
1714 };
17831715
1784pub const NodeLineComment = struct {
1785 base: Node,
1786 lines: ArrayList(Token),
1716 pub const LineComment = struct {
1717 base: Node,
1718 lines: ArrayList(Token),
17871719
1788 pub fn iterate(self: &NodeLineComment, index: usize) ?&Node {
1789 return null;
1790 }
1720 pub fn iterate(self: &LineComment, index: usize) ?&Node {
1721 return null;
1722 }
17911723
1792 pub fn firstToken(self: &NodeLineComment) Token {
1793 return self.lines.at(0);
1794 }
1724 pub fn firstToken(self: &LineComment) Token {
1725 return self.lines.at(0);
1726 }
17951727
1796 pub fn lastToken(self: &NodeLineComment) Token {
1797 return self.lines.at(self.lines.len - 1);
1798 }
1799};
1728 pub fn lastToken(self: &LineComment) Token {
1729 return self.lines.at(self.lines.len - 1);
1730 }
1731 };
18001732
1801pub const NodeTestDecl = struct {
1802 base: Node,
1803 test_token: Token,
1804 name: &Node,
1805 body_node: &Node,
1733 pub const TestDecl = struct {
1734 base: Node,
1735 comments: ?&LineComment,
1736 test_token: Token,
1737 name: &Node,
1738 body_node: &Node,
18061739
1807 pub fn iterate(self: &NodeTestDecl, index: usize) ?&Node {
1808 var i = index;
1740 pub fn iterate(self: &TestDecl, index: usize) ?&Node {
1741 var i = index;
18091742
1810 if (i < 1) return self.body_node;
1811 i -= 1;
1743 if (i < 1) return self.body_node;
1744 i -= 1;
18121745
1813 return null;
1814 }
1746 return null;
1747 }
18151748
1816 pub fn firstToken(self: &NodeTestDecl) Token {
1817 return self.test_token;
1818 }
1749 pub fn firstToken(self: &TestDecl) Token {
1750 return self.test_token;
1751 }
18191752
1820 pub fn lastToken(self: &NodeTestDecl) Token {
1821 return self.body_node.lastToken();
1822 }
1753 pub fn lastToken(self: &TestDecl) Token {
1754 return self.body_node.lastToken();
1755 }
1756 };
18231757};
1758
std/zig/parser.zig+502-473
......@@ -18,10 +18,10 @@ pub const Parser = struct {
1818 put_back_tokens: [2]Token,
1919 put_back_count: usize,
2020 source_file_name: []const u8,
21 pending_line_comment_node: ?&ast.NodeLineComment,
21 pending_line_comment_node: ?&ast.Node.LineComment,
2222
2323 pub const Tree = struct {
24 root_node: &ast.NodeRoot,
24 root_node: &ast.Node.Root,
2525 arena_allocator: std.heap.ArenaAllocator,
2626
2727 pub fn deinit(self: &Tree) void {
......@@ -66,22 +66,24 @@ pub const Parser = struct {
6666 extern_export_token: ?Token,
6767 lib_name: ?&ast.Node,
6868 list: &ArrayList(&ast.Node),
69 comments: ?&ast.Node.LineComment,
6970 };
7071
7172 const TopLevelExternOrFieldCtx = struct {
7273 visib_token: Token,
73 container_decl: &ast.NodeContainerDecl,
74 container_decl: &ast.Node.ContainerDecl,
7475 };
7576
7677 const ExternTypeCtx = struct {
7778 opt_ctx: OptionalCtx,
7879 extern_token: Token,
80 comments: ?&ast.Node.LineComment,
7981 };
8082
8183 const ContainerKindCtx = struct {
8284 opt_ctx: OptionalCtx,
8385 ltoken: Token,
84 layout: ast.NodeContainerDecl.Layout,
86 layout: ast.Node.ContainerDecl.Layout,
8587 };
8688
8789 const ExpectTokenSave = struct {
......@@ -132,7 +134,7 @@ pub const Parser = struct {
132134
133135 const AsyncEndCtx = struct {
134136 ctx: OptionalCtx,
135 attribute: &ast.NodeAsyncAttribute,
137 attribute: &ast.Node.AsyncAttribute,
136138 };
137139
138140 const ErrorTypeOrSetDeclCtx = struct {
......@@ -141,13 +143,13 @@ pub const Parser = struct {
141143 };
142144
143145 const ParamDeclEndCtx = struct {
144 fn_proto: &ast.NodeFnProto,
145 param_decl: &ast.NodeParamDecl,
146 fn_proto: &ast.Node.FnProto,
147 param_decl: &ast.Node.ParamDecl,
146148 };
147149
148150 const ComptimeStatementCtx = struct {
149151 comptime_token: Token,
150 block: &ast.NodeBlock,
152 block: &ast.Node.Block,
151153 };
152154
153155 const OptionalCtx = union(enum) {
......@@ -190,24 +192,24 @@ pub const Parser = struct {
190192 TopLevelExternOrField: TopLevelExternOrFieldCtx,
191193
192194 ContainerKind: ContainerKindCtx,
193 ContainerInitArgStart: &ast.NodeContainerDecl,
194 ContainerInitArg: &ast.NodeContainerDecl,
195 ContainerDecl: &ast.NodeContainerDecl,
195 ContainerInitArgStart: &ast.Node.ContainerDecl,
196 ContainerInitArg: &ast.Node.ContainerDecl,
197 ContainerDecl: &ast.Node.ContainerDecl,
196198
197199 VarDecl: VarDeclCtx,
198 VarDeclAlign: &ast.NodeVarDecl,
199 VarDeclEq: &ast.NodeVarDecl,
200 VarDeclAlign: &ast.Node.VarDecl,
201 VarDeclEq: &ast.Node.VarDecl,
200202
201 FnDef: &ast.NodeFnProto,
202 FnProto: &ast.NodeFnProto,
203 FnProtoAlign: &ast.NodeFnProto,
204 FnProtoReturnType: &ast.NodeFnProto,
203 FnDef: &ast.Node.FnProto,
204 FnProto: &ast.Node.FnProto,
205 FnProtoAlign: &ast.Node.FnProto,
206 FnProtoReturnType: &ast.Node.FnProto,
205207
206 ParamDecl: &ast.NodeFnProto,
207 ParamDeclAliasOrComptime: &ast.NodeParamDecl,
208 ParamDeclName: &ast.NodeParamDecl,
208 ParamDecl: &ast.Node.FnProto,
209 ParamDeclAliasOrComptime: &ast.Node.ParamDecl,
210 ParamDeclName: &ast.Node.ParamDecl,
209211 ParamDeclEnd: ParamDeclEndCtx,
210 ParamDeclComma: &ast.NodeFnProto,
212 ParamDeclComma: &ast.Node.FnProto,
211213
212214 MaybeLabeledExpression: MaybeLabeledExpressionCtx,
213215 LabeledExpression: LabelCtx,
......@@ -215,39 +217,39 @@ pub const Parser = struct {
215217 While: LoopCtx,
216218 WhileContinueExpr: &?&ast.Node,
217219 For: LoopCtx,
218 Else: &?&ast.NodeElse,
220 Else: &?&ast.Node.Else,
219221
220 Block: &ast.NodeBlock,
221 Statement: &ast.NodeBlock,
222 Block: &ast.Node.Block,
223 Statement: &ast.Node.Block,
222224 ComptimeStatement: ComptimeStatementCtx,
223225 Semicolon: &&ast.Node,
224226
225 AsmOutputItems: &ArrayList(&ast.NodeAsmOutput),
226 AsmOutputReturnOrType: &ast.NodeAsmOutput,
227 AsmInputItems: &ArrayList(&ast.NodeAsmInput),
227 AsmOutputItems: &ArrayList(&ast.Node.AsmOutput),
228 AsmOutputReturnOrType: &ast.Node.AsmOutput,
229 AsmInputItems: &ArrayList(&ast.Node.AsmInput),
228230 AsmClopperItems: &ArrayList(&ast.Node),
229231
230232 ExprListItemOrEnd: ExprListCtx,
231233 ExprListCommaOrEnd: ExprListCtx,
232 FieldInitListItemOrEnd: ListSave(&ast.NodeFieldInitializer),
233 FieldInitListCommaOrEnd: ListSave(&ast.NodeFieldInitializer),
234 FieldListCommaOrEnd: &ast.NodeContainerDecl,
234 FieldInitListItemOrEnd: ListSave(&ast.Node.FieldInitializer),
235 FieldInitListCommaOrEnd: ListSave(&ast.Node.FieldInitializer),
236 FieldListCommaOrEnd: &ast.Node.ContainerDecl,
235237 IdentifierListItemOrEnd: ListSave(&ast.Node),
236238 IdentifierListCommaOrEnd: ListSave(&ast.Node),
237 SwitchCaseOrEnd: ListSave(&ast.NodeSwitchCase),
238 SwitchCaseCommaOrEnd: ListSave(&ast.NodeSwitchCase),
239 SwitchCaseOrEnd: ListSave(&ast.Node.SwitchCase),
240 SwitchCaseCommaOrEnd: ListSave(&ast.Node.SwitchCase),
239241 SwitchCaseFirstItem: &ArrayList(&ast.Node),
240242 SwitchCaseItem: &ArrayList(&ast.Node),
241243 SwitchCaseItemCommaOrEnd: &ArrayList(&ast.Node),
242244
243 SuspendBody: &ast.NodeSuspend,
244 AsyncAllocator: &ast.NodeAsyncAttribute,
245 SuspendBody: &ast.Node.Suspend,
246 AsyncAllocator: &ast.Node.AsyncAttribute,
245247 AsyncEnd: AsyncEndCtx,
246248
247249 ExternType: ExternTypeCtx,
248 SliceOrArrayAccess: &ast.NodeSuffixOp,
249 SliceOrArrayType: &ast.NodePrefixOp,
250 AddrOfModifiers: &ast.NodePrefixOp.AddrOfInfo,
250 SliceOrArrayAccess: &ast.Node.SuffixOp,
251 SliceOrArrayType: &ast.Node.PrefixOp,
252 AddrOfModifiers: &ast.Node.PrefixOp.AddrOfInfo,
251253
252254 Payload: OptionalCtx,
253255 PointerPayload: OptionalCtx,
......@@ -310,8 +312,8 @@ pub const Parser = struct {
310312 errdefer arena_allocator.deinit();
311313
312314 const arena = &arena_allocator.allocator;
313 const root_node = try self.createNode(arena, ast.NodeRoot,
314 ast.NodeRoot {
315 const root_node = try self.createNode(arena, ast.Node.Root,
316 ast.Node.Root {
315317 .base = undefined,
316318 .decls = ArrayList(&ast.Node).init(arena),
317319 // initialized when we get the eof token
......@@ -334,43 +336,19 @@ pub const Parser = struct {
334336 // warn("\n");
335337 //}
336338
337 // look for line comments
338 while (true) {
339 if (self.eatToken(Token.Id.LineComment)) |line_comment| {
340 const node = blk: {
341 if (self.pending_line_comment_node) |comment_node| {
342 break :blk comment_node;
343 } else {
344 const comment_node = try arena.create(ast.NodeLineComment);
345 *comment_node = ast.NodeLineComment {
346 .base = ast.Node {
347 .id = ast.Node.Id.LineComment,
348 .comment = null,
349 },
350 .lines = ArrayList(Token).init(arena),
351 };
352 self.pending_line_comment_node = comment_node;
353 break :blk comment_node;
354 }
355 };
356 try node.lines.append(line_comment);
357 continue;
358 }
359 break;
360 }
361
362339 // This gives us 1 free append that can't fail
363340 const state = stack.pop();
364341
365342 switch (state) {
366343 State.TopLevel => {
344 const comments = try self.eatComments(arena);
367345 const token = self.getNextToken();
368346 switch (token.id) {
369347 Token.Id.Keyword_test => {
370348 stack.append(State.TopLevel) catch unreachable;
371349
372 const block = try self.createNode(arena, ast.NodeBlock,
373 ast.NodeBlock {
350 const block = try self.createNode(arena, ast.Node.Block,
351 ast.Node.Block {
374352 .base = undefined,
375353 .label = null,
376354 .lbrace = undefined,
......@@ -378,9 +356,10 @@ pub const Parser = struct {
378356 .rbrace = undefined,
379357 }
380358 );
381 const test_node = try self.createAttachNode(arena, &root_node.decls, ast.NodeTestDecl,
382 ast.NodeTestDecl {
359 const test_node = try self.createAttachNode(arena, &root_node.decls, ast.Node.TestDecl,
360 ast.Node.TestDecl {
383361 .base = undefined,
362 .comments = comments,
384363 .test_token = token,
385364 .name = undefined,
386365 .body_node = &block.base,
......@@ -413,8 +392,8 @@ pub const Parser = struct {
413392 continue;
414393 },
415394 Token.Id.Keyword_comptime => {
416 const block = try self.createNode(arena, ast.NodeBlock,
417 ast.NodeBlock {
395 const block = try self.createNode(arena, ast.Node.Block,
396 ast.Node.Block {
418397 .base = undefined,
419398 .label = null,
420399 .lbrace = undefined,
......@@ -422,8 +401,8 @@ pub const Parser = struct {
422401 .rbrace = undefined,
423402 }
424403 );
425 const node = try self.createAttachNode(arena, &root_node.decls, ast.NodeComptime,
426 ast.NodeComptime {
404 const node = try self.createAttachNode(arena, &root_node.decls, ast.Node.Comptime,
405 ast.Node.Comptime {
427406 .base = undefined,
428407 .comptime_token = token,
429408 .expr = &block.base,
......@@ -506,6 +485,7 @@ pub const Parser = struct {
506485 continue;
507486 },
508487 State.TopLevelDecl => |ctx| {
488 const comments = try self.eatComments(arena);
509489 const token = self.getNextToken();
510490 switch (token.id) {
511491 Token.Id.Keyword_use => {
......@@ -513,8 +493,8 @@ pub const Parser = struct {
513493 return self.parseError(token, "Invalid token {}", @tagName((??ctx.extern_export_inline_token).id));
514494 }
515495
516 const node = try self.createAttachNode(arena, ctx.decls, ast.NodeUse,
517 ast.NodeUse {
496 const node = try self.createAttachNode(arena, ctx.decls, ast.Node.Use,
497 ast.Node.Use {
518498 .base = undefined,
519499 .visib_token = ctx.visib_token,
520500 .expr = undefined,
......@@ -539,6 +519,7 @@ pub const Parser = struct {
539519
540520 stack.append(State {
541521 .VarDecl = VarDeclCtx {
522 .comments = comments,
542523 .visib_token = ctx.visib_token,
543524 .lib_name = ctx.lib_name,
544525 .comptime_token = null,
......@@ -551,9 +532,10 @@ pub const Parser = struct {
551532 },
552533 Token.Id.Keyword_fn, Token.Id.Keyword_nakedcc,
553534 Token.Id.Keyword_stdcallcc, Token.Id.Keyword_async => {
554 const fn_proto = try self.createAttachNode(arena, ctx.decls, ast.NodeFnProto,
555 ast.NodeFnProto {
535 const fn_proto = try self.createAttachNode(arena, ctx.decls, ast.Node.FnProto,
536 ast.Node.FnProto {
556537 .base = undefined,
538 .comments = comments,
557539 .visib_token = ctx.visib_token,
558540 .name_token = null,
559541 .fn_token = undefined,
......@@ -583,8 +565,8 @@ pub const Parser = struct {
583565 continue;
584566 },
585567 Token.Id.Keyword_async => {
586 const async_node = try self.createNode(arena, ast.NodeAsyncAttribute,
587 ast.NodeAsyncAttribute {
568 const async_node = try self.createNode(arena, ast.Node.AsyncAttribute,
569 ast.Node.AsyncAttribute {
588570 .base = undefined,
589571 .async_token = token,
590572 .allocator_type = null,
......@@ -616,9 +598,9 @@ pub const Parser = struct {
616598 },
617599 State.TopLevelExternOrField => |ctx| {
618600 if (self.eatToken(Token.Id.Identifier)) |identifier| {
619 std.debug.assert(ctx.container_decl.kind == ast.NodeContainerDecl.Kind.Struct);
620 const node = try self.createAttachNode(arena, &ctx.container_decl.fields_and_decls, ast.NodeStructField,
621 ast.NodeStructField {
601 std.debug.assert(ctx.container_decl.kind == ast.Node.ContainerDecl.Kind.Struct);
602 const node = try self.createAttachNode(arena, &ctx.container_decl.fields_and_decls, ast.Node.StructField,
603 ast.Node.StructField {
622604 .base = undefined,
623605 .visib_token = ctx.visib_token,
624606 .name_token = identifier,
......@@ -647,15 +629,15 @@ pub const Parser = struct {
647629
648630 State.ContainerKind => |ctx| {
649631 const token = self.getNextToken();
650 const node = try self.createToCtxNode(arena, ctx.opt_ctx, ast.NodeContainerDecl,
651 ast.NodeContainerDecl {
632 const node = try self.createToCtxNode(arena, ctx.opt_ctx, ast.Node.ContainerDecl,
633 ast.Node.ContainerDecl {
652634 .base = undefined,
653635 .ltoken = ctx.ltoken,
654636 .layout = ctx.layout,
655637 .kind = switch (token.id) {
656 Token.Id.Keyword_struct => ast.NodeContainerDecl.Kind.Struct,
657 Token.Id.Keyword_union => ast.NodeContainerDecl.Kind.Union,
658 Token.Id.Keyword_enum => ast.NodeContainerDecl.Kind.Enum,
638 Token.Id.Keyword_struct => ast.Node.ContainerDecl.Kind.Struct,
639 Token.Id.Keyword_union => ast.Node.ContainerDecl.Kind.Union,
640 Token.Id.Keyword_enum => ast.Node.ContainerDecl.Kind.Enum,
659641 else => {
660642 return self.parseError(token, "expected {}, {} or {}, found {}",
661643 @tagName(Token.Id.Keyword_struct),
......@@ -664,7 +646,7 @@ pub const Parser = struct {
664646 @tagName(token.id));
665647 },
666648 },
667 .init_arg_expr = ast.NodeContainerDecl.InitArg.None,
649 .init_arg_expr = ast.Node.ContainerDecl.InitArg.None,
668650 .fields_and_decls = ArrayList(&ast.Node).init(arena),
669651 .rbrace_token = undefined,
670652 }
......@@ -690,11 +672,11 @@ pub const Parser = struct {
690672 const init_arg_token = self.getNextToken();
691673 switch (init_arg_token.id) {
692674 Token.Id.Keyword_enum => {
693 container_decl.init_arg_expr = ast.NodeContainerDecl.InitArg.Enum;
675 container_decl.init_arg_expr = ast.Node.ContainerDecl.InitArg.Enum;
694676 },
695677 else => {
696678 self.putBackToken(init_arg_token);
697 container_decl.init_arg_expr = ast.NodeContainerDecl.InitArg { .Type = undefined };
679 container_decl.init_arg_expr = ast.Node.ContainerDecl.InitArg { .Type = undefined };
698680 stack.append(State { .Expression = OptionalCtx { .Required = &container_decl.init_arg_expr.Type } }) catch unreachable;
699681 },
700682 }
......@@ -705,9 +687,9 @@ pub const Parser = struct {
705687 switch (token.id) {
706688 Token.Id.Identifier => {
707689 switch (container_decl.kind) {
708 ast.NodeContainerDecl.Kind.Struct => {
709 const node = try self.createAttachNode(arena, &container_decl.fields_and_decls, ast.NodeStructField,
710 ast.NodeStructField {
690 ast.Node.ContainerDecl.Kind.Struct => {
691 const node = try self.createAttachNode(arena, &container_decl.fields_and_decls, ast.Node.StructField,
692 ast.Node.StructField {
711693 .base = undefined,
712694 .visib_token = null,
713695 .name_token = token,
......@@ -720,9 +702,9 @@ pub const Parser = struct {
720702 try stack.append(State { .ExpectToken = Token.Id.Colon });
721703 continue;
722704 },
723 ast.NodeContainerDecl.Kind.Union => {
724 const node = try self.createAttachNode(arena, &container_decl.fields_and_decls, ast.NodeUnionTag,
725 ast.NodeUnionTag {
705 ast.Node.ContainerDecl.Kind.Union => {
706 const node = try self.createAttachNode(arena, &container_decl.fields_and_decls, ast.Node.UnionTag,
707 ast.Node.UnionTag {
726708 .base = undefined,
727709 .name_token = token,
728710 .type_expr = null,
......@@ -734,9 +716,9 @@ pub const Parser = struct {
734716 try stack.append(State { .IfToken = Token.Id.Colon });
735717 continue;
736718 },
737 ast.NodeContainerDecl.Kind.Enum => {
738 const node = try self.createAttachNode(arena, &container_decl.fields_and_decls, ast.NodeEnumTag,
739 ast.NodeEnumTag {
719 ast.Node.ContainerDecl.Kind.Enum => {
720 const node = try self.createAttachNode(arena, &container_decl.fields_and_decls, ast.Node.EnumTag,
721 ast.Node.EnumTag {
740722 .base = undefined,
741723 .name_token = token,
742724 .value = null,
......@@ -752,7 +734,7 @@ pub const Parser = struct {
752734 },
753735 Token.Id.Keyword_pub => {
754736 switch (container_decl.kind) {
755 ast.NodeContainerDecl.Kind.Struct => {
737 ast.Node.ContainerDecl.Kind.Struct => {
756738 try stack.append(State {
757739 .TopLevelExternOrField = TopLevelExternOrFieldCtx {
758740 .visib_token = token,
......@@ -809,9 +791,10 @@ pub const Parser = struct {
809791
810792
811793 State.VarDecl => |ctx| {
812 const var_decl = try self.createAttachNode(arena, ctx.list, ast.NodeVarDecl,
813 ast.NodeVarDecl {
794 const var_decl = try self.createAttachNode(arena, ctx.list, ast.Node.VarDecl,
795 ast.Node.VarDecl {
814796 .base = undefined,
797 .comments = ctx.comments,
815798 .visib_token = ctx.visib_token,
816799 .mut_token = ctx.mut_token,
817800 .comptime_token = ctx.comptime_token,
......@@ -881,8 +864,8 @@ pub const Parser = struct {
881864 const token = self.getNextToken();
882865 switch(token.id) {
883866 Token.Id.LBrace => {
884 const block = try self.createNode(arena, ast.NodeBlock,
885 ast.NodeBlock {
867 const block = try self.createNode(arena, ast.Node.Block,
868 ast.Node.Block {
886869 .base = undefined,
887870 .label = null,
888871 .lbrace = token,
......@@ -924,7 +907,7 @@ pub const Parser = struct {
924907 const token = self.getNextToken();
925908 switch (token.id) {
926909 Token.Id.Bang => {
927 fn_proto.return_type = ast.NodeFnProto.ReturnType { .InferErrorSet = undefined };
910 fn_proto.return_type = ast.Node.FnProto.ReturnType { .InferErrorSet = undefined };
928911 stack.append(State {
929912 .TypeExprBegin = OptionalCtx { .Required = &fn_proto.return_type.InferErrorSet },
930913 }) catch unreachable;
......@@ -934,15 +917,15 @@ pub const Parser = struct {
934917 // TODO: this is a special case. Remove this when #760 is fixed
935918 if (token.id == Token.Id.Keyword_error) {
936919 if (self.isPeekToken(Token.Id.LBrace)) {
937 fn_proto.return_type = ast.NodeFnProto.ReturnType {
938 .Explicit = &(try self.createLiteral(arena, ast.NodeErrorType, token)).base
920 fn_proto.return_type = ast.Node.FnProto.ReturnType {
921 .Explicit = &(try self.createLiteral(arena, ast.Node.ErrorType, token)).base
939922 };
940923 continue;
941924 }
942925 }
943926
944927 self.putBackToken(token);
945 fn_proto.return_type = ast.NodeFnProto.ReturnType { .Explicit = undefined };
928 fn_proto.return_type = ast.Node.FnProto.ReturnType { .Explicit = undefined };
946929 stack.append(State { .TypeExprBegin = OptionalCtx { .Required = &fn_proto.return_type.Explicit }, }) catch unreachable;
947930 continue;
948931 },
......@@ -954,8 +937,8 @@ pub const Parser = struct {
954937 if (self.eatToken(Token.Id.RParen)) |_| {
955938 continue;
956939 }
957 const param_decl = try self.createAttachNode(arena, &fn_proto.params, ast.NodeParamDecl,
958 ast.NodeParamDecl {
940 const param_decl = try self.createAttachNode(arena, &fn_proto.params, ast.Node.ParamDecl,
941 ast.Node.ParamDecl {
959942 .base = undefined,
960943 .comptime_token = null,
961944 .noalias_token = null,
......@@ -1026,15 +1009,15 @@ pub const Parser = struct {
10261009 continue;
10271010 }
10281011
1029 _ = try self.createToCtxLiteral(arena, ctx.opt_ctx, ast.NodeIdentifier, ctx.label);
1012 _ = try self.createToCtxLiteral(arena, ctx.opt_ctx, ast.Node.Identifier, ctx.label);
10301013 continue;
10311014 },
10321015 State.LabeledExpression => |ctx| {
10331016 const token = self.getNextToken();
10341017 switch (token.id) {
10351018 Token.Id.LBrace => {
1036 const block = try self.createToCtxNode(arena, ctx.opt_ctx, ast.NodeBlock,
1037 ast.NodeBlock {
1019 const block = try self.createToCtxNode(arena, ctx.opt_ctx, ast.Node.Block,
1020 ast.Node.Block {
10381021 .base = undefined,
10391022 .label = ctx.label,
10401023 .lbrace = token,
......@@ -1123,8 +1106,8 @@ pub const Parser = struct {
11231106 }
11241107 },
11251108 State.While => |ctx| {
1126 const node = try self.createToCtxNode(arena, ctx.opt_ctx, ast.NodeWhile,
1127 ast.NodeWhile {
1109 const node = try self.createToCtxNode(arena, ctx.opt_ctx, ast.Node.While,
1110 ast.Node.While {
11281111 .base = undefined,
11291112 .label = ctx.label,
11301113 .inline_token = ctx.inline_token,
......@@ -1153,8 +1136,8 @@ pub const Parser = struct {
11531136 continue;
11541137 },
11551138 State.For => |ctx| {
1156 const node = try self.createToCtxNode(arena, ctx.opt_ctx, ast.NodeFor,
1157 ast.NodeFor {
1139 const node = try self.createToCtxNode(arena, ctx.opt_ctx, ast.Node.For,
1140 ast.Node.For {
11581141 .base = undefined,
11591142 .label = ctx.label,
11601143 .inline_token = ctx.inline_token,
......@@ -1175,8 +1158,8 @@ pub const Parser = struct {
11751158 },
11761159 State.Else => |dest| {
11771160 if (self.eatToken(Token.Id.Keyword_else)) |else_token| {
1178 const node = try self.createNode(arena, ast.NodeElse,
1179 ast.NodeElse {
1161 const node = try self.createNode(arena, ast.Node.Else,
1162 ast.Node.Else {
11801163 .base = undefined,
11811164 .else_token = else_token,
11821165 .payload = null,
......@@ -1210,6 +1193,7 @@ pub const Parser = struct {
12101193 }
12111194 },
12121195 State.Statement => |block| {
1196 const comments = try self.eatComments(arena);
12131197 const token = self.getNextToken();
12141198 switch (token.id) {
12151199 Token.Id.Keyword_comptime => {
......@@ -1224,6 +1208,7 @@ pub const Parser = struct {
12241208 Token.Id.Keyword_var, Token.Id.Keyword_const => {
12251209 stack.append(State {
12261210 .VarDecl = VarDeclCtx {
1211 .comments = comments,
12271212 .visib_token = null,
12281213 .comptime_token = null,
12291214 .extern_export_token = null,
......@@ -1235,13 +1220,13 @@ pub const Parser = struct {
12351220 continue;
12361221 },
12371222 Token.Id.Keyword_defer, Token.Id.Keyword_errdefer => {
1238 const node = try self.createAttachNode(arena, &block.statements, ast.NodeDefer,
1239 ast.NodeDefer {
1223 const node = try self.createAttachNode(arena, &block.statements, ast.Node.Defer,
1224 ast.Node.Defer {
12401225 .base = undefined,
12411226 .defer_token = token,
12421227 .kind = switch (token.id) {
1243 Token.Id.Keyword_defer => ast.NodeDefer.Kind.Unconditional,
1244 Token.Id.Keyword_errdefer => ast.NodeDefer.Kind.Error,
1228 Token.Id.Keyword_defer => ast.Node.Defer.Kind.Unconditional,
1229 Token.Id.Keyword_errdefer => ast.Node.Defer.Kind.Error,
12451230 else => unreachable,
12461231 },
12471232 .expr = undefined,
......@@ -1252,8 +1237,8 @@ pub const Parser = struct {
12521237 continue;
12531238 },
12541239 Token.Id.LBrace => {
1255 const inner_block = try self.createAttachNode(arena, &block.statements, ast.NodeBlock,
1256 ast.NodeBlock {
1240 const inner_block = try self.createAttachNode(arena, &block.statements, ast.Node.Block,
1241 ast.Node.Block {
12571242 .base = undefined,
12581243 .label = null,
12591244 .lbrace = token,
......@@ -1274,11 +1259,13 @@ pub const Parser = struct {
12741259 }
12751260 },
12761261 State.ComptimeStatement => |ctx| {
1262 const comments = try self.eatComments(arena);
12771263 const token = self.getNextToken();
12781264 switch (token.id) {
12791265 Token.Id.Keyword_var, Token.Id.Keyword_const => {
12801266 stack.append(State {
12811267 .VarDecl = VarDeclCtx {
1268 .comments = comments,
12821269 .visib_token = null,
12831270 .comptime_token = ctx.comptime_token,
12841271 .extern_export_token = null,
......@@ -1316,8 +1303,8 @@ pub const Parser = struct {
13161303 continue;
13171304 }
13181305
1319 const node = try self.createNode(arena, ast.NodeAsmOutput,
1320 ast.NodeAsmOutput {
1306 const node = try self.createNode(arena, ast.Node.AsmOutput,
1307 ast.Node.AsmOutput {
13211308 .base = undefined,
13221309 .symbolic_name = undefined,
13231310 .constraint = undefined,
......@@ -1340,11 +1327,11 @@ pub const Parser = struct {
13401327 const token = self.getNextToken();
13411328 switch (token.id) {
13421329 Token.Id.Identifier => {
1343 node.kind = ast.NodeAsmOutput.Kind { .Variable = try self.createLiteral(arena, ast.NodeIdentifier, token) };
1330 node.kind = ast.Node.AsmOutput.Kind { .Variable = try self.createLiteral(arena, ast.Node.Identifier, token) };
13441331 continue;
13451332 },
13461333 Token.Id.Arrow => {
1347 node.kind = ast.NodeAsmOutput.Kind { .Return = undefined };
1334 node.kind = ast.Node.AsmOutput.Kind { .Return = undefined };
13481335 try stack.append(State { .TypeExprBegin = OptionalCtx { .Required = &node.kind.Return } });
13491336 continue;
13501337 },
......@@ -1362,8 +1349,8 @@ pub const Parser = struct {
13621349 continue;
13631350 }
13641351
1365 const node = try self.createNode(arena, ast.NodeAsmInput,
1366 ast.NodeAsmInput {
1352 const node = try self.createNode(arena, ast.Node.AsmInput,
1353 ast.Node.AsmInput {
13671354 .base = undefined,
13681355 .symbolic_name = undefined,
13691356 .constraint = undefined,
......@@ -1415,8 +1402,8 @@ pub const Parser = struct {
14151402 continue;
14161403 }
14171404
1418 const node = try self.createNode(arena, ast.NodeFieldInitializer,
1419 ast.NodeFieldInitializer {
1405 const node = try self.createNode(arena, ast.Node.FieldInitializer,
1406 ast.Node.FieldInitializer {
14201407 .base = undefined,
14211408 .period_token = undefined,
14221409 .name_token = undefined,
......@@ -1485,8 +1472,8 @@ pub const Parser = struct {
14851472 continue;
14861473 }
14871474
1488 const node = try self.createNode(arena, ast.NodeSwitchCase,
1489 ast.NodeSwitchCase {
1475 const node = try self.createNode(arena, ast.Node.SwitchCase,
1476 ast.Node.SwitchCase {
14901477 .base = undefined,
14911478 .items = ArrayList(&ast.Node).init(arena),
14921479 .payload = null,
......@@ -1512,8 +1499,8 @@ pub const Parser = struct {
15121499 State.SwitchCaseFirstItem => |case_items| {
15131500 const token = self.getNextToken();
15141501 if (token.id == Token.Id.Keyword_else) {
1515 const else_node = try self.createAttachNode(arena, case_items, ast.NodeSwitchElse,
1516 ast.NodeSwitchElse {
1502 const else_node = try self.createAttachNode(arena, case_items, ast.Node.SwitchElse,
1503 ast.Node.SwitchElse {
15171504 .base = undefined,
15181505 .token = token,
15191506 }
......@@ -1564,24 +1551,24 @@ pub const Parser = struct {
15641551
15651552 switch (node.id) {
15661553 ast.Node.Id.FnProto => {
1567 const fn_proto = @fieldParentPtr(ast.NodeFnProto, "base", node);
1554 const fn_proto = @fieldParentPtr(ast.Node.FnProto, "base", node);
15681555 fn_proto.async_attr = ctx.attribute;
15691556 continue;
15701557 },
15711558 ast.Node.Id.SuffixOp => {
1572 const suffix_op = @fieldParentPtr(ast.NodeSuffixOp, "base", node);
1573 if (suffix_op.op == ast.NodeSuffixOp.SuffixOp.Call) {
1559 const suffix_op = @fieldParentPtr(ast.Node.SuffixOp, "base", node);
1560 if (suffix_op.op == ast.Node.SuffixOp.Op.Call) {
15741561 suffix_op.op.Call.async_attr = ctx.attribute;
15751562 continue;
15761563 }
15771564
15781565 return self.parseError(node.firstToken(), "expected {}, found {}.",
1579 @tagName(ast.NodeSuffixOp.SuffixOp.Call),
1566 @tagName(ast.Node.SuffixOp.Op.Call),
15801567 @tagName(suffix_op.op));
15811568 },
15821569 else => {
15831570 return self.parseError(node.firstToken(), "expected {} or {}, found {}.",
1584 @tagName(ast.NodeSuffixOp.SuffixOp.Call),
1571 @tagName(ast.Node.SuffixOp.Op.Call),
15851572 @tagName(ast.Node.Id.FnProto),
15861573 @tagName(node.id));
15871574 }
......@@ -1591,9 +1578,10 @@ pub const Parser = struct {
15911578
15921579 State.ExternType => |ctx| {
15931580 if (self.eatToken(Token.Id.Keyword_fn)) |fn_token| {
1594 const fn_proto = try self.createToCtxNode(arena, ctx.opt_ctx, ast.NodeFnProto,
1595 ast.NodeFnProto {
1581 const fn_proto = try self.createToCtxNode(arena, ctx.opt_ctx, ast.Node.FnProto,
1582 ast.Node.FnProto {
15961583 .base = undefined,
1584 .comments = ctx.comments,
15971585 .visib_token = null,
15981586 .name_token = null,
15991587 .fn_token = fn_token,
......@@ -1616,7 +1604,7 @@ pub const Parser = struct {
16161604 .ContainerKind = ContainerKindCtx {
16171605 .opt_ctx = ctx.opt_ctx,
16181606 .ltoken = ctx.extern_token,
1619 .layout = ast.NodeContainerDecl.Layout.Extern,
1607 .layout = ast.Node.ContainerDecl.Layout.Extern,
16201608 },
16211609 }) catch unreachable;
16221610 continue;
......@@ -1626,8 +1614,8 @@ pub const Parser = struct {
16261614 switch (token.id) {
16271615 Token.Id.Ellipsis2 => {
16281616 const start = node.op.ArrayAccess;
1629 node.op = ast.NodeSuffixOp.SuffixOp {
1630 .Slice = ast.NodeSuffixOp.SliceRange {
1617 node.op = ast.Node.SuffixOp.Op {
1618 .Slice = ast.Node.SuffixOp.SliceRange {
16311619 .start = start,
16321620 .end = null,
16331621 }
......@@ -1653,8 +1641,8 @@ pub const Parser = struct {
16531641 },
16541642 State.SliceOrArrayType => |node| {
16551643 if (self.eatToken(Token.Id.RBracket)) |_| {
1656 node.op = ast.NodePrefixOp.PrefixOp {
1657 .SliceType = ast.NodePrefixOp.AddrOfInfo {
1644 node.op = ast.Node.PrefixOp.Op {
1645 .SliceType = ast.Node.PrefixOp.AddrOfInfo {
16581646 .align_expr = null,
16591647 .bit_offset_start_token = null,
16601648 .bit_offset_end_token = null,
......@@ -1667,7 +1655,7 @@ pub const Parser = struct {
16671655 continue;
16681656 }
16691657
1670 node.op = ast.NodePrefixOp.PrefixOp { .ArrayType = undefined };
1658 node.op = ast.Node.PrefixOp.Op { .ArrayType = undefined };
16711659 stack.append(State { .TypeExprBegin = OptionalCtx { .Required = &node.rhs } }) catch unreachable;
16721660 try stack.append(State { .ExpectToken = Token.Id.RBracket });
16731661 try stack.append(State { .Expression = OptionalCtx { .Required = &node.op.ArrayType } });
......@@ -1723,8 +1711,8 @@ pub const Parser = struct {
17231711 continue;
17241712 }
17251713
1726 const node = try self.createToCtxNode(arena, opt_ctx, ast.NodePayload,
1727 ast.NodePayload {
1714 const node = try self.createToCtxNode(arena, opt_ctx, ast.Node.Payload,
1715 ast.Node.Payload {
17281716 .base = undefined,
17291717 .lpipe = token,
17301718 .error_symbol = undefined,
......@@ -1754,8 +1742,8 @@ pub const Parser = struct {
17541742 continue;
17551743 }
17561744
1757 const node = try self.createToCtxNode(arena, opt_ctx, ast.NodePointerPayload,
1758 ast.NodePointerPayload {
1745 const node = try self.createToCtxNode(arena, opt_ctx, ast.Node.PointerPayload,
1746 ast.Node.PointerPayload {
17591747 .base = undefined,
17601748 .lpipe = token,
17611749 .ptr_token = null,
......@@ -1792,8 +1780,8 @@ pub const Parser = struct {
17921780 continue;
17931781 }
17941782
1795 const node = try self.createToCtxNode(arena, opt_ctx, ast.NodePointerIndexPayload,
1796 ast.NodePointerIndexPayload {
1783 const node = try self.createToCtxNode(arena, opt_ctx, ast.Node.PointerIndexPayload,
1784 ast.Node.PointerIndexPayload {
17971785 .base = undefined,
17981786 .lpipe = token,
17991787 .ptr_token = null,
......@@ -1826,8 +1814,8 @@ pub const Parser = struct {
18261814 const token = self.getNextToken();
18271815 switch (token.id) {
18281816 Token.Id.Keyword_return, Token.Id.Keyword_break, Token.Id.Keyword_continue => {
1829 const node = try self.createToCtxNode(arena, opt_ctx, ast.NodeControlFlowExpression,
1830 ast.NodeControlFlowExpression {
1817 const node = try self.createToCtxNode(arena, opt_ctx, ast.Node.ControlFlowExpression,
1818 ast.Node.ControlFlowExpression {
18311819 .base = undefined,
18321820 .ltoken = token,
18331821 .kind = undefined,
......@@ -1839,31 +1827,31 @@ pub const Parser = struct {
18391827
18401828 switch (token.id) {
18411829 Token.Id.Keyword_break => {
1842 node.kind = ast.NodeControlFlowExpression.Kind { .Break = null };
1830 node.kind = ast.Node.ControlFlowExpression.Kind { .Break = null };
18431831 try stack.append(State { .Identifier = OptionalCtx { .RequiredNull = &node.kind.Break } });
18441832 try stack.append(State { .IfToken = Token.Id.Colon });
18451833 },
18461834 Token.Id.Keyword_continue => {
1847 node.kind = ast.NodeControlFlowExpression.Kind { .Continue = null };
1835 node.kind = ast.Node.ControlFlowExpression.Kind { .Continue = null };
18481836 try stack.append(State { .Identifier = OptionalCtx { .RequiredNull = &node.kind.Continue } });
18491837 try stack.append(State { .IfToken = Token.Id.Colon });
18501838 },
18511839 Token.Id.Keyword_return => {
1852 node.kind = ast.NodeControlFlowExpression.Kind.Return;
1840 node.kind = ast.Node.ControlFlowExpression.Kind.Return;
18531841 },
18541842 else => unreachable,
18551843 }
18561844 continue;
18571845 },
18581846 Token.Id.Keyword_try, Token.Id.Keyword_cancel, Token.Id.Keyword_resume => {
1859 const node = try self.createToCtxNode(arena, opt_ctx, ast.NodePrefixOp,
1860 ast.NodePrefixOp {
1847 const node = try self.createToCtxNode(arena, opt_ctx, ast.Node.PrefixOp,
1848 ast.Node.PrefixOp {
18611849 .base = undefined,
18621850 .op_token = token,
18631851 .op = switch (token.id) {
1864 Token.Id.Keyword_try => ast.NodePrefixOp.PrefixOp { .Try = void{} },
1865 Token.Id.Keyword_cancel => ast.NodePrefixOp.PrefixOp { .Cancel = void{} },
1866 Token.Id.Keyword_resume => ast.NodePrefixOp.PrefixOp { .Resume = void{} },
1852 Token.Id.Keyword_try => ast.Node.PrefixOp.Op { .Try = void{} },
1853 Token.Id.Keyword_cancel => ast.Node.PrefixOp.Op { .Cancel = void{} },
1854 Token.Id.Keyword_resume => ast.Node.PrefixOp.Op { .Resume = void{} },
18671855 else => unreachable,
18681856 },
18691857 .rhs = undefined,
......@@ -1891,12 +1879,12 @@ pub const Parser = struct {
18911879 const lhs = opt_ctx.get() ?? continue;
18921880
18931881 if (self.eatToken(Token.Id.Ellipsis3)) |ellipsis3| {
1894 const node = try self.createToCtxNode(arena, opt_ctx, ast.NodeInfixOp,
1895 ast.NodeInfixOp {
1882 const node = try self.createToCtxNode(arena, opt_ctx, ast.Node.InfixOp,
1883 ast.Node.InfixOp {
18961884 .base = undefined,
18971885 .lhs = lhs,
18981886 .op_token = ellipsis3,
1899 .op = ast.NodeInfixOp.InfixOp.Range,
1887 .op = ast.Node.InfixOp.Op.Range,
19001888 .rhs = undefined,
19011889 }
19021890 );
......@@ -1915,8 +1903,8 @@ pub const Parser = struct {
19151903
19161904 const token = self.getNextToken();
19171905 if (tokenIdToAssignment(token.id)) |ass_id| {
1918 const node = try self.createToCtxNode(arena, opt_ctx, ast.NodeInfixOp,
1919 ast.NodeInfixOp {
1906 const node = try self.createToCtxNode(arena, opt_ctx, ast.Node.InfixOp,
1907 ast.Node.InfixOp {
19201908 .base = undefined,
19211909 .lhs = lhs,
19221910 .op_token = token,
......@@ -1944,8 +1932,8 @@ pub const Parser = struct {
19441932
19451933 const token = self.getNextToken();
19461934 if (tokenIdToUnwrapExpr(token.id)) |unwrap_id| {
1947 const node = try self.createToCtxNode(arena, opt_ctx, ast.NodeInfixOp,
1948 ast.NodeInfixOp {
1935 const node = try self.createToCtxNode(arena, opt_ctx, ast.Node.InfixOp,
1936 ast.Node.InfixOp {
19491937 .base = undefined,
19501938 .lhs = lhs,
19511939 .op_token = token,
......@@ -1957,7 +1945,7 @@ pub const Parser = struct {
19571945 stack.append(State { .UnwrapExpressionEnd = opt_ctx.toRequired() }) catch unreachable;
19581946 try stack.append(State { .Expression = OptionalCtx { .Required = &node.rhs } });
19591947
1960 if (node.op == ast.NodeInfixOp.InfixOp.Catch) {
1948 if (node.op == ast.Node.InfixOp.Op.Catch) {
19611949 try stack.append(State { .Payload = OptionalCtx { .Optional = &node.op.Catch } });
19621950 }
19631951 continue;
......@@ -1977,12 +1965,12 @@ pub const Parser = struct {
19771965 const lhs = opt_ctx.get() ?? continue;
19781966
19791967 if (self.eatToken(Token.Id.Keyword_or)) |or_token| {
1980 const node = try self.createToCtxNode(arena, opt_ctx, ast.NodeInfixOp,
1981 ast.NodeInfixOp {
1968 const node = try self.createToCtxNode(arena, opt_ctx, ast.Node.InfixOp,
1969 ast.Node.InfixOp {
19821970 .base = undefined,
19831971 .lhs = lhs,
19841972 .op_token = or_token,
1985 .op = ast.NodeInfixOp.InfixOp.BoolOr,
1973 .op = ast.Node.InfixOp.Op.BoolOr,
19861974 .rhs = undefined,
19871975 }
19881976 );
......@@ -2002,12 +1990,12 @@ pub const Parser = struct {
20021990 const lhs = opt_ctx.get() ?? continue;
20031991
20041992 if (self.eatToken(Token.Id.Keyword_and)) |and_token| {
2005 const node = try self.createToCtxNode(arena, opt_ctx, ast.NodeInfixOp,
2006 ast.NodeInfixOp {
1993 const node = try self.createToCtxNode(arena, opt_ctx, ast.Node.InfixOp,
1994 ast.Node.InfixOp {
20071995 .base = undefined,
20081996 .lhs = lhs,
20091997 .op_token = and_token,
2010 .op = ast.NodeInfixOp.InfixOp.BoolAnd,
1998 .op = ast.Node.InfixOp.Op.BoolAnd,
20111999 .rhs = undefined,
20122000 }
20132001 );
......@@ -2028,8 +2016,8 @@ pub const Parser = struct {
20282016
20292017 const token = self.getNextToken();
20302018 if (tokenIdToComparison(token.id)) |comp_id| {
2031 const node = try self.createToCtxNode(arena, opt_ctx, ast.NodeInfixOp,
2032 ast.NodeInfixOp {
2019 const node = try self.createToCtxNode(arena, opt_ctx, ast.Node.InfixOp,
2020 ast.Node.InfixOp {
20332021 .base = undefined,
20342022 .lhs = lhs,
20352023 .op_token = token,
......@@ -2056,12 +2044,12 @@ pub const Parser = struct {
20562044 const lhs = opt_ctx.get() ?? continue;
20572045
20582046 if (self.eatToken(Token.Id.Pipe)) |pipe| {
2059 const node = try self.createToCtxNode(arena, opt_ctx, ast.NodeInfixOp,
2060 ast.NodeInfixOp {
2047 const node = try self.createToCtxNode(arena, opt_ctx, ast.Node.InfixOp,
2048 ast.Node.InfixOp {
20612049 .base = undefined,
20622050 .lhs = lhs,
20632051 .op_token = pipe,
2064 .op = ast.NodeInfixOp.InfixOp.BitOr,
2052 .op = ast.Node.InfixOp.Op.BitOr,
20652053 .rhs = undefined,
20662054 }
20672055 );
......@@ -2081,12 +2069,12 @@ pub const Parser = struct {
20812069 const lhs = opt_ctx.get() ?? continue;
20822070
20832071 if (self.eatToken(Token.Id.Caret)) |caret| {
2084 const node = try self.createToCtxNode(arena, opt_ctx, ast.NodeInfixOp,
2085 ast.NodeInfixOp {
2072 const node = try self.createToCtxNode(arena, opt_ctx, ast.Node.InfixOp,
2073 ast.Node.InfixOp {
20862074 .base = undefined,
20872075 .lhs = lhs,
20882076 .op_token = caret,
2089 .op = ast.NodeInfixOp.InfixOp.BitXor,
2077 .op = ast.Node.InfixOp.Op.BitXor,
20902078 .rhs = undefined,
20912079 }
20922080 );
......@@ -2106,12 +2094,12 @@ pub const Parser = struct {
21062094 const lhs = opt_ctx.get() ?? continue;
21072095
21082096 if (self.eatToken(Token.Id.Ampersand)) |ampersand| {
2109 const node = try self.createToCtxNode(arena, opt_ctx, ast.NodeInfixOp,
2110 ast.NodeInfixOp {
2097 const node = try self.createToCtxNode(arena, opt_ctx, ast.Node.InfixOp,
2098 ast.Node.InfixOp {
21112099 .base = undefined,
21122100 .lhs = lhs,
21132101 .op_token = ampersand,
2114 .op = ast.NodeInfixOp.InfixOp.BitAnd,
2102 .op = ast.Node.InfixOp.Op.BitAnd,
21152103 .rhs = undefined,
21162104 }
21172105 );
......@@ -2132,8 +2120,8 @@ pub const Parser = struct {
21322120
21332121 const token = self.getNextToken();
21342122 if (tokenIdToBitShift(token.id)) |bitshift_id| {
2135 const node = try self.createToCtxNode(arena, opt_ctx, ast.NodeInfixOp,
2136 ast.NodeInfixOp {
2123 const node = try self.createToCtxNode(arena, opt_ctx, ast.Node.InfixOp,
2124 ast.Node.InfixOp {
21372125 .base = undefined,
21382126 .lhs = lhs,
21392127 .op_token = token,
......@@ -2161,8 +2149,8 @@ pub const Parser = struct {
21612149
21622150 const token = self.getNextToken();
21632151 if (tokenIdToAddition(token.id)) |add_id| {
2164 const node = try self.createToCtxNode(arena, opt_ctx, ast.NodeInfixOp,
2165 ast.NodeInfixOp {
2152 const node = try self.createToCtxNode(arena, opt_ctx, ast.Node.InfixOp,
2153 ast.Node.InfixOp {
21662154 .base = undefined,
21672155 .lhs = lhs,
21682156 .op_token = token,
......@@ -2190,8 +2178,8 @@ pub const Parser = struct {
21902178
21912179 const token = self.getNextToken();
21922180 if (tokenIdToMultiply(token.id)) |mult_id| {
2193 const node = try self.createToCtxNode(arena, opt_ctx, ast.NodeInfixOp,
2194 ast.NodeInfixOp {
2181 const node = try self.createToCtxNode(arena, opt_ctx, ast.Node.InfixOp,
2182 ast.Node.InfixOp {
21952183 .base = undefined,
21962184 .lhs = lhs,
21972185 .op_token = token,
......@@ -2219,12 +2207,12 @@ pub const Parser = struct {
22192207 const lhs = opt_ctx.get() ?? continue;
22202208
22212209 if (self.isPeekToken(Token.Id.Period)) {
2222 const node = try self.createToCtxNode(arena, opt_ctx, ast.NodeSuffixOp,
2223 ast.NodeSuffixOp {
2210 const node = try self.createToCtxNode(arena, opt_ctx, ast.Node.SuffixOp,
2211 ast.Node.SuffixOp {
22242212 .base = undefined,
22252213 .lhs = lhs,
2226 .op = ast.NodeSuffixOp.SuffixOp {
2227 .StructInitializer = ArrayList(&ast.NodeFieldInitializer).init(arena),
2214 .op = ast.Node.SuffixOp.Op {
2215 .StructInitializer = ArrayList(&ast.Node.FieldInitializer).init(arena),
22282216 },
22292217 .rtoken = undefined,
22302218 }
......@@ -2232,7 +2220,7 @@ pub const Parser = struct {
22322220 stack.append(State { .CurlySuffixExpressionEnd = opt_ctx.toRequired() }) catch unreachable;
22332221 try stack.append(State { .IfToken = Token.Id.LBrace });
22342222 try stack.append(State {
2235 .FieldInitListItemOrEnd = ListSave(&ast.NodeFieldInitializer) {
2223 .FieldInitListItemOrEnd = ListSave(&ast.Node.FieldInitializer) {
22362224 .list = &node.op.StructInitializer,
22372225 .ptr = &node.rtoken,
22382226 }
......@@ -2240,11 +2228,11 @@ pub const Parser = struct {
22402228 continue;
22412229 }
22422230
2243 const node = try self.createToCtxNode(arena, opt_ctx, ast.NodeSuffixOp,
2244 ast.NodeSuffixOp {
2231 const node = try self.createToCtxNode(arena, opt_ctx, ast.Node.SuffixOp,
2232 ast.Node.SuffixOp {
22452233 .base = undefined,
22462234 .lhs = lhs,
2247 .op = ast.NodeSuffixOp.SuffixOp {
2235 .op = ast.Node.SuffixOp.Op {
22482236 .ArrayInitializer = ArrayList(&ast.Node).init(arena),
22492237 },
22502238 .rtoken = undefined,
......@@ -2272,12 +2260,12 @@ pub const Parser = struct {
22722260 const lhs = opt_ctx.get() ?? continue;
22732261
22742262 if (self.eatToken(Token.Id.Bang)) |bang| {
2275 const node = try self.createToCtxNode(arena, opt_ctx, ast.NodeInfixOp,
2276 ast.NodeInfixOp {
2263 const node = try self.createToCtxNode(arena, opt_ctx, ast.Node.InfixOp,
2264 ast.Node.InfixOp {
22772265 .base = undefined,
22782266 .lhs = lhs,
22792267 .op_token = bang,
2280 .op = ast.NodeInfixOp.InfixOp.ErrorUnion,
2268 .op = ast.Node.InfixOp.Op.ErrorUnion,
22812269 .rhs = undefined,
22822270 }
22832271 );
......@@ -2290,8 +2278,8 @@ pub const Parser = struct {
22902278 State.PrefixOpExpression => |opt_ctx| {
22912279 const token = self.getNextToken();
22922280 if (tokenIdToPrefixOp(token.id)) |prefix_id| {
2293 var node = try self.createToCtxNode(arena, opt_ctx, ast.NodePrefixOp,
2294 ast.NodePrefixOp {
2281 var node = try self.createToCtxNode(arena, opt_ctx, ast.Node.PrefixOp,
2282 ast.Node.PrefixOp {
22952283 .base = undefined,
22962284 .op_token = token,
22972285 .op = prefix_id,
......@@ -2301,8 +2289,8 @@ pub const Parser = struct {
23012289
23022290 // Treat '**' token as two derefs
23032291 if (token.id == Token.Id.AsteriskAsterisk) {
2304 const child = try self.createNode(arena, ast.NodePrefixOp,
2305 ast.NodePrefixOp {
2292 const child = try self.createNode(arena, ast.Node.PrefixOp,
2293 ast.Node.PrefixOp {
23062294 .base = undefined,
23072295 .op_token = token,
23082296 .op = prefix_id,
......@@ -2314,7 +2302,7 @@ pub const Parser = struct {
23142302 }
23152303
23162304 stack.append(State { .TypeExprBegin = OptionalCtx { .Required = &node.rhs } }) catch unreachable;
2317 if (node.op == ast.NodePrefixOp.PrefixOp.AddrOf) {
2305 if (node.op == ast.Node.PrefixOp.Op.AddrOf) {
23182306 try stack.append(State { .AddrOfModifiers = &node.op.AddrOf });
23192307 }
23202308 continue;
......@@ -2327,8 +2315,8 @@ pub const Parser = struct {
23272315
23282316 State.SuffixOpExpressionBegin => |opt_ctx| {
23292317 if (self.eatToken(Token.Id.Keyword_async)) |async_token| {
2330 const async_node = try self.createNode(arena, ast.NodeAsyncAttribute,
2331 ast.NodeAsyncAttribute {
2318 const async_node = try self.createNode(arena, ast.Node.AsyncAttribute,
2319 ast.Node.AsyncAttribute {
23322320 .base = undefined,
23332321 .async_token = async_token,
23342322 .allocator_type = null,
......@@ -2358,12 +2346,12 @@ pub const Parser = struct {
23582346 const token = self.getNextToken();
23592347 switch (token.id) {
23602348 Token.Id.LParen => {
2361 const node = try self.createToCtxNode(arena, opt_ctx, ast.NodeSuffixOp,
2362 ast.NodeSuffixOp {
2349 const node = try self.createToCtxNode(arena, opt_ctx, ast.Node.SuffixOp,
2350 ast.Node.SuffixOp {
23632351 .base = undefined,
23642352 .lhs = lhs,
2365 .op = ast.NodeSuffixOp.SuffixOp {
2366 .Call = ast.NodeSuffixOp.CallInfo {
2353 .op = ast.Node.SuffixOp.Op {
2354 .Call = ast.Node.SuffixOp.CallInfo {
23672355 .params = ArrayList(&ast.Node).init(arena),
23682356 .async_attr = null,
23692357 }
......@@ -2382,11 +2370,11 @@ pub const Parser = struct {
23822370 continue;
23832371 },
23842372 Token.Id.LBracket => {
2385 const node = try self.createToCtxNode(arena, opt_ctx, ast.NodeSuffixOp,
2386 ast.NodeSuffixOp {
2373 const node = try self.createToCtxNode(arena, opt_ctx, ast.Node.SuffixOp,
2374 ast.Node.SuffixOp {
23872375 .base = undefined,
23882376 .lhs = lhs,
2389 .op = ast.NodeSuffixOp.SuffixOp {
2377 .op = ast.Node.SuffixOp.Op {
23902378 .ArrayAccess = undefined,
23912379 },
23922380 .rtoken = undefined
......@@ -2398,12 +2386,12 @@ pub const Parser = struct {
23982386 continue;
23992387 },
24002388 Token.Id.Period => {
2401 const node = try self.createToCtxNode(arena, opt_ctx, ast.NodeInfixOp,
2402 ast.NodeInfixOp {
2389 const node = try self.createToCtxNode(arena, opt_ctx, ast.Node.InfixOp,
2390 ast.Node.InfixOp {
24032391 .base = undefined,
24042392 .lhs = lhs,
24052393 .op_token = token,
2406 .op = ast.NodeInfixOp.InfixOp.Period,
2394 .op = ast.Node.InfixOp.Op.Period,
24072395 .rhs = undefined,
24082396 }
24092397 );
......@@ -2422,39 +2410,39 @@ pub const Parser = struct {
24222410 const token = self.getNextToken();
24232411 switch (token.id) {
24242412 Token.Id.IntegerLiteral => {
2425 _ = try self.createToCtxLiteral(arena, opt_ctx, ast.NodeStringLiteral, token);
2413 _ = try self.createToCtxLiteral(arena, opt_ctx, ast.Node.StringLiteral, token);
24262414 continue;
24272415 },
24282416 Token.Id.FloatLiteral => {
2429 _ = try self.createToCtxLiteral(arena, opt_ctx, ast.NodeFloatLiteral, token);
2417 _ = try self.createToCtxLiteral(arena, opt_ctx, ast.Node.FloatLiteral, token);
24302418 continue;
24312419 },
24322420 Token.Id.CharLiteral => {
2433 _ = try self.createToCtxLiteral(arena, opt_ctx, ast.NodeCharLiteral, token);
2421 _ = try self.createToCtxLiteral(arena, opt_ctx, ast.Node.CharLiteral, token);
24342422 continue;
24352423 },
24362424 Token.Id.Keyword_undefined => {
2437 _ = try self.createToCtxLiteral(arena, opt_ctx, ast.NodeUndefinedLiteral, token);
2425 _ = try self.createToCtxLiteral(arena, opt_ctx, ast.Node.UndefinedLiteral, token);
24382426 continue;
24392427 },
24402428 Token.Id.Keyword_true, Token.Id.Keyword_false => {
2441 _ = try self.createToCtxLiteral(arena, opt_ctx, ast.NodeBoolLiteral, token);
2429 _ = try self.createToCtxLiteral(arena, opt_ctx, ast.Node.BoolLiteral, token);
24422430 continue;
24432431 },
24442432 Token.Id.Keyword_null => {
2445 _ = try self.createToCtxLiteral(arena, opt_ctx, ast.NodeNullLiteral, token);
2433 _ = try self.createToCtxLiteral(arena, opt_ctx, ast.Node.NullLiteral, token);
24462434 continue;
24472435 },
24482436 Token.Id.Keyword_this => {
2449 _ = try self.createToCtxLiteral(arena, opt_ctx, ast.NodeThisLiteral, token);
2437 _ = try self.createToCtxLiteral(arena, opt_ctx, ast.Node.ThisLiteral, token);
24502438 continue;
24512439 },
24522440 Token.Id.Keyword_var => {
2453 _ = try self.createToCtxLiteral(arena, opt_ctx, ast.NodeVarType, token);
2441 _ = try self.createToCtxLiteral(arena, opt_ctx, ast.Node.VarType, token);
24542442 continue;
24552443 },
24562444 Token.Id.Keyword_unreachable => {
2457 _ = try self.createToCtxLiteral(arena, opt_ctx, ast.NodeUnreachable, token);
2445 _ = try self.createToCtxLiteral(arena, opt_ctx, ast.Node.Unreachable, token);
24582446 continue;
24592447 },
24602448 Token.Id.StringLiteral, Token.Id.MultilineStringLiteralLine => {
......@@ -2462,8 +2450,8 @@ pub const Parser = struct {
24622450 continue;
24632451 },
24642452 Token.Id.LParen => {
2465 const node = try self.createToCtxNode(arena, opt_ctx, ast.NodeGroupedExpression,
2466 ast.NodeGroupedExpression {
2453 const node = try self.createToCtxNode(arena, opt_ctx, ast.Node.GroupedExpression,
2454 ast.Node.GroupedExpression {
24672455 .base = undefined,
24682456 .lparen = token,
24692457 .expr = undefined,
......@@ -2480,8 +2468,8 @@ pub const Parser = struct {
24802468 continue;
24812469 },
24822470 Token.Id.Builtin => {
2483 const node = try self.createToCtxNode(arena, opt_ctx, ast.NodeBuiltinCall,
2484 ast.NodeBuiltinCall {
2471 const node = try self.createToCtxNode(arena, opt_ctx, ast.Node.BuiltinCall,
2472 ast.Node.BuiltinCall {
24852473 .base = undefined,
24862474 .builtin_token = token,
24872475 .params = ArrayList(&ast.Node).init(arena),
......@@ -2499,8 +2487,8 @@ pub const Parser = struct {
24992487 continue;
25002488 },
25012489 Token.Id.LBracket => {
2502 const node = try self.createToCtxNode(arena, opt_ctx, ast.NodePrefixOp,
2503 ast.NodePrefixOp {
2490 const node = try self.createToCtxNode(arena, opt_ctx, ast.Node.PrefixOp,
2491 ast.Node.PrefixOp {
25042492 .base = undefined,
25052493 .op_token = token,
25062494 .op = undefined,
......@@ -2524,7 +2512,7 @@ pub const Parser = struct {
25242512 .ContainerKind = ContainerKindCtx {
25252513 .opt_ctx = opt_ctx,
25262514 .ltoken = token,
2527 .layout = ast.NodeContainerDecl.Layout.Packed,
2515 .layout = ast.Node.ContainerDecl.Layout.Packed,
25282516 },
25292517 }) catch unreachable;
25302518 continue;
......@@ -2534,6 +2522,7 @@ pub const Parser = struct {
25342522 .ExternType = ExternTypeCtx {
25352523 .opt_ctx = opt_ctx,
25362524 .extern_token = token,
2525 .comments = null,
25372526 },
25382527 }) catch unreachable;
25392528 continue;
......@@ -2544,7 +2533,7 @@ pub const Parser = struct {
25442533 .ContainerKind = ContainerKindCtx {
25452534 .opt_ctx = opt_ctx,
25462535 .ltoken = token,
2547 .layout = ast.NodeContainerDecl.Layout.Auto,
2536 .layout = ast.Node.ContainerDecl.Layout.Auto,
25482537 },
25492538 }) catch unreachable;
25502539 continue;
......@@ -2559,9 +2548,10 @@ pub const Parser = struct {
25592548 continue;
25602549 },
25612550 Token.Id.Keyword_fn => {
2562 const fn_proto = try self.createToCtxNode(arena, opt_ctx, ast.NodeFnProto,
2563 ast.NodeFnProto {
2551 const fn_proto = try self.createToCtxNode(arena, opt_ctx, ast.Node.FnProto,
2552 ast.Node.FnProto {
25642553 .base = undefined,
2554 .comments = null,
25652555 .visib_token = null,
25662556 .name_token = null,
25672557 .fn_token = token,
......@@ -2580,9 +2570,10 @@ pub const Parser = struct {
25802570 continue;
25812571 },
25822572 Token.Id.Keyword_nakedcc, Token.Id.Keyword_stdcallcc => {
2583 const fn_proto = try self.createToCtxNode(arena, opt_ctx, ast.NodeFnProto,
2584 ast.NodeFnProto {
2573 const fn_proto = try self.createToCtxNode(arena, opt_ctx, ast.Node.FnProto,
2574 ast.Node.FnProto {
25852575 .base = undefined,
2576 .comments = null,
25862577 .visib_token = null,
25872578 .name_token = null,
25882579 .fn_token = undefined,
......@@ -2607,15 +2598,15 @@ pub const Parser = struct {
26072598 continue;
26082599 },
26092600 Token.Id.Keyword_asm => {
2610 const node = try self.createToCtxNode(arena, opt_ctx, ast.NodeAsm,
2611 ast.NodeAsm {
2601 const node = try self.createToCtxNode(arena, opt_ctx, ast.Node.Asm,
2602 ast.Node.Asm {
26122603 .base = undefined,
26132604 .asm_token = token,
26142605 .volatile_token = null,
26152606 .template = undefined,
2616 //.tokens = ArrayList(ast.NodeAsm.AsmToken).init(arena),
2617 .outputs = ArrayList(&ast.NodeAsmOutput).init(arena),
2618 .inputs = ArrayList(&ast.NodeAsmInput).init(arena),
2607 //.tokens = ArrayList(ast.Node.Asm.AsmToken).init(arena),
2608 .outputs = ArrayList(&ast.Node.AsmOutput).init(arena),
2609 .inputs = ArrayList(&ast.Node.AsmInput).init(arena),
26192610 .cloppers = ArrayList(&ast.Node).init(arena),
26202611 .rparen = undefined,
26212612 }
......@@ -2666,12 +2657,12 @@ pub const Parser = struct {
26662657
26672658 State.ErrorTypeOrSetDecl => |ctx| {
26682659 if (self.eatToken(Token.Id.LBrace) == null) {
2669 _ = try self.createToCtxLiteral(arena, ctx.opt_ctx, ast.NodeErrorType, ctx.error_token);
2660 _ = try self.createToCtxLiteral(arena, ctx.opt_ctx, ast.Node.ErrorType, ctx.error_token);
26702661 continue;
26712662 }
26722663
2673 const node = try self.createToCtxNode(arena, ctx.opt_ctx, ast.NodeErrorSetDecl,
2674 ast.NodeErrorSetDecl {
2664 const node = try self.createToCtxNode(arena, ctx.opt_ctx, ast.Node.ErrorSetDecl,
2665 ast.Node.ErrorSetDecl {
26752666 .base = undefined,
26762667 .error_token = ctx.error_token,
26772668 .decls = ArrayList(&ast.Node).init(arena),
......@@ -2702,7 +2693,7 @@ pub const Parser = struct {
27022693 },
27032694 State.Identifier => |opt_ctx| {
27042695 if (self.eatToken(Token.Id.Identifier)) |ident_token| {
2705 _ = try self.createToCtxLiteral(arena, opt_ctx, ast.NodeIdentifier, ident_token);
2696 _ = try self.createToCtxLiteral(arena, opt_ctx, ast.Node.Identifier, ident_token);
27062697 continue;
27072698 }
27082699
......@@ -2750,6 +2741,33 @@ pub const Parser = struct {
27502741 }
27512742 }
27522743
2744 fn eatComments(self: &Parser, arena: &mem.Allocator) !?&ast.Node.LineComment {
2745 var result: ?&ast.Node.LineComment = null;
2746 while (true) {
2747 if (self.eatToken(Token.Id.LineComment)) |line_comment| {
2748 const node = blk: {
2749 if (result) |comment_node| {
2750 break :blk comment_node;
2751 } else {
2752 const comment_node = try arena.create(ast.Node.LineComment);
2753 *comment_node = ast.Node.LineComment {
2754 .base = ast.Node {
2755 .id = ast.Node.Id.LineComment,
2756 },
2757 .lines = ArrayList(Token).init(arena),
2758 };
2759 result = comment_node;
2760 break :blk comment_node;
2761 }
2762 };
2763 try node.lines.append(line_comment);
2764 continue;
2765 }
2766 break;
2767 }
2768 return result;
2769 }
2770
27532771 fn requireSemiColon(node: &const ast.Node) bool {
27542772 var n = node;
27552773 while (true) {
......@@ -2770,7 +2788,7 @@ pub const Parser = struct {
27702788 ast.Node.Id.LineComment,
27712789 ast.Node.Id.TestDecl => return false,
27722790 ast.Node.Id.While => {
2773 const while_node = @fieldParentPtr(ast.NodeWhile, "base", n);
2791 const while_node = @fieldParentPtr(ast.Node.While, "base", n);
27742792 if (while_node.@"else") |@"else"| {
27752793 n = @"else".base;
27762794 continue;
......@@ -2779,7 +2797,7 @@ pub const Parser = struct {
27792797 return while_node.body.id != ast.Node.Id.Block;
27802798 },
27812799 ast.Node.Id.For => {
2782 const for_node = @fieldParentPtr(ast.NodeFor, "base", n);
2800 const for_node = @fieldParentPtr(ast.Node.For, "base", n);
27832801 if (for_node.@"else") |@"else"| {
27842802 n = @"else".base;
27852803 continue;
......@@ -2788,7 +2806,7 @@ pub const Parser = struct {
27882806 return for_node.body.id != ast.Node.Id.Block;
27892807 },
27902808 ast.Node.Id.If => {
2791 const if_node = @fieldParentPtr(ast.NodeIf, "base", n);
2809 const if_node = @fieldParentPtr(ast.Node.If, "base", n);
27922810 if (if_node.@"else") |@"else"| {
27932811 n = @"else".base;
27942812 continue;
......@@ -2797,20 +2815,20 @@ pub const Parser = struct {
27972815 return if_node.body.id != ast.Node.Id.Block;
27982816 },
27992817 ast.Node.Id.Else => {
2800 const else_node = @fieldParentPtr(ast.NodeElse, "base", n);
2818 const else_node = @fieldParentPtr(ast.Node.Else, "base", n);
28012819 n = else_node.body;
28022820 continue;
28032821 },
28042822 ast.Node.Id.Defer => {
2805 const defer_node = @fieldParentPtr(ast.NodeDefer, "base", n);
2823 const defer_node = @fieldParentPtr(ast.Node.Defer, "base", n);
28062824 return defer_node.expr.id != ast.Node.Id.Block;
28072825 },
28082826 ast.Node.Id.Comptime => {
2809 const comptime_node = @fieldParentPtr(ast.NodeComptime, "base", n);
2827 const comptime_node = @fieldParentPtr(ast.Node.Comptime, "base", n);
28102828 return comptime_node.expr.id != ast.Node.Id.Block;
28112829 },
28122830 ast.Node.Id.Suspend => {
2813 const suspend_node = @fieldParentPtr(ast.NodeSuspend, "base", n);
2831 const suspend_node = @fieldParentPtr(ast.Node.Suspend, "base", n);
28142832 if (suspend_node.body) |body| {
28152833 return body.id != ast.Node.Id.Block;
28162834 }
......@@ -2825,11 +2843,11 @@ pub const Parser = struct {
28252843 fn parseStringLiteral(self: &Parser, arena: &mem.Allocator, token: &const Token) !?&ast.Node {
28262844 switch (token.id) {
28272845 Token.Id.StringLiteral => {
2828 return &(try self.createLiteral(arena, ast.NodeStringLiteral, token)).base;
2846 return &(try self.createLiteral(arena, ast.Node.StringLiteral, token)).base;
28292847 },
28302848 Token.Id.MultilineStringLiteralLine => {
2831 const node = try self.createNode(arena, ast.NodeMultilineStringLiteral,
2832 ast.NodeMultilineStringLiteral {
2849 const node = try self.createNode(arena, ast.Node.MultilineStringLiteral,
2850 ast.Node.MultilineStringLiteral {
28332851 .base = undefined,
28342852 .tokens = ArrayList(Token).init(arena),
28352853 }
......@@ -2856,8 +2874,8 @@ pub const Parser = struct {
28562874 fn parseBlockExpr(self: &Parser, stack: &ArrayList(State), arena: &mem.Allocator, ctx: &const OptionalCtx, token: &const Token) !bool {
28572875 switch (token.id) {
28582876 Token.Id.Keyword_suspend => {
2859 const node = try self.createToCtxNode(arena, ctx, ast.NodeSuspend,
2860 ast.NodeSuspend {
2877 const node = try self.createToCtxNode(arena, ctx, ast.Node.Suspend,
2878 ast.Node.Suspend {
28612879 .base = undefined,
28622880 .suspend_token = *token,
28632881 .payload = null,
......@@ -2870,8 +2888,8 @@ pub const Parser = struct {
28702888 return true;
28712889 },
28722890 Token.Id.Keyword_if => {
2873 const node = try self.createToCtxNode(arena, ctx, ast.NodeIf,
2874 ast.NodeIf {
2891 const node = try self.createToCtxNode(arena, ctx, ast.Node.If,
2892 ast.Node.If {
28752893 .base = undefined,
28762894 .if_token = *token,
28772895 .condition = undefined,
......@@ -2912,18 +2930,18 @@ pub const Parser = struct {
29122930 return true;
29132931 },
29142932 Token.Id.Keyword_switch => {
2915 const node = try self.createToCtxNode(arena, ctx, ast.NodeSwitch,
2916 ast.NodeSwitch {
2933 const node = try self.createToCtxNode(arena, ctx, ast.Node.Switch,
2934 ast.Node.Switch {
29172935 .base = undefined,
29182936 .switch_token = *token,
29192937 .expr = undefined,
2920 .cases = ArrayList(&ast.NodeSwitchCase).init(arena),
2938 .cases = ArrayList(&ast.Node.SwitchCase).init(arena),
29212939 .rbrace = undefined,
29222940 }
29232941 );
29242942
29252943 stack.append(State {
2926 .SwitchCaseOrEnd = ListSave(&ast.NodeSwitchCase) {
2944 .SwitchCaseOrEnd = ListSave(&ast.Node.SwitchCase) {
29272945 .list = &node.cases,
29282946 .ptr = &node.rbrace,
29292947 },
......@@ -2935,8 +2953,8 @@ pub const Parser = struct {
29352953 return true;
29362954 },
29372955 Token.Id.Keyword_comptime => {
2938 const node = try self.createToCtxNode(arena, ctx, ast.NodeComptime,
2939 ast.NodeComptime {
2956 const node = try self.createToCtxNode(arena, ctx, ast.Node.Comptime,
2957 ast.Node.Comptime {
29402958 .base = undefined,
29412959 .comptime_token = *token,
29422960 .expr = undefined,
......@@ -2946,8 +2964,8 @@ pub const Parser = struct {
29462964 return true;
29472965 },
29482966 Token.Id.LBrace => {
2949 const block = try self.createToCtxNode(arena, ctx, ast.NodeBlock,
2950 ast.NodeBlock {
2967 const block = try self.createToCtxNode(arena, ctx, ast.Node.Block,
2968 ast.Node.Block {
29512969 .base = undefined,
29522970 .label = null,
29532971 .lbrace = *token,
......@@ -2978,88 +2996,88 @@ pub const Parser = struct {
29782996 }
29792997 }
29802998
2981 fn tokenIdToAssignment(id: &const Token.Id) ?ast.NodeInfixOp.InfixOp {
2999 fn tokenIdToAssignment(id: &const Token.Id) ?ast.Node.InfixOp.Op {
29823000 // TODO: We have to cast all cases because of this:
29833001 // error: expected type '?InfixOp', found '?@TagType(InfixOp)'
29843002 return switch (*id) {
2985 Token.Id.AmpersandEqual => ast.NodeInfixOp.InfixOp { .AssignBitAnd = void{} },
2986 Token.Id.AngleBracketAngleBracketLeftEqual => ast.NodeInfixOp.InfixOp { .AssignBitShiftLeft = void{} },
2987 Token.Id.AngleBracketAngleBracketRightEqual => ast.NodeInfixOp.InfixOp { .AssignBitShiftRight = void{} },
2988 Token.Id.AsteriskEqual => ast.NodeInfixOp.InfixOp { .AssignTimes = void{} },
2989 Token.Id.AsteriskPercentEqual => ast.NodeInfixOp.InfixOp { .AssignTimesWarp = void{} },
2990 Token.Id.CaretEqual => ast.NodeInfixOp.InfixOp { .AssignBitXor = void{} },
2991 Token.Id.Equal => ast.NodeInfixOp.InfixOp { .Assign = void{} },
2992 Token.Id.MinusEqual => ast.NodeInfixOp.InfixOp { .AssignMinus = void{} },
2993 Token.Id.MinusPercentEqual => ast.NodeInfixOp.InfixOp { .AssignMinusWrap = void{} },
2994 Token.Id.PercentEqual => ast.NodeInfixOp.InfixOp { .AssignMod = void{} },
2995 Token.Id.PipeEqual => ast.NodeInfixOp.InfixOp { .AssignBitOr = void{} },
2996 Token.Id.PlusEqual => ast.NodeInfixOp.InfixOp { .AssignPlus = void{} },
2997 Token.Id.PlusPercentEqual => ast.NodeInfixOp.InfixOp { .AssignPlusWrap = void{} },
2998 Token.Id.SlashEqual => ast.NodeInfixOp.InfixOp { .AssignDiv = void{} },
3003 Token.Id.AmpersandEqual => ast.Node.InfixOp.Op { .AssignBitAnd = void{} },
3004 Token.Id.AngleBracketAngleBracketLeftEqual => ast.Node.InfixOp.Op { .AssignBitShiftLeft = void{} },
3005 Token.Id.AngleBracketAngleBracketRightEqual => ast.Node.InfixOp.Op { .AssignBitShiftRight = void{} },
3006 Token.Id.AsteriskEqual => ast.Node.InfixOp.Op { .AssignTimes = void{} },
3007 Token.Id.AsteriskPercentEqual => ast.Node.InfixOp.Op { .AssignTimesWarp = void{} },
3008 Token.Id.CaretEqual => ast.Node.InfixOp.Op { .AssignBitXor = void{} },
3009 Token.Id.Equal => ast.Node.InfixOp.Op { .Assign = void{} },
3010 Token.Id.MinusEqual => ast.Node.InfixOp.Op { .AssignMinus = void{} },
3011 Token.Id.MinusPercentEqual => ast.Node.InfixOp.Op { .AssignMinusWrap = void{} },
3012 Token.Id.PercentEqual => ast.Node.InfixOp.Op { .AssignMod = void{} },
3013 Token.Id.PipeEqual => ast.Node.InfixOp.Op { .AssignBitOr = void{} },
3014 Token.Id.PlusEqual => ast.Node.InfixOp.Op { .AssignPlus = void{} },
3015 Token.Id.PlusPercentEqual => ast.Node.InfixOp.Op { .AssignPlusWrap = void{} },
3016 Token.Id.SlashEqual => ast.Node.InfixOp.Op { .AssignDiv = void{} },
29993017 else => null,
30003018 };
30013019 }
30023020
3003 fn tokenIdToUnwrapExpr(id: @TagType(Token.Id)) ?ast.NodeInfixOp.InfixOp {
3021 fn tokenIdToUnwrapExpr(id: @TagType(Token.Id)) ?ast.Node.InfixOp.Op {
30043022 return switch (id) {
3005 Token.Id.Keyword_catch => ast.NodeInfixOp.InfixOp { .Catch = null },
3006 Token.Id.QuestionMarkQuestionMark => ast.NodeInfixOp.InfixOp { .UnwrapMaybe = void{} },
3023 Token.Id.Keyword_catch => ast.Node.InfixOp.Op { .Catch = null },
3024 Token.Id.QuestionMarkQuestionMark => ast.Node.InfixOp.Op { .UnwrapMaybe = void{} },
30073025 else => null,
30083026 };
30093027 }
30103028
3011 fn tokenIdToComparison(id: @TagType(Token.Id)) ?ast.NodeInfixOp.InfixOp {
3029 fn tokenIdToComparison(id: @TagType(Token.Id)) ?ast.Node.InfixOp.Op {
30123030 return switch (id) {
3013 Token.Id.BangEqual => ast.NodeInfixOp.InfixOp { .BangEqual = void{} },
3014 Token.Id.EqualEqual => ast.NodeInfixOp.InfixOp { .EqualEqual = void{} },
3015 Token.Id.AngleBracketLeft => ast.NodeInfixOp.InfixOp { .LessThan = void{} },
3016 Token.Id.AngleBracketLeftEqual => ast.NodeInfixOp.InfixOp { .LessOrEqual = void{} },
3017 Token.Id.AngleBracketRight => ast.NodeInfixOp.InfixOp { .GreaterThan = void{} },
3018 Token.Id.AngleBracketRightEqual => ast.NodeInfixOp.InfixOp { .GreaterOrEqual = void{} },
3031 Token.Id.BangEqual => ast.Node.InfixOp.Op { .BangEqual = void{} },
3032 Token.Id.EqualEqual => ast.Node.InfixOp.Op { .EqualEqual = void{} },
3033 Token.Id.AngleBracketLeft => ast.Node.InfixOp.Op { .LessThan = void{} },
3034 Token.Id.AngleBracketLeftEqual => ast.Node.InfixOp.Op { .LessOrEqual = void{} },
3035 Token.Id.AngleBracketRight => ast.Node.InfixOp.Op { .GreaterThan = void{} },
3036 Token.Id.AngleBracketRightEqual => ast.Node.InfixOp.Op { .GreaterOrEqual = void{} },
30193037 else => null,
30203038 };
30213039 }
30223040
3023 fn tokenIdToBitShift(id: @TagType(Token.Id)) ?ast.NodeInfixOp.InfixOp {
3041 fn tokenIdToBitShift(id: @TagType(Token.Id)) ?ast.Node.InfixOp.Op {
30243042 return switch (id) {
3025 Token.Id.AngleBracketAngleBracketLeft => ast.NodeInfixOp.InfixOp { .BitShiftLeft = void{} },
3026 Token.Id.AngleBracketAngleBracketRight => ast.NodeInfixOp.InfixOp { .BitShiftRight = void{} },
3043 Token.Id.AngleBracketAngleBracketLeft => ast.Node.InfixOp.Op { .BitShiftLeft = void{} },
3044 Token.Id.AngleBracketAngleBracketRight => ast.Node.InfixOp.Op { .BitShiftRight = void{} },
30273045 else => null,
30283046 };
30293047 }
30303048
3031 fn tokenIdToAddition(id: @TagType(Token.Id)) ?ast.NodeInfixOp.InfixOp {
3049 fn tokenIdToAddition(id: @TagType(Token.Id)) ?ast.Node.InfixOp.Op {
30323050 return switch (id) {
3033 Token.Id.Minus => ast.NodeInfixOp.InfixOp { .Sub = void{} },
3034 Token.Id.MinusPercent => ast.NodeInfixOp.InfixOp { .SubWrap = void{} },
3035 Token.Id.Plus => ast.NodeInfixOp.InfixOp { .Add = void{} },
3036 Token.Id.PlusPercent => ast.NodeInfixOp.InfixOp { .AddWrap = void{} },
3037 Token.Id.PlusPlus => ast.NodeInfixOp.InfixOp { .ArrayCat = void{} },
3051 Token.Id.Minus => ast.Node.InfixOp.Op { .Sub = void{} },
3052 Token.Id.MinusPercent => ast.Node.InfixOp.Op { .SubWrap = void{} },
3053 Token.Id.Plus => ast.Node.InfixOp.Op { .Add = void{} },
3054 Token.Id.PlusPercent => ast.Node.InfixOp.Op { .AddWrap = void{} },
3055 Token.Id.PlusPlus => ast.Node.InfixOp.Op { .ArrayCat = void{} },
30383056 else => null,
30393057 };
30403058 }
30413059
3042 fn tokenIdToMultiply(id: @TagType(Token.Id)) ?ast.NodeInfixOp.InfixOp {
3060 fn tokenIdToMultiply(id: @TagType(Token.Id)) ?ast.Node.InfixOp.Op {
30433061 return switch (id) {
3044 Token.Id.Slash => ast.NodeInfixOp.InfixOp { .Div = void{} },
3045 Token.Id.Asterisk => ast.NodeInfixOp.InfixOp { .Mult = void{} },
3046 Token.Id.AsteriskAsterisk => ast.NodeInfixOp.InfixOp { .ArrayMult = void{} },
3047 Token.Id.AsteriskPercent => ast.NodeInfixOp.InfixOp { .MultWrap = void{} },
3048 Token.Id.Percent => ast.NodeInfixOp.InfixOp { .Mod = void{} },
3049 Token.Id.PipePipe => ast.NodeInfixOp.InfixOp { .MergeErrorSets = void{} },
3062 Token.Id.Slash => ast.Node.InfixOp.Op { .Div = void{} },
3063 Token.Id.Asterisk => ast.Node.InfixOp.Op { .Mult = void{} },
3064 Token.Id.AsteriskAsterisk => ast.Node.InfixOp.Op { .ArrayMult = void{} },
3065 Token.Id.AsteriskPercent => ast.Node.InfixOp.Op { .MultWrap = void{} },
3066 Token.Id.Percent => ast.Node.InfixOp.Op { .Mod = void{} },
3067 Token.Id.PipePipe => ast.Node.InfixOp.Op { .MergeErrorSets = void{} },
30503068 else => null,
30513069 };
30523070 }
30533071
3054 fn tokenIdToPrefixOp(id: @TagType(Token.Id)) ?ast.NodePrefixOp.PrefixOp {
3072 fn tokenIdToPrefixOp(id: @TagType(Token.Id)) ?ast.Node.PrefixOp.Op {
30553073 return switch (id) {
3056 Token.Id.Bang => ast.NodePrefixOp.PrefixOp { .BoolNot = void{} },
3057 Token.Id.Tilde => ast.NodePrefixOp.PrefixOp { .BitNot = void{} },
3058 Token.Id.Minus => ast.NodePrefixOp.PrefixOp { .Negation = void{} },
3059 Token.Id.MinusPercent => ast.NodePrefixOp.PrefixOp { .NegationWrap = void{} },
3060 Token.Id.Asterisk, Token.Id.AsteriskAsterisk => ast.NodePrefixOp.PrefixOp { .Deref = void{} },
3061 Token.Id.Ampersand => ast.NodePrefixOp.PrefixOp {
3062 .AddrOf = ast.NodePrefixOp.AddrOfInfo {
3074 Token.Id.Bang => ast.Node.PrefixOp.Op { .BoolNot = void{} },
3075 Token.Id.Tilde => ast.Node.PrefixOp.Op { .BitNot = void{} },
3076 Token.Id.Minus => ast.Node.PrefixOp.Op { .Negation = void{} },
3077 Token.Id.MinusPercent => ast.Node.PrefixOp.Op { .NegationWrap = void{} },
3078 Token.Id.Asterisk, Token.Id.AsteriskAsterisk => ast.Node.PrefixOp.Op { .Deref = void{} },
3079 Token.Id.Ampersand => ast.Node.PrefixOp.Op {
3080 .AddrOf = ast.Node.PrefixOp.AddrOfInfo {
30633081 .align_expr = null,
30643082 .bit_offset_start_token = null,
30653083 .bit_offset_end_token = null,
......@@ -3067,10 +3085,10 @@ pub const Parser = struct {
30673085 .volatile_token = null,
30683086 },
30693087 },
3070 Token.Id.QuestionMark => ast.NodePrefixOp.PrefixOp { .MaybeType = void{} },
3071 Token.Id.QuestionMarkQuestionMark => ast.NodePrefixOp.PrefixOp { .UnwrapMaybe = void{} },
3072 Token.Id.Keyword_await => ast.NodePrefixOp.PrefixOp { .Await = void{} },
3073 Token.Id.Keyword_try => ast.NodePrefixOp.PrefixOp { .Try = void{ } },
3088 Token.Id.QuestionMark => ast.Node.PrefixOp.Op { .MaybeType = void{} },
3089 Token.Id.QuestionMarkQuestionMark => ast.Node.PrefixOp.Op { .UnwrapMaybe = void{} },
3090 Token.Id.Keyword_await => ast.Node.PrefixOp.Op { .Await = void{} },
3091 Token.Id.Keyword_try => ast.Node.PrefixOp.Op { .Try = void{ } },
30743092 else => null,
30753093 };
30763094 }
......@@ -3080,11 +3098,7 @@ pub const Parser = struct {
30803098 *node = *init_to;
30813099 node.base = blk: {
30823100 const id = ast.Node.typeToId(T);
3083 if (self.pending_line_comment_node) |comment_node| {
3084 self.pending_line_comment_node = null;
3085 break :blk ast.Node {.id = id, .comment = comment_node};
3086 }
3087 break :blk ast.Node {.id = id, .comment = null };
3101 break :blk ast.Node {.id = id};
30883102 };
30893103
30903104 return node;
......@@ -3183,7 +3197,7 @@ pub const Parser = struct {
31833197 indent: usize,
31843198 };
31853199
3186 pub fn renderAst(self: &Parser, stream: var, root_node: &ast.NodeRoot) !void {
3200 pub fn renderAst(self: &Parser, stream: var, root_node: &ast.Node.Root) !void {
31873201 var stack = self.initUtilityArrayList(RenderAstFrame);
31883202 defer self.deinitUtilityArrayList(stack);
31893203
......@@ -3215,14 +3229,14 @@ pub const Parser = struct {
32153229 ParamDecl: &ast.Node,
32163230 Text: []const u8,
32173231 Expression: &ast.Node,
3218 VarDecl: &ast.NodeVarDecl,
3232 VarDecl: &ast.Node.VarDecl,
32193233 Statement: &ast.Node,
3220 FieldInitializer: &ast.NodeFieldInitializer,
3234 FieldInitializer: &ast.Node.FieldInitializer,
32213235 PrintIndent,
32223236 Indent: usize,
32233237 };
32243238
3225 pub fn renderSource(self: &Parser, stream: var, root_node: &ast.NodeRoot) !void {
3239 pub fn renderSource(self: &Parser, stream: var, root_node: &ast.Node.Root) !void {
32263240 var stack = self.initUtilityArrayList(RenderState);
32273241 defer self.deinitUtilityArrayList(stack);
32283242
......@@ -3256,7 +3270,8 @@ pub const Parser = struct {
32563270 RenderState.TopLevelDecl => |decl| {
32573271 switch (decl.id) {
32583272 ast.Node.Id.FnProto => {
3259 const fn_proto = @fieldParentPtr(ast.NodeFnProto, "base", decl);
3273 const fn_proto = @fieldParentPtr(ast.Node.FnProto, "base", decl);
3274 try self.renderComments(stream, fn_proto, indent);
32603275
32613276 if (fn_proto.body_node) |body_node| {
32623277 stack.append(RenderState { .Expression = body_node}) catch unreachable;
......@@ -3268,7 +3283,7 @@ pub const Parser = struct {
32683283 try stack.append(RenderState { .Expression = decl });
32693284 },
32703285 ast.Node.Id.Use => {
3271 const use_decl = @fieldParentPtr(ast.NodeUse, "base", decl);
3286 const use_decl = @fieldParentPtr(ast.Node.Use, "base", decl);
32723287 if (use_decl.visib_token) |visib_token| {
32733288 try stream.print("{} ", self.tokenizer.getTokenSlice(visib_token));
32743289 }
......@@ -3277,18 +3292,19 @@ pub const Parser = struct {
32773292 try stack.append(RenderState { .Expression = use_decl.expr });
32783293 },
32793294 ast.Node.Id.VarDecl => {
3280 const var_decl = @fieldParentPtr(ast.NodeVarDecl, "base", decl);
3295 const var_decl = @fieldParentPtr(ast.Node.VarDecl, "base", decl);
32813296 try stack.append(RenderState { .VarDecl = var_decl});
32823297 },
32833298 ast.Node.Id.TestDecl => {
3284 const test_decl = @fieldParentPtr(ast.NodeTestDecl, "base", decl);
3299 const test_decl = @fieldParentPtr(ast.Node.TestDecl, "base", decl);
3300 try self.renderComments(stream, test_decl, indent);
32853301 try stream.print("test ");
32863302 try stack.append(RenderState { .Expression = test_decl.body_node });
32873303 try stack.append(RenderState { .Text = " " });
32883304 try stack.append(RenderState { .Expression = test_decl.name });
32893305 },
32903306 ast.Node.Id.StructField => {
3291 const field = @fieldParentPtr(ast.NodeStructField, "base", decl);
3307 const field = @fieldParentPtr(ast.Node.StructField, "base", decl);
32923308 if (field.visib_token) |visib_token| {
32933309 try stream.print("{} ", self.tokenizer.getTokenSlice(visib_token));
32943310 }
......@@ -3296,7 +3312,7 @@ pub const Parser = struct {
32963312 try stack.append(RenderState { .Expression = field.type_expr});
32973313 },
32983314 ast.Node.Id.UnionTag => {
3299 const tag = @fieldParentPtr(ast.NodeUnionTag, "base", decl);
3315 const tag = @fieldParentPtr(ast.Node.UnionTag, "base", decl);
33003316 try stream.print("{}", self.tokenizer.getTokenSlice(tag.name_token));
33013317
33023318 if (tag.type_expr) |type_expr| {
......@@ -3305,7 +3321,7 @@ pub const Parser = struct {
33053321 }
33063322 },
33073323 ast.Node.Id.EnumTag => {
3308 const tag = @fieldParentPtr(ast.NodeEnumTag, "base", decl);
3324 const tag = @fieldParentPtr(ast.Node.EnumTag, "base", decl);
33093325 try stream.print("{}", self.tokenizer.getTokenSlice(tag.name_token));
33103326
33113327 if (tag.value) |value| {
......@@ -3324,6 +3340,7 @@ pub const Parser = struct {
33243340 },
33253341
33263342 RenderState.FieldInitializer => |field_init| {
3343 //TODO try self.renderComments(stream, field_init, indent);
33273344 try stream.print(".{}", self.tokenizer.getTokenSlice(field_init.name_token));
33283345 try stream.print(" = ");
33293346 try stack.append(RenderState { .Expression = field_init.expr });
......@@ -3369,7 +3386,8 @@ pub const Parser = struct {
33693386 },
33703387
33713388 RenderState.ParamDecl => |base| {
3372 const param_decl = @fieldParentPtr(ast.NodeParamDecl, "base", base);
3389 const param_decl = @fieldParentPtr(ast.Node.ParamDecl, "base", base);
3390 // TODO try self.renderComments(stream, param_decl, indent);
33733391 if (param_decl.comptime_token) |comptime_token| {
33743392 try stream.print("{} ", self.tokenizer.getTokenSlice(comptime_token));
33753393 }
......@@ -3390,11 +3408,11 @@ pub const Parser = struct {
33903408 },
33913409 RenderState.Expression => |base| switch (base.id) {
33923410 ast.Node.Id.Identifier => {
3393 const identifier = @fieldParentPtr(ast.NodeIdentifier, "base", base);
3411 const identifier = @fieldParentPtr(ast.Node.Identifier, "base", base);
33943412 try stream.print("{}", self.tokenizer.getTokenSlice(identifier.token));
33953413 },
33963414 ast.Node.Id.Block => {
3397 const block = @fieldParentPtr(ast.NodeBlock, "base", base);
3415 const block = @fieldParentPtr(ast.Node.Block, "base", base);
33983416 if (block.label) |label| {
33993417 try stream.print("{}: ", self.tokenizer.getTokenSlice(label));
34003418 }
......@@ -3430,17 +3448,17 @@ pub const Parser = struct {
34303448 }
34313449 },
34323450 ast.Node.Id.Defer => {
3433 const defer_node = @fieldParentPtr(ast.NodeDefer, "base", base);
3451 const defer_node = @fieldParentPtr(ast.Node.Defer, "base", base);
34343452 try stream.print("{} ", self.tokenizer.getTokenSlice(defer_node.defer_token));
34353453 try stack.append(RenderState { .Expression = defer_node.expr });
34363454 },
34373455 ast.Node.Id.Comptime => {
3438 const comptime_node = @fieldParentPtr(ast.NodeComptime, "base", base);
3456 const comptime_node = @fieldParentPtr(ast.Node.Comptime, "base", base);
34393457 try stream.print("{} ", self.tokenizer.getTokenSlice(comptime_node.comptime_token));
34403458 try stack.append(RenderState { .Expression = comptime_node.expr });
34413459 },
34423460 ast.Node.Id.AsyncAttribute => {
3443 const async_attr = @fieldParentPtr(ast.NodeAsyncAttribute, "base", base);
3461 const async_attr = @fieldParentPtr(ast.Node.AsyncAttribute, "base", base);
34443462 try stream.print("{}", self.tokenizer.getTokenSlice(async_attr.async_token));
34453463
34463464 if (async_attr.allocator_type) |allocator_type| {
......@@ -3450,7 +3468,7 @@ pub const Parser = struct {
34503468 }
34513469 },
34523470 ast.Node.Id.Suspend => {
3453 const suspend_node = @fieldParentPtr(ast.NodeSuspend, "base", base);
3471 const suspend_node = @fieldParentPtr(ast.Node.Suspend, "base", base);
34543472 try stream.print("{}", self.tokenizer.getTokenSlice(suspend_node.suspend_token));
34553473
34563474 if (suspend_node.body) |body| {
......@@ -3464,10 +3482,10 @@ pub const Parser = struct {
34643482 }
34653483 },
34663484 ast.Node.Id.InfixOp => {
3467 const prefix_op_node = @fieldParentPtr(ast.NodeInfixOp, "base", base);
3485 const prefix_op_node = @fieldParentPtr(ast.Node.InfixOp, "base", base);
34683486 try stack.append(RenderState { .Expression = prefix_op_node.rhs });
34693487
3470 if (prefix_op_node.op == ast.NodeInfixOp.InfixOp.Catch) {
3488 if (prefix_op_node.op == ast.Node.InfixOp.Op.Catch) {
34713489 if (prefix_op_node.op.Catch) |payload| {
34723490 try stack.append(RenderState { .Text = " " });
34733491 try stack.append(RenderState { .Expression = payload });
......@@ -3475,49 +3493,49 @@ pub const Parser = struct {
34753493 try stack.append(RenderState { .Text = " catch " });
34763494 } else {
34773495 const text = switch (prefix_op_node.op) {
3478 ast.NodeInfixOp.InfixOp.Add => " + ",
3479 ast.NodeInfixOp.InfixOp.AddWrap => " +% ",
3480 ast.NodeInfixOp.InfixOp.ArrayCat => " ++ ",
3481 ast.NodeInfixOp.InfixOp.ArrayMult => " ** ",
3482 ast.NodeInfixOp.InfixOp.Assign => " = ",
3483 ast.NodeInfixOp.InfixOp.AssignBitAnd => " &= ",
3484 ast.NodeInfixOp.InfixOp.AssignBitOr => " |= ",
3485 ast.NodeInfixOp.InfixOp.AssignBitShiftLeft => " <<= ",
3486 ast.NodeInfixOp.InfixOp.AssignBitShiftRight => " >>= ",
3487 ast.NodeInfixOp.InfixOp.AssignBitXor => " ^= ",
3488 ast.NodeInfixOp.InfixOp.AssignDiv => " /= ",
3489 ast.NodeInfixOp.InfixOp.AssignMinus => " -= ",
3490 ast.NodeInfixOp.InfixOp.AssignMinusWrap => " -%= ",
3491 ast.NodeInfixOp.InfixOp.AssignMod => " %= ",
3492 ast.NodeInfixOp.InfixOp.AssignPlus => " += ",
3493 ast.NodeInfixOp.InfixOp.AssignPlusWrap => " +%= ",
3494 ast.NodeInfixOp.InfixOp.AssignTimes => " *= ",
3495 ast.NodeInfixOp.InfixOp.AssignTimesWarp => " *%= ",
3496 ast.NodeInfixOp.InfixOp.BangEqual => " != ",
3497 ast.NodeInfixOp.InfixOp.BitAnd => " & ",
3498 ast.NodeInfixOp.InfixOp.BitOr => " | ",
3499 ast.NodeInfixOp.InfixOp.BitShiftLeft => " << ",
3500 ast.NodeInfixOp.InfixOp.BitShiftRight => " >> ",
3501 ast.NodeInfixOp.InfixOp.BitXor => " ^ ",
3502 ast.NodeInfixOp.InfixOp.BoolAnd => " and ",
3503 ast.NodeInfixOp.InfixOp.BoolOr => " or ",
3504 ast.NodeInfixOp.InfixOp.Div => " / ",
3505 ast.NodeInfixOp.InfixOp.EqualEqual => " == ",
3506 ast.NodeInfixOp.InfixOp.ErrorUnion => "!",
3507 ast.NodeInfixOp.InfixOp.GreaterOrEqual => " >= ",
3508 ast.NodeInfixOp.InfixOp.GreaterThan => " > ",
3509 ast.NodeInfixOp.InfixOp.LessOrEqual => " <= ",
3510 ast.NodeInfixOp.InfixOp.LessThan => " < ",
3511 ast.NodeInfixOp.InfixOp.MergeErrorSets => " || ",
3512 ast.NodeInfixOp.InfixOp.Mod => " % ",
3513 ast.NodeInfixOp.InfixOp.Mult => " * ",
3514 ast.NodeInfixOp.InfixOp.MultWrap => " *% ",
3515 ast.NodeInfixOp.InfixOp.Period => ".",
3516 ast.NodeInfixOp.InfixOp.Sub => " - ",
3517 ast.NodeInfixOp.InfixOp.SubWrap => " -% ",
3518 ast.NodeInfixOp.InfixOp.UnwrapMaybe => " ?? ",
3519 ast.NodeInfixOp.InfixOp.Range => " ... ",
3520 ast.NodeInfixOp.InfixOp.Catch => unreachable,
3496 ast.Node.InfixOp.Op.Add => " + ",
3497 ast.Node.InfixOp.Op.AddWrap => " +% ",
3498 ast.Node.InfixOp.Op.ArrayCat => " ++ ",
3499 ast.Node.InfixOp.Op.ArrayMult => " ** ",
3500 ast.Node.InfixOp.Op.Assign => " = ",
3501 ast.Node.InfixOp.Op.AssignBitAnd => " &= ",
3502 ast.Node.InfixOp.Op.AssignBitOr => " |= ",
3503 ast.Node.InfixOp.Op.AssignBitShiftLeft => " <<= ",
3504 ast.Node.InfixOp.Op.AssignBitShiftRight => " >>= ",
3505 ast.Node.InfixOp.Op.AssignBitXor => " ^= ",
3506 ast.Node.InfixOp.Op.AssignDiv => " /= ",
3507 ast.Node.InfixOp.Op.AssignMinus => " -= ",
3508 ast.Node.InfixOp.Op.AssignMinusWrap => " -%= ",
3509 ast.Node.InfixOp.Op.AssignMod => " %= ",
3510 ast.Node.InfixOp.Op.AssignPlus => " += ",
3511 ast.Node.InfixOp.Op.AssignPlusWrap => " +%= ",
3512 ast.Node.InfixOp.Op.AssignTimes => " *= ",
3513 ast.Node.InfixOp.Op.AssignTimesWarp => " *%= ",
3514 ast.Node.InfixOp.Op.BangEqual => " != ",
3515 ast.Node.InfixOp.Op.BitAnd => " & ",
3516 ast.Node.InfixOp.Op.BitOr => " | ",
3517 ast.Node.InfixOp.Op.BitShiftLeft => " << ",
3518 ast.Node.InfixOp.Op.BitShiftRight => " >> ",
3519 ast.Node.InfixOp.Op.BitXor => " ^ ",
3520 ast.Node.InfixOp.Op.BoolAnd => " and ",
3521 ast.Node.InfixOp.Op.BoolOr => " or ",
3522 ast.Node.InfixOp.Op.Div => " / ",
3523 ast.Node.InfixOp.Op.EqualEqual => " == ",
3524 ast.Node.InfixOp.Op.ErrorUnion => "!",
3525 ast.Node.InfixOp.Op.GreaterOrEqual => " >= ",
3526 ast.Node.InfixOp.Op.GreaterThan => " > ",
3527 ast.Node.InfixOp.Op.LessOrEqual => " <= ",
3528 ast.Node.InfixOp.Op.LessThan => " < ",
3529 ast.Node.InfixOp.Op.MergeErrorSets => " || ",
3530 ast.Node.InfixOp.Op.Mod => " % ",
3531 ast.Node.InfixOp.Op.Mult => " * ",
3532 ast.Node.InfixOp.Op.MultWrap => " *% ",
3533 ast.Node.InfixOp.Op.Period => ".",
3534 ast.Node.InfixOp.Op.Sub => " - ",
3535 ast.Node.InfixOp.Op.SubWrap => " -% ",
3536 ast.Node.InfixOp.Op.UnwrapMaybe => " ?? ",
3537 ast.Node.InfixOp.Op.Range => " ... ",
3538 ast.Node.InfixOp.Op.Catch => unreachable,
35213539 };
35223540
35233541 try stack.append(RenderState { .Text = text });
......@@ -3525,10 +3543,10 @@ pub const Parser = struct {
35253543 try stack.append(RenderState { .Expression = prefix_op_node.lhs });
35263544 },
35273545 ast.Node.Id.PrefixOp => {
3528 const prefix_op_node = @fieldParentPtr(ast.NodePrefixOp, "base", base);
3546 const prefix_op_node = @fieldParentPtr(ast.Node.PrefixOp, "base", base);
35293547 try stack.append(RenderState { .Expression = prefix_op_node.rhs });
35303548 switch (prefix_op_node.op) {
3531 ast.NodePrefixOp.PrefixOp.AddrOf => |addr_of_info| {
3549 ast.Node.PrefixOp.Op.AddrOf => |addr_of_info| {
35323550 try stream.write("&");
35333551 if (addr_of_info.volatile_token != null) {
35343552 try stack.append(RenderState { .Text = "volatile "});
......@@ -3542,7 +3560,7 @@ pub const Parser = struct {
35423560 try stack.append(RenderState { .Expression = align_expr});
35433561 }
35443562 },
3545 ast.NodePrefixOp.PrefixOp.SliceType => |addr_of_info| {
3563 ast.Node.PrefixOp.Op.SliceType => |addr_of_info| {
35463564 try stream.write("[]");
35473565 if (addr_of_info.volatile_token != null) {
35483566 try stack.append(RenderState { .Text = "volatile "});
......@@ -3556,29 +3574,29 @@ pub const Parser = struct {
35563574 try stack.append(RenderState { .Expression = align_expr});
35573575 }
35583576 },
3559 ast.NodePrefixOp.PrefixOp.ArrayType => |array_index| {
3577 ast.Node.PrefixOp.Op.ArrayType => |array_index| {
35603578 try stack.append(RenderState { .Text = "]"});
35613579 try stack.append(RenderState { .Expression = array_index});
35623580 try stack.append(RenderState { .Text = "["});
35633581 },
3564 ast.NodePrefixOp.PrefixOp.BitNot => try stream.write("~"),
3565 ast.NodePrefixOp.PrefixOp.BoolNot => try stream.write("!"),
3566 ast.NodePrefixOp.PrefixOp.Deref => try stream.write("*"),
3567 ast.NodePrefixOp.PrefixOp.Negation => try stream.write("-"),
3568 ast.NodePrefixOp.PrefixOp.NegationWrap => try stream.write("-%"),
3569 ast.NodePrefixOp.PrefixOp.Try => try stream.write("try "),
3570 ast.NodePrefixOp.PrefixOp.UnwrapMaybe => try stream.write("??"),
3571 ast.NodePrefixOp.PrefixOp.MaybeType => try stream.write("?"),
3572 ast.NodePrefixOp.PrefixOp.Await => try stream.write("await "),
3573 ast.NodePrefixOp.PrefixOp.Cancel => try stream.write("cancel "),
3574 ast.NodePrefixOp.PrefixOp.Resume => try stream.write("resume "),
3582 ast.Node.PrefixOp.Op.BitNot => try stream.write("~"),
3583 ast.Node.PrefixOp.Op.BoolNot => try stream.write("!"),
3584 ast.Node.PrefixOp.Op.Deref => try stream.write("*"),
3585 ast.Node.PrefixOp.Op.Negation => try stream.write("-"),
3586 ast.Node.PrefixOp.Op.NegationWrap => try stream.write("-%"),
3587 ast.Node.PrefixOp.Op.Try => try stream.write("try "),
3588 ast.Node.PrefixOp.Op.UnwrapMaybe => try stream.write("??"),
3589 ast.Node.PrefixOp.Op.MaybeType => try stream.write("?"),
3590 ast.Node.PrefixOp.Op.Await => try stream.write("await "),
3591 ast.Node.PrefixOp.Op.Cancel => try stream.write("cancel "),
3592 ast.Node.PrefixOp.Op.Resume => try stream.write("resume "),
35753593 }
35763594 },
35773595 ast.Node.Id.SuffixOp => {
3578 const suffix_op = @fieldParentPtr(ast.NodeSuffixOp, "base", base);
3596 const suffix_op = @fieldParentPtr(ast.Node.SuffixOp, "base", base);
35793597
35803598 switch (suffix_op.op) {
3581 ast.NodeSuffixOp.SuffixOp.Call => |call_info| {
3599 ast.Node.SuffixOp.Op.Call => |call_info| {
35823600 try stack.append(RenderState { .Text = ")"});
35833601 var i = call_info.params.len;
35843602 while (i != 0) {
......@@ -3597,13 +3615,13 @@ pub const Parser = struct {
35973615 try stack.append(RenderState { .Expression = &async_attr.base });
35983616 }
35993617 },
3600 ast.NodeSuffixOp.SuffixOp.ArrayAccess => |index_expr| {
3618 ast.Node.SuffixOp.Op.ArrayAccess => |index_expr| {
36013619 try stack.append(RenderState { .Text = "]"});
36023620 try stack.append(RenderState { .Expression = index_expr});
36033621 try stack.append(RenderState { .Text = "["});
36043622 try stack.append(RenderState { .Expression = suffix_op.lhs });
36053623 },
3606 ast.NodeSuffixOp.SuffixOp.Slice => |range| {
3624 ast.Node.SuffixOp.Op.Slice => |range| {
36073625 try stack.append(RenderState { .Text = "]"});
36083626 if (range.end) |end| {
36093627 try stack.append(RenderState { .Expression = end});
......@@ -3613,7 +3631,7 @@ pub const Parser = struct {
36133631 try stack.append(RenderState { .Text = "["});
36143632 try stack.append(RenderState { .Expression = suffix_op.lhs });
36153633 },
3616 ast.NodeSuffixOp.SuffixOp.StructInitializer => |field_inits| {
3634 ast.Node.SuffixOp.Op.StructInitializer => |field_inits| {
36173635 if (field_inits.len == 0) {
36183636 try stack.append(RenderState { .Text = "{}" });
36193637 try stack.append(RenderState { .Expression = suffix_op.lhs });
......@@ -3634,7 +3652,7 @@ pub const Parser = struct {
36343652 try stack.append(RenderState { .Text = " {\n"});
36353653 try stack.append(RenderState { .Expression = suffix_op.lhs });
36363654 },
3637 ast.NodeSuffixOp.SuffixOp.ArrayInitializer => |exprs| {
3655 ast.Node.SuffixOp.Op.ArrayInitializer => |exprs| {
36383656 if (exprs.len == 0) {
36393657 try stack.append(RenderState { .Text = "{}" });
36403658 try stack.append(RenderState { .Expression = suffix_op.lhs });
......@@ -3658,7 +3676,7 @@ pub const Parser = struct {
36583676 }
36593677 },
36603678 ast.Node.Id.ControlFlowExpression => {
3661 const flow_expr = @fieldParentPtr(ast.NodeControlFlowExpression, "base", base);
3679 const flow_expr = @fieldParentPtr(ast.Node.ControlFlowExpression, "base", base);
36623680
36633681 if (flow_expr.rhs) |rhs| {
36643682 try stack.append(RenderState { .Expression = rhs });
......@@ -3666,34 +3684,34 @@ pub const Parser = struct {
36663684 }
36673685
36683686 switch (flow_expr.kind) {
3669 ast.NodeControlFlowExpression.Kind.Break => |maybe_label| {
3687 ast.Node.ControlFlowExpression.Kind.Break => |maybe_label| {
36703688 try stream.print("break");
36713689 if (maybe_label) |label| {
36723690 try stream.print(" :");
36733691 try stack.append(RenderState { .Expression = label });
36743692 }
36753693 },
3676 ast.NodeControlFlowExpression.Kind.Continue => |maybe_label| {
3694 ast.Node.ControlFlowExpression.Kind.Continue => |maybe_label| {
36773695 try stream.print("continue");
36783696 if (maybe_label) |label| {
36793697 try stream.print(" :");
36803698 try stack.append(RenderState { .Expression = label });
36813699 }
36823700 },
3683 ast.NodeControlFlowExpression.Kind.Return => {
3701 ast.Node.ControlFlowExpression.Kind.Return => {
36843702 try stream.print("return");
36853703 },
36863704
36873705 }
36883706 },
36893707 ast.Node.Id.Payload => {
3690 const payload = @fieldParentPtr(ast.NodePayload, "base", base);
3708 const payload = @fieldParentPtr(ast.Node.Payload, "base", base);
36913709 try stack.append(RenderState { .Text = "|"});
36923710 try stack.append(RenderState { .Expression = payload.error_symbol });
36933711 try stack.append(RenderState { .Text = "|"});
36943712 },
36953713 ast.Node.Id.PointerPayload => {
3696 const payload = @fieldParentPtr(ast.NodePointerPayload, "base", base);
3714 const payload = @fieldParentPtr(ast.Node.PointerPayload, "base", base);
36973715 try stack.append(RenderState { .Text = "|"});
36983716 try stack.append(RenderState { .Expression = payload.value_symbol });
36993717
......@@ -3704,7 +3722,7 @@ pub const Parser = struct {
37043722 try stack.append(RenderState { .Text = "|"});
37053723 },
37063724 ast.Node.Id.PointerIndexPayload => {
3707 const payload = @fieldParentPtr(ast.NodePointerIndexPayload, "base", base);
3725 const payload = @fieldParentPtr(ast.Node.PointerIndexPayload, "base", base);
37083726 try stack.append(RenderState { .Text = "|"});
37093727
37103728 if (payload.index_symbol) |index_symbol| {
......@@ -3721,69 +3739,69 @@ pub const Parser = struct {
37213739 try stack.append(RenderState { .Text = "|"});
37223740 },
37233741 ast.Node.Id.GroupedExpression => {
3724 const grouped_expr = @fieldParentPtr(ast.NodeGroupedExpression, "base", base);
3742 const grouped_expr = @fieldParentPtr(ast.Node.GroupedExpression, "base", base);
37253743 try stack.append(RenderState { .Text = ")"});
37263744 try stack.append(RenderState { .Expression = grouped_expr.expr });
37273745 try stack.append(RenderState { .Text = "("});
37283746 },
37293747 ast.Node.Id.FieldInitializer => {
3730 const field_init = @fieldParentPtr(ast.NodeFieldInitializer, "base", base);
3748 const field_init = @fieldParentPtr(ast.Node.FieldInitializer, "base", base);
37313749 try stream.print(".{} = ", self.tokenizer.getTokenSlice(field_init.name_token));
37323750 try stack.append(RenderState { .Expression = field_init.expr });
37333751 },
37343752 ast.Node.Id.IntegerLiteral => {
3735 const integer_literal = @fieldParentPtr(ast.NodeIntegerLiteral, "base", base);
3753 const integer_literal = @fieldParentPtr(ast.Node.IntegerLiteral, "base", base);
37363754 try stream.print("{}", self.tokenizer.getTokenSlice(integer_literal.token));
37373755 },
37383756 ast.Node.Id.FloatLiteral => {
3739 const float_literal = @fieldParentPtr(ast.NodeFloatLiteral, "base", base);
3757 const float_literal = @fieldParentPtr(ast.Node.FloatLiteral, "base", base);
37403758 try stream.print("{}", self.tokenizer.getTokenSlice(float_literal.token));
37413759 },
37423760 ast.Node.Id.StringLiteral => {
3743 const string_literal = @fieldParentPtr(ast.NodeStringLiteral, "base", base);
3761 const string_literal = @fieldParentPtr(ast.Node.StringLiteral, "base", base);
37443762 try stream.print("{}", self.tokenizer.getTokenSlice(string_literal.token));
37453763 },
37463764 ast.Node.Id.CharLiteral => {
3747 const char_literal = @fieldParentPtr(ast.NodeCharLiteral, "base", base);
3765 const char_literal = @fieldParentPtr(ast.Node.CharLiteral, "base", base);
37483766 try stream.print("{}", self.tokenizer.getTokenSlice(char_literal.token));
37493767 },
37503768 ast.Node.Id.BoolLiteral => {
3751 const bool_literal = @fieldParentPtr(ast.NodeCharLiteral, "base", base);
3769 const bool_literal = @fieldParentPtr(ast.Node.CharLiteral, "base", base);
37523770 try stream.print("{}", self.tokenizer.getTokenSlice(bool_literal.token));
37533771 },
37543772 ast.Node.Id.NullLiteral => {
3755 const null_literal = @fieldParentPtr(ast.NodeNullLiteral, "base", base);
3773 const null_literal = @fieldParentPtr(ast.Node.NullLiteral, "base", base);
37563774 try stream.print("{}", self.tokenizer.getTokenSlice(null_literal.token));
37573775 },
37583776 ast.Node.Id.ThisLiteral => {
3759 const this_literal = @fieldParentPtr(ast.NodeThisLiteral, "base", base);
3777 const this_literal = @fieldParentPtr(ast.Node.ThisLiteral, "base", base);
37603778 try stream.print("{}", self.tokenizer.getTokenSlice(this_literal.token));
37613779 },
37623780 ast.Node.Id.Unreachable => {
3763 const unreachable_node = @fieldParentPtr(ast.NodeUnreachable, "base", base);
3781 const unreachable_node = @fieldParentPtr(ast.Node.Unreachable, "base", base);
37643782 try stream.print("{}", self.tokenizer.getTokenSlice(unreachable_node.token));
37653783 },
37663784 ast.Node.Id.ErrorType => {
3767 const error_type = @fieldParentPtr(ast.NodeErrorType, "base", base);
3785 const error_type = @fieldParentPtr(ast.Node.ErrorType, "base", base);
37683786 try stream.print("{}", self.tokenizer.getTokenSlice(error_type.token));
37693787 },
37703788 ast.Node.Id.VarType => {
3771 const var_type = @fieldParentPtr(ast.NodeVarType, "base", base);
3789 const var_type = @fieldParentPtr(ast.Node.VarType, "base", base);
37723790 try stream.print("{}", self.tokenizer.getTokenSlice(var_type.token));
37733791 },
37743792 ast.Node.Id.ContainerDecl => {
3775 const container_decl = @fieldParentPtr(ast.NodeContainerDecl, "base", base);
3793 const container_decl = @fieldParentPtr(ast.Node.ContainerDecl, "base", base);
37763794
37773795 switch (container_decl.layout) {
3778 ast.NodeContainerDecl.Layout.Packed => try stream.print("packed "),
3779 ast.NodeContainerDecl.Layout.Extern => try stream.print("extern "),
3780 ast.NodeContainerDecl.Layout.Auto => { },
3796 ast.Node.ContainerDecl.Layout.Packed => try stream.print("packed "),
3797 ast.Node.ContainerDecl.Layout.Extern => try stream.print("extern "),
3798 ast.Node.ContainerDecl.Layout.Auto => { },
37813799 }
37823800
37833801 switch (container_decl.kind) {
3784 ast.NodeContainerDecl.Kind.Struct => try stream.print("struct"),
3785 ast.NodeContainerDecl.Kind.Enum => try stream.print("enum"),
3786 ast.NodeContainerDecl.Kind.Union => try stream.print("union"),
3802 ast.Node.ContainerDecl.Kind.Struct => try stream.print("struct"),
3803 ast.Node.ContainerDecl.Kind.Enum => try stream.print("enum"),
3804 ast.Node.ContainerDecl.Kind.Union => try stream.print("union"),
37873805 }
37883806
37893807 try stack.append(RenderState { .Text = "}"});
......@@ -3823,9 +3841,9 @@ pub const Parser = struct {
38233841 try stack.append(RenderState { .Text = "{"});
38243842
38253843 switch (container_decl.init_arg_expr) {
3826 ast.NodeContainerDecl.InitArg.None => try stack.append(RenderState { .Text = " "}),
3827 ast.NodeContainerDecl.InitArg.Enum => try stack.append(RenderState { .Text = "(enum) "}),
3828 ast.NodeContainerDecl.InitArg.Type => |type_expr| {
3844 ast.Node.ContainerDecl.InitArg.None => try stack.append(RenderState { .Text = " "}),
3845 ast.Node.ContainerDecl.InitArg.Enum => try stack.append(RenderState { .Text = "(enum) "}),
3846 ast.Node.ContainerDecl.InitArg.Type => |type_expr| {
38293847 try stack.append(RenderState { .Text = ") "});
38303848 try stack.append(RenderState { .Expression = type_expr});
38313849 try stack.append(RenderState { .Text = "("});
......@@ -3833,7 +3851,7 @@ pub const Parser = struct {
38333851 }
38343852 },
38353853 ast.Node.Id.ErrorSetDecl => {
3836 const err_set_decl = @fieldParentPtr(ast.NodeErrorSetDecl, "base", base);
3854 const err_set_decl = @fieldParentPtr(ast.Node.ErrorSetDecl, "base", base);
38373855 try stream.print("error ");
38383856
38393857 try stack.append(RenderState { .Text = "}"});
......@@ -3866,7 +3884,7 @@ pub const Parser = struct {
38663884 try stack.append(RenderState { .Text = "{"});
38673885 },
38683886 ast.Node.Id.MultilineStringLiteral => {
3869 const multiline_str_literal = @fieldParentPtr(ast.NodeMultilineStringLiteral, "base", base);
3887 const multiline_str_literal = @fieldParentPtr(ast.Node.MultilineStringLiteral, "base", base);
38703888 try stream.print("\n");
38713889
38723890 var i : usize = 0;
......@@ -3878,11 +3896,11 @@ pub const Parser = struct {
38783896 try stream.writeByteNTimes(' ', indent + indent_delta);
38793897 },
38803898 ast.Node.Id.UndefinedLiteral => {
3881 const undefined_literal = @fieldParentPtr(ast.NodeUndefinedLiteral, "base", base);
3899 const undefined_literal = @fieldParentPtr(ast.Node.UndefinedLiteral, "base", base);
38823900 try stream.print("{}", self.tokenizer.getTokenSlice(undefined_literal.token));
38833901 },
38843902 ast.Node.Id.BuiltinCall => {
3885 const builtin_call = @fieldParentPtr(ast.NodeBuiltinCall, "base", base);
3903 const builtin_call = @fieldParentPtr(ast.Node.BuiltinCall, "base", base);
38863904 try stream.print("{}(", self.tokenizer.getTokenSlice(builtin_call.builtin_token));
38873905 try stack.append(RenderState { .Text = ")"});
38883906 var i = builtin_call.params.len;
......@@ -3896,13 +3914,13 @@ pub const Parser = struct {
38963914 }
38973915 },
38983916 ast.Node.Id.FnProto => {
3899 const fn_proto = @fieldParentPtr(ast.NodeFnProto, "base", base);
3917 const fn_proto = @fieldParentPtr(ast.Node.FnProto, "base", base);
39003918
39013919 switch (fn_proto.return_type) {
3902 ast.NodeFnProto.ReturnType.Explicit => |node| {
3920 ast.Node.FnProto.ReturnType.Explicit => |node| {
39033921 try stack.append(RenderState { .Expression = node});
39043922 },
3905 ast.NodeFnProto.ReturnType.InferErrorSet => |node| {
3923 ast.Node.FnProto.ReturnType.InferErrorSet => |node| {
39063924 try stack.append(RenderState { .Expression = node});
39073925 try stack.append(RenderState { .Text = "!"});
39083926 },
......@@ -3960,7 +3978,7 @@ pub const Parser = struct {
39603978 },
39613979 ast.Node.Id.LineComment => @panic("TODO render line comment in an expression"),
39623980 ast.Node.Id.Switch => {
3963 const switch_node = @fieldParentPtr(ast.NodeSwitch, "base", base);
3981 const switch_node = @fieldParentPtr(ast.Node.Switch, "base", base);
39643982 try stream.print("{} (", self.tokenizer.getTokenSlice(switch_node.switch_token));
39653983
39663984 try stack.append(RenderState { .Text = "}"});
......@@ -3994,7 +4012,7 @@ pub const Parser = struct {
39944012 try stack.append(RenderState { .Expression = switch_node.expr });
39954013 },
39964014 ast.Node.Id.SwitchCase => {
3997 const switch_case = @fieldParentPtr(ast.NodeSwitchCase, "base", base);
4015 const switch_case = @fieldParentPtr(ast.Node.SwitchCase, "base", base);
39984016
39994017 try stack.append(RenderState { .Expression = switch_case.expr });
40004018 if (switch_case.payload) |payload| {
......@@ -4016,11 +4034,11 @@ pub const Parser = struct {
40164034 }
40174035 },
40184036 ast.Node.Id.SwitchElse => {
4019 const switch_else = @fieldParentPtr(ast.NodeSwitchElse, "base", base);
4037 const switch_else = @fieldParentPtr(ast.Node.SwitchElse, "base", base);
40204038 try stream.print("{}", self.tokenizer.getTokenSlice(switch_else.token));
40214039 },
40224040 ast.Node.Id.Else => {
4023 const else_node = @fieldParentPtr(ast.NodeElse, "base", base);
4041 const else_node = @fieldParentPtr(ast.Node.Else, "base", base);
40244042 try stream.print("{}", self.tokenizer.getTokenSlice(else_node.else_token));
40254043
40264044 switch (else_node.body.id) {
......@@ -4045,7 +4063,7 @@ pub const Parser = struct {
40454063 }
40464064 },
40474065 ast.Node.Id.While => {
4048 const while_node = @fieldParentPtr(ast.NodeWhile, "base", base);
4066 const while_node = @fieldParentPtr(ast.Node.While, "base", base);
40494067 if (while_node.label) |label| {
40504068 try stream.print("{}: ", self.tokenizer.getTokenSlice(label));
40514069 }
......@@ -4095,7 +4113,7 @@ pub const Parser = struct {
40954113 try stack.append(RenderState { .Text = "(" });
40964114 },
40974115 ast.Node.Id.For => {
4098 const for_node = @fieldParentPtr(ast.NodeFor, "base", base);
4116 const for_node = @fieldParentPtr(ast.Node.For, "base", base);
40994117 if (for_node.label) |label| {
41004118 try stream.print("{}: ", self.tokenizer.getTokenSlice(label));
41014119 }
......@@ -4138,7 +4156,7 @@ pub const Parser = struct {
41384156 try stack.append(RenderState { .Text = "(" });
41394157 },
41404158 ast.Node.Id.If => {
4141 const if_node = @fieldParentPtr(ast.NodeIf, "base", base);
4159 const if_node = @fieldParentPtr(ast.Node.If, "base", base);
41424160 try stream.print("{} ", self.tokenizer.getTokenSlice(if_node.if_token));
41434161
41444162 switch (if_node.body.id) {
......@@ -4185,7 +4203,7 @@ pub const Parser = struct {
41854203 try stack.append(RenderState { .Text = "(" });
41864204 },
41874205 ast.Node.Id.Asm => {
4188 const asm_node = @fieldParentPtr(ast.NodeAsm, "base", base);
4206 const asm_node = @fieldParentPtr(ast.Node.Asm, "base", base);
41894207 try stream.print("{} ", self.tokenizer.getTokenSlice(asm_node.asm_token));
41904208
41914209 if (asm_node.volatile_token) |volatile_token| {
......@@ -4272,7 +4290,7 @@ pub const Parser = struct {
42724290 try stack.append(RenderState { .Text = "(" });
42734291 },
42744292 ast.Node.Id.AsmInput => {
4275 const asm_input = @fieldParentPtr(ast.NodeAsmInput, "base", base);
4293 const asm_input = @fieldParentPtr(ast.Node.AsmInput, "base", base);
42764294
42774295 try stack.append(RenderState { .Text = ")"});
42784296 try stack.append(RenderState { .Expression = asm_input.expr});
......@@ -4283,14 +4301,14 @@ pub const Parser = struct {
42834301 try stack.append(RenderState { .Text = "["});
42844302 },
42854303 ast.Node.Id.AsmOutput => {
4286 const asm_output = @fieldParentPtr(ast.NodeAsmOutput, "base", base);
4304 const asm_output = @fieldParentPtr(ast.Node.AsmOutput, "base", base);
42874305
42884306 try stack.append(RenderState { .Text = ")"});
42894307 switch (asm_output.kind) {
4290 ast.NodeAsmOutput.Kind.Variable => |variable_name| {
4308 ast.Node.AsmOutput.Kind.Variable => |variable_name| {
42914309 try stack.append(RenderState { .Expression = &variable_name.base});
42924310 },
4293 ast.NodeAsmOutput.Kind.Return => |return_type| {
4311 ast.Node.AsmOutput.Kind.Return => |return_type| {
42944312 try stack.append(RenderState { .Expression = return_type});
42954313 try stack.append(RenderState { .Text = "-> "});
42964314 },
......@@ -4312,15 +4330,10 @@ pub const Parser = struct {
43124330 ast.Node.Id.ParamDecl => unreachable,
43134331 },
43144332 RenderState.Statement => |base| {
4315 if (base.comment) |comment| {
4316 for (comment.lines.toSliceConst()) |line_token| {
4317 try stream.print("{}\n", self.tokenizer.getTokenSlice(line_token));
4318 try stream.writeByteNTimes(' ', indent);
4319 }
4320 }
43214333 switch (base.id) {
43224334 ast.Node.Id.VarDecl => {
4323 const var_decl = @fieldParentPtr(ast.NodeVarDecl, "base", base);
4335 const var_decl = @fieldParentPtr(ast.Node.VarDecl, "base", base);
4336 try self.renderComments(stream, var_decl, indent);
43244337 try stack.append(RenderState { .VarDecl = var_decl});
43254338 },
43264339 else => {
......@@ -4337,6 +4350,14 @@ pub const Parser = struct {
43374350 }
43384351 }
43394352
4353 fn renderComments(self: &Parser, stream: var, node: var, indent: usize) !void {
4354 const comment = node.comments ?? return;
4355 for (comment.lines.toSliceConst()) |line_token| {
4356 try stream.print("{}\n", self.tokenizer.getTokenSlice(line_token));
4357 try stream.writeByteNTimes(' ', indent);
4358 }
4359 }
4360
43404361 fn initUtilityArrayList(self: &Parser, comptime T: type) ArrayList(T) {
43414362 const new_byte_count = self.utility_bytes.len - self.utility_bytes.len % @sizeOf(T);
43424363 self.utility_bytes = self.util_allocator.alignedShrink(u8, utility_bytes_align, self.utility_bytes, new_byte_count);
......@@ -4411,6 +4432,14 @@ fn testCanonical(source: []const u8) !void {
44114432 }
44124433}
44134434
4435test "zig fmt: preserve top level comments" {
4436 try testCanonical(
4437 \\// top level comment
4438 \\test "hi" {}
4439 \\
4440 );
4441}
4442
44144443test "zig fmt: get stdout or fail" {
44154444 try testCanonical(
44164445 \\const std = @import("std");