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...@@ -6523,6 +6523,8 @@ static IrInstruction *ir_gen_node_raw(IrBuilder *irb, AstNode *node, Scope *scop
6523 case NodeTypeFieldAccessExpr:6523 case NodeTypeFieldAccessExpr:
6524 {6524 {
6525 IrInstruction *ptr_instruction = ir_gen_field_access(irb, scope, node);6525 IrInstruction *ptr_instruction = ir_gen_field_access(irb, scope, node);
6526 if (ptr_instruction == irb->codegen->invalid_instruction)
6527 return ptr_instruction;
6526 if (lval.is_ptr)6528 if (lval.is_ptr)
6527 return ptr_instruction;6529 return ptr_instruction;
65286530
...@@ -15556,6 +15558,8 @@ static TypeTableEntry *ir_analyze_instruction_field_parent_ptr(IrAnalyze *ira,...@@ -15556,6 +15558,8 @@ static TypeTableEntry *ir_analyze_instruction_field_parent_ptr(IrAnalyze *ira,
15556 }15558 }
1555715559
15558 ensure_complete_type(ira->codegen, container_type);15560 ensure_complete_type(ira->codegen, container_type);
15561 if (type_is_invalid(container_type))
15562 return ira->codegen->builtin_types.entry_invalid;
1555915563
15560 TypeStructField *field = find_struct_type_field(container_type, field_name);15564 TypeStructField *field = find_struct_type_field(container_type, field_name);
15561 if (field == nullptr) {15565 if (field == nullptr) {
std/zig/ast.zig+1314-1379
...@@ -6,7 +6,6 @@ const mem = std.mem;...@@ -6,7 +6,6 @@ const mem = std.mem;
66
7pub const Node = struct {7pub const Node = struct {
8 id: Id,8 id: Id,
9 comment: ?&NodeLineComment,
109
11 pub const Id = enum {10 pub const Id = enum {
12 // Top level11 // Top level
...@@ -74,1750 +73,1686 @@ pub const Node = struct {...@@ -74,1750 +73,1686 @@ pub const Node = struct {
74 FieldInitializer,73 FieldInitializer,
75 };74 };
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
161 pub fn iterate(base: &Node, index: usize) ?&Node {76 pub fn iterate(base: &Node, index: usize) ?&Node {
162 inline for (idTypeTable) |id_type_pair| {77 comptime var i = 0;
163 if (base.id == id_type_pair.id)78 inline while (i < @memberCount(Id)) : (i += 1) {
164 return @fieldParentPtr(id_type_pair.Type, "base", base).iterate(index);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 }
165 }83 }
166
167 unreachable;84 unreachable;
168 }85 }
16986
170 pub fn firstToken(base: &Node) Token {87 pub fn firstToken(base: &Node) Token {
171 inline for (idTypeTable) |id_type_pair| {88 comptime var i = 0;
172 if (base.id == id_type_pair.id)89 inline while (i < @memberCount(Id)) : (i += 1) {
173 return @fieldParentPtr(id_type_pair.Type, "base", base).firstToken();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 }
174 }94 }
175
176 unreachable;95 unreachable;
177 }96 }
17897
179 pub fn lastToken(base: &Node) Token {98 pub fn lastToken(base: &Node) Token {
180 inline for (idTypeTable) |id_type_pair| {99 comptime var i = 0;
181 if (base.id == id_type_pair.id)100 inline while (i < @memberCount(Id)) : (i += 1) {
182 return @fieldParentPtr(id_type_pair.Type, "base", base).lastToken();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 }
183 }105 }
184
185 unreachable;106 unreachable;
186 }107 }
187};
188108
189pub const NodeRoot = struct {109 pub fn typeToId(comptime T: type) Id {
190 base: Node,110 comptime var i = 0;
191 decls: ArrayList(&Node),111 inline while (i < @memberCount(Id)) : (i += 1) {
192 eof_token: Token,112 if (T == @field(Node, @memberName(Id, i))) {
193113 return @field(Id, @memberName(Id, i));
194 pub fn iterate(self: &NodeRoot, index: usize) ?&Node {114 }
195 if (index < self.decls.len) {
196 return self.decls.items[self.decls.len - index - 1];
197 }115 }
198 return null;116 unreachable;
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();
203 }117 }
204118
205 pub fn lastToken(self: &NodeRoot) Token {119 pub const Root = struct {
206 return if (self.decls.len == 0) self.eof_token else self.decls.at(self.decls.len - 1).lastToken();120 base: Node,
207 }121 decls: ArrayList(&Node),
208};122 eof_token: Token,
209123
210pub const NodeVarDecl = struct {124 pub fn iterate(self: &Root, index: usize) ?&Node {
211 base: Node,125 if (index < self.decls.len) {
212 visib_token: ?Token,126 return self.decls.items[self.decls.len - index - 1];
213 name_token: Token,127 }
214 eq_token: Token,128 return null;
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;
230 }129 }
231130
232 if (self.align_node) |align_node| {131 pub fn firstToken(self: &Root) Token {
233 if (i < 1) return align_node;132 return if (self.decls.len == 0) self.eof_token else self.decls.at(0).firstToken();
234 i -= 1;
235 }133 }
236134
237 if (self.init_node) |init_node| {135 pub fn lastToken(self: &Root) Token {
238 if (i < 1) return init_node;136 return if (self.decls.len == 0) self.eof_token else self.decls.at(self.decls.len - 1).lastToken();
239 i -= 1;
240 }137 }
138 };
241139
242 return null;140 pub const VarDecl = struct {
243 }141 base: Node,
244142 comments: ?&LineComment,
245 pub fn firstToken(self: &NodeVarDecl) Token {143 visib_token: ?Token,
246 if (self.visib_token) |visib_token| return visib_token;144 name_token: Token,
247 if (self.comptime_token) |comptime_token| return comptime_token;145 eq_token: Token,
248 if (self.extern_export_token) |extern_export_token| return extern_export_token;146 mut_token: Token,
249 assert(self.lib_name == null);147 comptime_token: ?Token,
250 return self.mut_token;148 extern_export_token: ?Token,
251 }149 lib_name: ?&Node,
252150 type_node: ?&Node,
253 pub fn lastToken(self: &NodeVarDecl) Token {151 align_node: ?&Node,
254 return self.semicolon_token;152 init_node: ?&Node,
255 }153 semicolon_token: Token,
256};154
257155 pub fn iterate(self: &VarDecl, index: usize) ?&Node {
258pub const NodeUse = struct {156 var i = index;
259 base: Node,157
260 visib_token: ?Token,158 if (self.type_node) |type_node| {
261 expr: &Node,159 if (i < 1) return type_node;
262 semicolon_token: Token,160 i -= 1;
263161 }
264 pub fn iterate(self: &NodeUse, index: usize) ?&Node {
265 var i = index;
266162
267 if (i < 1) return self.expr;163 if (self.align_node) |align_node| {
268 i -= 1;164 if (i < 1) return align_node;
165 i -= 1;
166 }
269167
270 return null;168 if (self.init_node) |init_node| {
271 }169 if (i < 1) return init_node;
170 i -= 1;
171 }
272172
273 pub fn firstToken(self: &NodeUse) Token {173 return null;
274 if (self.visib_token) |visib_token| return visib_token;174 }
275 return self.expr.firstToken();
276 }
277175
278 pub fn lastToken(self: &NodeUse) Token {176 pub fn firstToken(self: &VarDecl) Token {
279 return self.semicolon_token;177 if (self.visib_token) |visib_token| return visib_token;
280 }178 if (self.comptime_token) |comptime_token| return comptime_token;
281};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 {184 pub fn lastToken(self: &VarDecl) Token {
284 base: Node,185 return self.semicolon_token;
285 error_token: Token,186 }
286 decls: ArrayList(&Node),187 };
287 rbrace_token: Token,
288188
289 pub fn iterate(self: &NodeErrorSetDecl, index: usize) ?&Node {189 pub const Use = struct {
290 var i = index;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);195 pub fn iterate(self: &Use, index: usize) ?&Node {
293 i -= self.decls.len;196 var i = index;
294197
295 return null;198 if (i < 1) return self.expr;
296 }199 i -= 1;
297200
298 pub fn firstToken(self: &NodeErrorSetDecl) Token {201 return null;
299 return self.error_token;202 }
300 }
301203
302 pub fn lastToken(self: &NodeErrorSetDecl) Token {204 pub fn firstToken(self: &Use) Token {
303 return self.rbrace_token;205 if (self.visib_token) |visib_token| return visib_token;
304 }206 return self.expr.firstToken();
305};207 }
306208
307pub const NodeContainerDecl = struct {209 pub fn lastToken(self: &Use) Token {
308 base: Node,210 return self.semicolon_token;
309 ltoken: Token,211 }
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,
320 };212 };
321213
322 const Kind = enum {214 pub const ErrorSetDecl = struct {
323 Struct,215 base: Node,
324 Enum,216 error_token: Token,
325 Union,217 decls: ArrayList(&Node),
326 };218 rbrace_token: Token,
327219
328 const InitArg = union(enum) {220 pub fn iterate(self: &ErrorSetDecl, index: usize) ?&Node {
329 None,221 var i = index;
330 Enum,
331 Type: &Node,
332 };
333222
334 pub fn iterate(self: &NodeContainerDecl, index: usize) ?&Node {223 if (i < self.decls.len) return self.decls.at(i);
335 var i = index;224 i -= self.decls.len;
336225
337 switch (self.init_arg_expr) {226 return null;
338 InitArg.Type => |t| {
339 if (i < 1) return t;
340 i -= 1;
341 },
342 InitArg.None,
343 InitArg.Enum => { }
344 }227 }
345228
346 if (i < self.fields_and_decls.len) return self.fields_and_decls.at(i);229 pub fn firstToken(self: &ErrorSetDecl) Token {
347 i -= self.fields_and_decls.len;230 return self.error_token;
231 }
348232
349 return null;233 pub fn lastToken(self: &ErrorSetDecl) Token {
350 }234 return self.rbrace_token;
235 }
236 };
351237
352 pub fn firstToken(self: &NodeContainerDecl) Token {238 pub const ContainerDecl = struct {
353 return self.ltoken;239 base: Node,
354 }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 {253 const Kind = enum {
357 return self.rbrace_token;254 Struct,
358 }255 Enum,
359};256 Union,
257 };
258
259 const InitArg = union(enum) {
260 None,
261 Enum,
262 Type: &Node,
263 };
360264
361pub const NodeStructField = struct {265 pub fn iterate(self: &ContainerDecl, index: usize) ?&Node {
362 base: Node,266 var i = index;
363 visib_token: ?Token,
364 name_token: Token,
365 type_expr: &Node,
366267
367 pub fn iterate(self: &NodeStructField, index: usize) ?&Node {268 switch (self.init_arg_expr) {
368 var i = index;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;277 if (i < self.fields_and_decls.len) return self.fields_and_decls.at(i);
371 i -= 1;278 i -= self.fields_and_decls.len;
372279
373 return null;280 return null;
374 }281 }
375282
376 pub fn firstToken(self: &NodeStructField) Token {283 pub fn firstToken(self: &ContainerDecl) Token {
377 if (self.visib_token) |visib_token| return visib_token;284 return self.ltoken;
378 return self.name_token;285 }
379 }
380286
381 pub fn lastToken(self: &NodeStructField) Token {287 pub fn lastToken(self: &ContainerDecl) Token {
382 return self.type_expr.lastToken();288 return self.rbrace_token;
383 }289 }
384};290 };
385291
386pub const NodeUnionTag = struct {292 pub const StructField = struct {
387 base: Node,293 base: Node,
388 name_token: Token,294 visib_token: ?Token,
389 type_expr: ?&Node,295 name_token: Token,
296 type_expr: &Node,
390297
391 pub fn iterate(self: &NodeUnionTag, index: usize) ?&Node {298 pub fn iterate(self: &StructField, index: usize) ?&Node {
392 var i = index;299 var i = index;
393300
394 if (self.type_expr) |type_expr| {301 if (i < 1) return self.type_expr;
395 if (i < 1) return type_expr;
396 i -= 1;302 i -= 1;
397 }
398303
399 return null;304 return null;
400 }305 }
401306
402 pub fn firstToken(self: &NodeUnionTag) Token {307 pub fn firstToken(self: &StructField) Token {
403 return self.name_token;308 if (self.visib_token) |visib_token| return visib_token;
404 }309 return self.name_token;
310 }
405311
406 pub fn lastToken(self: &NodeUnionTag) Token {312 pub fn lastToken(self: &StructField) Token {
407 if (self.type_expr) |type_expr| {313 return self.type_expr.lastToken();
408 return type_expr.lastToken();
409 }314 }
315 };
410316
411 return self.name_token;317 pub const UnionTag = struct {
412 }318 base: Node,
413};319 name_token: Token,
320 type_expr: ?&Node,
414321
415pub const NodeEnumTag = struct {322 pub fn iterate(self: &UnionTag, index: usize) ?&Node {
416 base: Node,323 var i = index;
417 name_token: Token,
418 value: ?&Node,
419324
420 pub fn iterate(self: &NodeEnumTag, index: usize) ?&Node {325 if (self.type_expr) |type_expr| {
421 var i = index;326 if (i < 1) return type_expr;
327 i -= 1;
328 }
422329
423 if (self.value) |value| {330 return null;
424 if (i < 1) return value;
425 i -= 1;
426 }331 }
427332
428 return null;333 pub fn firstToken(self: &UnionTag) Token {
429 }334 return self.name_token;
335 }
430336
431 pub fn firstToken(self: &NodeEnumTag) Token {337 pub fn lastToken(self: &UnionTag) Token {
432 return self.name_token;338 if (self.type_expr) |type_expr| {
433 }339 return type_expr.lastToken();
340 }
434341
435 pub fn lastToken(self: &NodeEnumTag) Token {342 return self.name_token;
436 if (self.value) |value| {
437 return value.lastToken();
438 }343 }
344 };
439345
440 return self.name_token;346 pub const EnumTag = struct {
441 }347 base: Node,
442};348 name_token: Token,
443349 value: ?&Node,
444pub const NodeIdentifier = struct {
445 base: Node,
446 token: Token,
447350
448 pub fn iterate(self: &NodeIdentifier, index: usize) ?&Node {351 pub fn iterate(self: &EnumTag, index: usize) ?&Node {
449 return null;352 var i = index;
450 }
451353
452 pub fn firstToken(self: &NodeIdentifier) Token {354 if (self.value) |value| {
453 return self.token;355 if (i < 1) return value;
454 }356 i -= 1;
357 }
455358
456 pub fn lastToken(self: &NodeIdentifier) Token {359 return null;
457 return self.token;360 }
458 }
459};
460361
461pub const NodeAsyncAttribute = struct {362 pub fn firstToken(self: &EnumTag) Token {
462 base: Node,363 return self.name_token;
463 async_token: Token,364 }
464 allocator_type: ?&Node,
465 rangle_bracket: ?Token,
466365
467 pub fn iterate(self: &NodeAsyncAttribute, index: usize) ?&Node {366 pub fn lastToken(self: &EnumTag) Token {
468 var i = index;367 if (self.value) |value| {
368 return value.lastToken();
369 }
469370
470 if (self.allocator_type) |allocator_type| {371 return self.name_token;
471 if (i < 1) return allocator_type;
472 i -= 1;
473 }372 }
373 };
474374
475 return null;375 pub const Identifier = struct {
476 }376 base: Node,
477377 token: Token,
478 pub fn firstToken(self: &NodeAsyncAttribute) Token {
479 return self.async_token;
480 }
481378
482 pub fn lastToken(self: &NodeAsyncAttribute) Token {379 pub fn iterate(self: &Identifier, index: usize) ?&Node {
483 if (self.rangle_bracket) |rangle_bracket| {380 return null;
484 return rangle_bracket;
485 }381 }
486382
487 return self.async_token;383 pub fn firstToken(self: &Identifier) Token {
488 }384 return self.token;
489};385 }
490386
491pub const NodeFnProto = struct {387 pub fn lastToken(self: &Identifier) Token {
492 base: Node,388 return self.token;
493 visib_token: ?Token,389 }
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,
509 };390 };
510391
511 pub fn iterate(self: &NodeFnProto, index: usize) ?&Node {392 pub const AsyncAttribute = struct {
512 var i = index;393 base: Node,
394 async_token: Token,
395 allocator_type: ?&Node,
396 rangle_bracket: ?Token,
513397
514 if (self.body_node) |body_node| {398 pub fn iterate(self: &AsyncAttribute, index: usize) ?&Node {
515 if (i < 1) return body_node;399 var i = index;
516 i -= 1;
517 }
518400
519 switch (self.return_type) {401 if (self.allocator_type) |allocator_type| {
520 // TODO allow this and next prong to share bodies since the types are the same402 if (i < 1) return allocator_type;
521 ReturnType.Explicit => |node| {
522 if (i < 1) return node;
523 i -= 1;403 i -= 1;
524 },404 }
525 ReturnType.InferErrorSet => |node| {405
526 if (i < 1) return node;406 return null;
527 i -= 1;
528 },
529 }407 }
530408
531 if (self.align_expr) |align_expr| {409 pub fn firstToken(self: &AsyncAttribute) Token {
532 if (i < 1) return align_expr;410 return self.async_token;
533 i -= 1;
534 }411 }
535412
536 if (i < self.params.len) return self.params.items[self.params.len - i - 1];413 pub fn lastToken(self: &AsyncAttribute) Token {
537 i -= self.params.len;414 if (self.rangle_bracket) |rangle_bracket| {
415 return rangle_bracket;
416 }
538417
539 if (self.lib_name) |lib_name| {418 return self.async_token;
540 if (i < 1) return lib_name;
541 i -= 1;
542 }419 }
420 };
543421
544 return null;422 pub const FnProto = struct {
545 }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 {443 pub fn iterate(self: &FnProto, index: usize) ?&Node {
548 if (self.visib_token) |visib_token| return visib_token;444 var i = index;
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 }
554445
555 pub fn lastToken(self: &NodeFnProto) Token {446 if (self.body_node) |body_node| {
556 if (self.body_node) |body_node| return body_node.lastToken();447 if (i < 1) return body_node;
557 switch (self.return_type) {448 i -= 1;
558 // TODO allow this and next prong to share bodies since the types are the same449 }
559 ReturnType.Explicit => |node| return node.lastToken(),
560 ReturnType.InferErrorSet => |node| return node.lastToken(),
561 }
562 }
563};
564450
565pub const NodeParamDecl = struct {451 switch (self.return_type) {
566 base: Node,452 // TODO allow this and next prong to share bodies since the types are the same
567 comptime_token: ?Token,453 ReturnType.Explicit => |node| {
568 noalias_token: ?Token,454 if (i < 1) return node;
569 name_token: ?Token,455 i -= 1;
570 type_node: &Node,456 },
571 var_args_token: ?Token,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 {463 if (self.align_expr) |align_expr| {
574 var i = index;464 if (i < 1) return align_expr;
465 i -= 1;
466 }
575467
576 if (i < 1) return self.type_node;468 if (i < self.params.len) return self.params.items[self.params.len - i - 1];
577 i -= 1;469 i -= self.params.len;
578470
579 return null;471 if (self.lib_name) |lib_name| {
580 }472 if (i < 1) return lib_name;
473 i -= 1;
474 }
581475
582 pub fn firstToken(self: &NodeParamDecl) Token {476 return null;
583 if (self.comptime_token) |comptime_token| return comptime_token;477 }
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 }
588478
589 pub fn lastToken(self: &NodeParamDecl) Token {479 pub fn firstToken(self: &FnProto) Token {
590 if (self.var_args_token) |var_args_token| return var_args_token;480 if (self.visib_token) |visib_token| return visib_token;
591 return self.type_node.lastToken();481 if (self.extern_export_inline_token) |extern_export_inline_token| return extern_export_inline_token;
592 }482 assert(self.lib_name == null);
593};483 if (self.cc_token) |cc_token| return cc_token;
484 return self.fn_token;
485 }
594486
595pub const NodeBlock = struct {487 pub fn lastToken(self: &FnProto) Token {
596 base: Node,488 if (self.body_node) |body_node| return body_node.lastToken();
597 label: ?Token,489 switch (self.return_type) {
598 lbrace: Token,490 // TODO allow this and next prong to share bodies since the types are the same
599 statements: ArrayList(&Node),491 ReturnType.Explicit => |node| return node.lastToken(),
600 rbrace: Token,492 ReturnType.InferErrorSet => |node| return node.lastToken(),
493 }
494 }
495 };
601496
602 pub fn iterate(self: &NodeBlock, index: usize) ?&Node {497 pub const ParamDecl = struct {
603 var i = index;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];505 pub fn iterate(self: &ParamDecl, index: usize) ?&Node {
606 i -= self.statements.len;506 var i = index;
607507
608 return null;508 if (i < 1) return self.type_node;
609 }509 i -= 1;
610510
611 pub fn firstToken(self: &NodeBlock) Token {511 return null;
612 if (self.label) |label| {
613 return label;
614 }512 }
615513
616 return self.lbrace;514 pub fn firstToken(self: &ParamDecl) Token {
617 }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 {521 pub fn lastToken(self: &ParamDecl) Token {
620 return self.rbrace;522 if (self.var_args_token) |var_args_token| return var_args_token;
621 }523 return self.type_node.lastToken();
622};524 }
525 };
623526
624pub const NodeDefer = struct {527 pub const Block = struct {
625 base: Node,528 base: Node,
626 defer_token: Token,529 label: ?Token,
627 kind: Kind,530 lbrace: Token,
628 expr: &Node,531 statements: ArrayList(&Node),
532 rbrace: Token,
629533
630 const Kind = enum {534 pub fn iterate(self: &Block, index: usize) ?&Node {
631 Error,535 var i = index;
632 Unconditional,
633 };
634536
635 pub fn iterate(self: &NodeDefer, index: usize) ?&Node {537 if (i < self.statements.len) return self.statements.items[i];
636 var i = index;538 i -= self.statements.len;
637539
638 if (i < 1) return self.expr;540 return null;
639 i -= 1;541 }
640542
641 return null;543 pub fn firstToken(self: &Block) Token {
642 }544 if (self.label) |label| {
545 return label;
546 }
643547
644 pub fn firstToken(self: &NodeDefer) Token {548 return self.lbrace;
645 return self.defer_token;549 }
646 }
647550
648 pub fn lastToken(self: &NodeDefer) Token {551 pub fn lastToken(self: &Block) Token {
649 return self.expr.lastToken();552 return self.rbrace;
650 }553 }
651};554 };
652555
653pub const NodeComptime = struct {556 pub const Defer = struct {
654 base: Node,557 base: Node,
655 comptime_token: Token,558 defer_token: Token,
656 expr: &Node,559 kind: Kind,
560 expr: &Node,
657561
658 pub fn iterate(self: &NodeComptime, index: usize) ?&Node {562 const Kind = enum {
659 var i = index;563 Error,
564 Unconditional,
565 };
660566
661 if (i < 1) return self.expr;567 pub fn iterate(self: &Defer, index: usize) ?&Node {
662 i -= 1;568 var i = index;
663569
664 return null;570 if (i < 1) return self.expr;
665 }571 i -= 1;
666572
667 pub fn firstToken(self: &NodeComptime) Token {573 return null;
668 return self.comptime_token;574 }
669 }
670575
671 pub fn lastToken(self: &NodeComptime) Token {576 pub fn firstToken(self: &Defer) Token {
672 return self.expr.lastToken();577 return self.defer_token;
673 }578 }
674};
675579
676pub const NodePayload = struct {580 pub fn lastToken(self: &Defer) Token {
677 base: Node,581 return self.expr.lastToken();
678 lpipe: Token,582 }
679 error_symbol: &Node,583 };
680 rpipe: Token,
681584
682 pub fn iterate(self: &NodePayload, index: usize) ?&Node {585 pub const Comptime = struct {
683 var i = index;586 base: Node,
587 comptime_token: Token,
588 expr: &Node,
684589
685 if (i < 1) return self.error_symbol;590 pub fn iterate(self: &Comptime, index: usize) ?&Node {
686 i -= 1;591 var i = index;
687592
688 return null;593 if (i < 1) return self.expr;
689 }594 i -= 1;
690595
691 pub fn firstToken(self: &NodePayload) Token {596 return null;
692 return self.lpipe;597 }
693 }
694598
695 pub fn lastToken(self: &NodePayload) Token {599 pub fn firstToken(self: &Comptime) Token {
696 return self.rpipe;600 return self.comptime_token;
697 }601 }
698};
699602
700pub const NodePointerPayload = struct {603 pub fn lastToken(self: &Comptime) Token {
701 base: Node,604 return self.expr.lastToken();
702 lpipe: Token,605 }
703 ptr_token: ?Token,606 };
704 value_symbol: &Node,
705 rpipe: Token,
706607
707 pub fn iterate(self: &NodePointerPayload, index: usize) ?&Node {608 pub const Payload = struct {
708 var i = index;609 base: Node,
610 lpipe: Token,
611 error_symbol: &Node,
612 rpipe: Token,
709613
710 if (i < 1) return self.value_symbol;614 pub fn iterate(self: &Payload, index: usize) ?&Node {
711 i -= 1;615 var i = index;
712616
713 return null;617 if (i < 1) return self.error_symbol;
714 }618 i -= 1;
715619
716 pub fn firstToken(self: &NodePointerPayload) Token {620 return null;
717 return self.lpipe;621 }
718 }
719622
720 pub fn lastToken(self: &NodePointerPayload) Token {623 pub fn firstToken(self: &Payload) Token {
721 return self.rpipe;624 return self.lpipe;
722 }625 }
723};
724626
725pub const NodePointerIndexPayload = struct {627 pub fn lastToken(self: &Payload) Token {
726 base: Node,628 return self.rpipe;
727 lpipe: Token,629 }
728 ptr_token: ?Token,630 };
729 value_symbol: &Node,
730 index_symbol: ?&Node,
731 rpipe: Token,
732631
733 pub fn iterate(self: &NodePointerIndexPayload, index: usize) ?&Node {632 pub const PointerPayload = struct {
734 var i = index;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;639 pub fn iterate(self: &PointerPayload, index: usize) ?&Node {
737 i -= 1;640 var i = index;
738641
739 if (self.index_symbol) |index_symbol| {642 if (i < 1) return self.value_symbol;
740 if (i < 1) return index_symbol;
741 i -= 1;643 i -= 1;
742 }
743644
744 return null;645 return null;
745 }646 }
746647
747 pub fn firstToken(self: &NodePointerIndexPayload) Token {648 pub fn firstToken(self: &PointerPayload) Token {
748 return self.lpipe;649 return self.lpipe;
749 }650 }
750651
751 pub fn lastToken(self: &NodePointerIndexPayload) Token {652 pub fn lastToken(self: &PointerPayload) Token {
752 return self.rpipe;653 return self.rpipe;
753 }654 }
754};655 };
755656
756pub const NodeElse = struct {657 pub const PointerIndexPayload = struct {
757 base: Node,658 base: Node,
758 else_token: Token,659 lpipe: Token,
759 payload: ?&Node,660 ptr_token: ?Token,
760 body: &Node,661 value_symbol: &Node,
662 index_symbol: ?&Node,
663 rpipe: Token,
761664
762 pub fn iterate(self: &NodeElse, index: usize) ?&Node {665 pub fn iterate(self: &PointerIndexPayload, index: usize) ?&Node {
763 var i = index;666 var i = index;
764667
765 if (self.payload) |payload| {668 if (i < 1) return self.value_symbol;
766 if (i < 1) return payload;
767 i -= 1;669 i -= 1;
768 }
769670
770 if (i < 1) return self.body;671 if (self.index_symbol) |index_symbol| {
771 i -= 1;672 if (i < 1) return index_symbol;
772673 i -= 1;
773 return null;674 }
774 }
775675
776 pub fn firstToken(self: &NodeElse) Token {676 return null;
777 return self.else_token;677 }
778 }
779678
780 pub fn lastToken(self: &NodeElse) Token {679 pub fn firstToken(self: &PointerIndexPayload) Token {
781 return self.body.lastToken();680 return self.lpipe;
782 }681 }
783};
784682
785pub const NodeSwitch = struct {683 pub fn lastToken(self: &PointerIndexPayload) Token {
786 base: Node,684 return self.rpipe;
787 switch_token: Token,685 }
788 expr: &Node,686 };
789 cases: ArrayList(&NodeSwitchCase),
790 rbrace: Token,
791687
792 pub fn iterate(self: &NodeSwitch, index: usize) ?&Node {688 pub const Else = struct {
793 var i = index;689 base: Node,
690 else_token: Token,
691 payload: ?&Node,
692 body: &Node,
794693
795 if (i < 1) return self.expr;694 pub fn iterate(self: &Else, index: usize) ?&Node {
796 i -= 1;695 var i = index;
797696
798 if (i < self.cases.len) return &self.cases.at(i).base;697 if (self.payload) |payload| {
799 i -= self.cases.len;698 if (i < 1) return payload;
699 i -= 1;
700 }
800701
801 return null;702 if (i < 1) return self.body;
802 }703 i -= 1;
803704
804 pub fn firstToken(self: &NodeSwitch) Token {705 return null;
805 return self.switch_token;706 }
806 }
807707
808 pub fn lastToken(self: &NodeSwitch) Token {708 pub fn firstToken(self: &Else) Token {
809 return self.rbrace;709 return self.else_token;
810 }710 }
811};
812711
813pub const NodeSwitchCase = struct {712 pub fn lastToken(self: &Else) Token {
814 base: Node,713 return self.body.lastToken();
815 items: ArrayList(&Node),714 }
816 payload: ?&Node,715 };
817 expr: &Node,
818716
819 pub fn iterate(self: &NodeSwitchCase, index: usize) ?&Node {717 pub const Switch = struct {
820 var i = index;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);724 pub fn iterate(self: &Switch, index: usize) ?&Node {
823 i -= self.items.len;725 var i = index;
824726
825 if (self.payload) |payload| {727 if (i < 1) return self.expr;
826 if (i < 1) return payload;
827 i -= 1;728 i -= 1;
828 }
829729
830 if (i < 1) return self.expr;730 if (i < self.cases.len) return &self.cases.at(i).base;
831 i -= 1;731 i -= self.cases.len;
832732
833 return null;733 return null;
834 }734 }
835735
836 pub fn firstToken(self: &NodeSwitchCase) Token {736 pub fn firstToken(self: &Switch) Token {
837 return self.items.at(0).firstToken();737 return self.switch_token;
838 }738 }
839739
840 pub fn lastToken(self: &NodeSwitchCase) Token {740 pub fn lastToken(self: &Switch) Token {
841 return self.expr.lastToken();741 return self.rbrace;
842 }742 }
843};743 };
844744
845pub const NodeSwitchElse = struct {745 pub const SwitchCase = struct {
846 base: Node,746 base: Node,
847 token: Token,747 items: ArrayList(&Node),
748 payload: ?&Node,
749 expr: &Node,
848750
849 pub fn iterate(self: &NodeSwitchElse, index: usize) ?&Node {751 pub fn iterate(self: &SwitchCase, index: usize) ?&Node {
850 return null;752 var i = index;
851 }
852753
853 pub fn firstToken(self: &NodeSwitchElse) Token {754 if (i < self.items.len) return self.items.at(i);
854 return self.token;755 i -= self.items.len;
855 }
856756
857 pub fn lastToken(self: &NodeSwitchElse) Token {757 if (self.payload) |payload| {
858 return self.token;758 if (i < 1) return payload;
859 }759 i -= 1;
860};760 }
861761
862pub const NodeWhile = struct {762 if (i < 1) return self.expr;
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;
881 i -= 1;763 i -= 1;
882 }
883764
884 if (self.continue_expr) |continue_expr| {765 return null;
885 if (i < 1) return continue_expr;
886 i -= 1;
887 }766 }
888767
889 if (i < 1) return self.body;768 pub fn firstToken(self: &SwitchCase) Token {
890 i -= 1;769 return self.items.at(0).firstToken();
770 }
891771
892 if (self.@"else") |@"else"| {772 pub fn lastToken(self: &SwitchCase) Token {
893 if (i < 1) return &@"else".base;773 return self.expr.lastToken();
894 i -= 1;
895 }774 }
775 };
896776
897 return null;777 pub const SwitchElse = struct {
898 }778 base: Node,
779 token: Token,
899780
900 pub fn firstToken(self: &NodeWhile) Token {781 pub fn iterate(self: &SwitchElse, index: usize) ?&Node {
901 if (self.label) |label| {782 return null;
902 return label;
903 }783 }
904784
905 if (self.inline_token) |inline_token| {785 pub fn firstToken(self: &SwitchElse) Token {
906 return inline_token;786 return self.token;
907 }787 }
908788
909 return self.while_token;789 pub fn lastToken(self: &SwitchElse) Token {
910 }790 return self.token;
911
912 pub fn lastToken(self: &NodeWhile) Token {
913 if (self.@"else") |@"else"| {
914 return @"else".body.lastToken();
915 }791 }
792 };
916793
917 return self.body.lastToken();794 pub const While = struct {
918 }795 base: Node,
919};796 label: ?Token,
920797 inline_token: ?Token,
921pub const NodeFor = struct {798 while_token: Token,
922 base: Node,799 condition: &Node,
923 label: ?Token,800 payload: ?&Node,
924 inline_token: ?Token,801 continue_expr: ?&Node,
925 for_token: Token,802 body: &Node,
926 array_expr: &Node,803 @"else": ?&Else,
927 payload: ?&Node,804
928 body: &Node,805 pub fn iterate(self: &While, index: usize) ?&Node {
929 @"else": ?&NodeElse,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 {811 if (self.payload) |payload| {
932 var i = index;812 if (i < 1) return payload;
813 i -= 1;
814 }
933815
934 if (i < 1) return self.array_expr;816 if (self.continue_expr) |continue_expr| {
935 i -= 1;817 if (i < 1) return continue_expr;
818 i -= 1;
819 }
936820
937 if (self.payload) |payload| {821 if (i < 1) return self.body;
938 if (i < 1) return payload;
939 i -= 1;822 i -= 1;
940 }
941823
942 if (i < 1) return self.body;824 if (self.@"else") |@"else"| {
943 i -= 1;825 if (i < 1) return &@"else".base;
826 i -= 1;
827 }
944828
945 if (self.@"else") |@"else"| {829 return null;
946 if (i < 1) return &@"else".base;
947 i -= 1;
948 }830 }
949831
950 return null;832 pub fn firstToken(self: &While) Token {
951 }833 if (self.label) |label| {
834 return label;
835 }
952836
953 pub fn firstToken(self: &NodeFor) Token {837 if (self.inline_token) |inline_token| {
954 if (self.label) |label| {838 return inline_token;
955 return label;839 }
956 }
957840
958 if (self.inline_token) |inline_token| {841 return self.while_token;
959 return inline_token;
960 }842 }
961843
962 return self.for_token;844 pub fn lastToken(self: &While) Token {
963 }845 if (self.@"else") |@"else"| {
846 return @"else".body.lastToken();
847 }
964848
965 pub fn lastToken(self: &NodeFor) Token {849 return self.body.lastToken();
966 if (self.@"else") |@"else"| {
967 return @"else".body.lastToken();
968 }850 }
851 };
969852
970 return self.body.lastToken();853 pub const For = struct {
971 }854 base: Node,
972};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 {863 pub fn iterate(self: &For, index: usize) ?&Node {
975 base: Node,864 var i = index;
976 if_token: Token,
977 condition: &Node,
978 payload: ?&Node,
979 body: &Node,
980 @"else": ?&NodeElse,
981865
982 pub fn iterate(self: &NodeIf, index: usize) ?&Node {866 if (i < 1) return self.array_expr;
983 var i = index;867 i -= 1;
984868
985 if (i < 1) return self.condition;869 if (self.payload) |payload| {
986 i -= 1;870 if (i < 1) return payload;
871 i -= 1;
872 }
987873
988 if (self.payload) |payload| {874 if (i < 1) return self.body;
989 if (i < 1) return payload;
990 i -= 1;875 i -= 1;
991 }
992876
993 if (i < 1) return self.body;877 if (self.@"else") |@"else"| {
994 i -= 1;878 if (i < 1) return &@"else".base;
879 i -= 1;
880 }
995881
996 if (self.@"else") |@"else"| {882 return null;
997 if (i < 1) return &@"else".base;
998 i -= 1;
999 }883 }
1000884
1001 return null;885 pub fn firstToken(self: &For) Token {
1002 }886 if (self.label) |label| {
887 return label;
888 }
1003889
1004 pub fn firstToken(self: &NodeIf) Token {890 if (self.inline_token) |inline_token| {
1005 return self.if_token;891 return inline_token;
1006 }892 }
1007893
1008 pub fn lastToken(self: &NodeIf) Token {894 return self.for_token;
1009 if (self.@"else") |@"else"| {
1010 return @"else".body.lastToken();
1011 }895 }
1012896
1013 return self.body.lastToken();897 pub fn lastToken(self: &For) Token {
1014 }898 if (self.@"else") |@"else"| {
1015};899 return @"else".body.lastToken();
900 }
1016901
1017pub const NodeInfixOp = struct {902 return self.body.lastToken();
1018 base: Node,903 }
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,
1068 };904 };
1069905
1070 pub fn iterate(self: &NodeInfixOp, index: usize) ?&Node {906 pub const If = struct {
1071 var i = index;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;914 pub fn iterate(self: &If, index: usize) ?&Node {
1074 i -= 1;915 var i = index;
1075916
1076 switch (self.op) {917 if (i < 1) return self.condition;
1077 InfixOp.Catch => |maybe_payload| {918 i -= 1;
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 }
1133919
1134 pub fn firstToken(self: &NodeInfixOp) Token {920 if (self.payload) |payload| {
1135 return self.lhs.firstToken();921 if (i < 1) return payload;
1136 }922 i -= 1;
923 }
1137924
1138 pub fn lastToken(self: &NodeInfixOp) Token {925 if (i < 1) return self.body;
1139 return self.rhs.lastToken();926 i -= 1;
1140 }
1141};
1142927
1143pub const NodePrefixOp = struct {928 if (self.@"else") |@"else"| {
1144 base: Node,929 if (i < 1) return &@"else".base;
1145 op_token: Token,930 i -= 1;
1146 op: PrefixOp,931 }
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 };
1165932
1166 const AddrOfInfo = struct {933 return null;
1167 align_expr: ?&Node,934 }
1168 bit_offset_start_token: ?Token,
1169 bit_offset_end_token: ?Token,
1170 const_token: ?Token,
1171 volatile_token: ?Token,
1172 };
1173935
1174 pub fn iterate(self: &NodePrefixOp, index: usize) ?&Node {936 pub fn firstToken(self: &If) Token {
1175 var i = index;937 return self.if_token;
938 }
1176939
1177 switch (self.op) {940 pub fn lastToken(self: &If) Token {
1178 PrefixOp.SliceType => |addr_of_info| {941 if (self.@"else") |@"else"| {
1179 if (addr_of_info.align_expr) |align_expr| {942 return @"else".body.lastToken();
1180 if (i < 1) return align_expr;943 }
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 }
1212944
1213 pub fn firstToken(self: &NodePrefixOp) Token {945 return self.body.lastToken();
1214 return self.op_token;946 }
1215 }947 };
1216948
1217 pub fn lastToken(self: &NodePrefixOp) Token {949 pub const InfixOp = struct {
1218 return self.rhs.lastToken();950 base: Node,
1219 }951 op_token: Token,
1220};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 {1002 pub fn iterate(self: &InfixOp, index: usize) ?&Node {
1223 base: Node,1003 var i = index;
1224 period_token: Token,
1225 name_token: Token,
1226 expr: &Node,
12271004
1228 pub fn iterate(self: &NodeFieldInitializer, index: usize) ?&Node {1005 if (i < 1) return self.lhs;
1229 var i = index;1006 i -= 1;
12301007
1231 if (i < 1) return self.expr;1008 switch (self.op) {
1232 i -= 1;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;1060 if (i < 1) return self.rhs;
1235 }1061 i -= 1;
12361062
1237 pub fn firstToken(self: &NodeFieldInitializer) Token {1063 return null;
1238 return self.period_token;1064 }
1239 }
12401065
1241 pub fn lastToken(self: &NodeFieldInitializer) Token {1066 pub fn firstToken(self: &InfixOp) Token {
1242 return self.expr.lastToken();1067 return self.lhs.firstToken();
1243 }1068 }
1244};
12451069
1246pub const NodeSuffixOp = struct {1070 pub fn lastToken(self: &InfixOp) Token {
1247 base: Node,1071 return self.rhs.lastToken();
1248 lhs: &Node,1072 }
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),
1258 };1073 };
12591074
1260 const CallInfo = struct {1075 pub const PrefixOp = struct {
1261 params: ArrayList(&Node),1076 base: Node,
1262 async_attr: ?&NodeAsyncAttribute,1077 op_token: Token,
1263 };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 {1098 const AddrOfInfo = struct {
1266 start: &Node,1099 align_expr: ?&Node,
1267 end: ?&Node,1100 bit_offset_start_token: ?Token,
1268 };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 {1106 pub fn iterate(self: &PrefixOp, index: usize) ?&Node {
1271 var i = index;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;1139 if (i < 1) return self.rhs;
1274 i -= 1;1140 i -= 1;
12751141
1276 switch (self.op) {1142 return null;
1277 SuffixOp.Call => |call_info| {1143 }
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;
12881144
1289 if (range.end) |end| {1145 pub fn firstToken(self: &PrefixOp) Token {
1290 if (i < 1) return end;1146 return self.op_token;
1291 i -= 1;1147 }
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 }
13061148
1307 pub fn firstToken(self: &NodeSuffixOp) Token {1149 pub fn lastToken(self: &PrefixOp) Token {
1308 return self.lhs.firstToken();1150 return self.rhs.lastToken();
1309 }1151 }
1152 };
13101153
1311 pub fn lastToken(self: &NodeSuffixOp) Token {1154 pub const FieldInitializer = struct {
1312 return self.rtoken;1155 base: Node,
1313 }1156 period_token: Token,
1314};1157 name_token: Token,
1158 expr: &Node,
13151159
1316pub const NodeGroupedExpression = struct {1160 pub fn iterate(self: &FieldInitializer, index: usize) ?&Node {
1317 base: Node,1161 var i = index;
1318 lparen: Token,
1319 expr: &Node,
1320 rparen: Token,
13211162
1322 pub fn iterate(self: &NodeGroupedExpression, index: usize) ?&Node {1163 if (i < 1) return self.expr;
1323 var i = index;1164 i -= 1;
13241165
1325 if (i < 1) return self.expr;1166 return null;
1326 i -= 1;1167 }
13271168
1328 return null;1169 pub fn firstToken(self: &FieldInitializer) Token {
1329 }1170 return self.period_token;
1171 }
13301172
1331 pub fn firstToken(self: &NodeGroupedExpression) Token {1173 pub fn lastToken(self: &FieldInitializer) Token {
1332 return self.lparen;1174 return self.expr.lastToken();
1333 }1175 }
1176 };
13341177
1335 pub fn lastToken(self: &NodeGroupedExpression) Token {1178 pub const SuffixOp = struct {
1336 return self.rparen;1179 base: Node,
1337 }1180 lhs: &Node,
1338};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 {1197 const SliceRange = struct {
1341 base: Node,1198 start: &Node,
1342 ltoken: Token,1199 end: ?&Node,
1343 kind: Kind,1200 };
1344 rhs: ?&Node,
13451201
1346 const Kind = union(enum) {1202 pub fn iterate(self: &SuffixOp, index: usize) ?&Node {
1347 Break: ?&Node,1203 var i = index;
1348 Continue: ?&Node,
1349 Return,
1350 };
13511204
1352 pub fn iterate(self: &NodeControlFlowExpression, index: usize) ?&Node {1205 if (i < 1) return self.lhs;
1353 var i = index;1206 i -= 1;
13541207
1355 switch (self.kind) {1208 switch (self.op) {
1356 Kind.Break => |maybe_label| {1209 Op.Call => |call_info| {
1357 if (maybe_label) |label| {1210 if (i < call_info.params.len) return call_info.params.at(i);
1358 if (i < 1) return label;1211 i -= call_info.params.len;
1212 },
1213 Op.ArrayAccess => |index_expr| {
1214 if (i < 1) return index_expr;
1359 i -= 1;1215 i -= 1;
1360 }1216 },
1361 },1217 Op.Slice => |range| {
1362 Kind.Continue => |maybe_label| {1218 if (i < 1) return range.start;
1363 if (maybe_label) |label| {
1364 if (i < 1) return label;
1365 i -= 1;1219 i -= 1;
1366 }1220
1367 },1221 if (range.end) |end| {
1368 Kind.Return => {},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;
1369 }1237 }
13701238
1371 if (self.rhs) |rhs| {1239 pub fn firstToken(self: &SuffixOp) Token {
1372 if (i < 1) return rhs;1240 return self.lhs.firstToken();
1373 i -= 1;
1374 }1241 }
13751242
1376 return null;1243 pub fn lastToken(self: &SuffixOp) Token {
1377 }1244 return self.rtoken;
1245 }
1246 };
13781247
1379 pub fn firstToken(self: &NodeControlFlowExpression) Token {1248 pub const GroupedExpression = struct {
1380 return self.ltoken;1249 base: Node,
1381 }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 {1257 if (i < 1) return self.expr;
1384 if (self.rhs) |rhs| {1258 i -= 1;
1385 return rhs.lastToken();1259
1260 return null;
1386 }1261 }
13871262
1388 switch (self.kind) {1263 pub fn firstToken(self: &GroupedExpression) Token {
1389 Kind.Break => |maybe_label| {1264 return self.lparen;
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,
1400 }1265 }
14011266
1402 return self.ltoken;1267 pub fn lastToken(self: &GroupedExpression) Token {
1403 }1268 return self.rparen;
1404};1269 }
1270 };
14051271
1406pub const NodeSuspend = struct {1272 pub const ControlFlowExpression = struct {
1407 base: Node,1273 base: Node,
1408 suspend_token: Token,1274 ltoken: Token,
1409 payload: ?&Node,1275 kind: Kind,
1410 body: ?&Node,1276 rhs: ?&Node,
14111277
1412 pub fn iterate(self: &NodeSuspend, index: usize) ?&Node {1278 const Kind = union(enum) {
1413 var i = index;1279 Break: ?&Node,
1280 Continue: ?&Node,
1281 Return,
1282 };
14141283
1415 if (self.payload) |payload| {1284 pub fn iterate(self: &ControlFlowExpression, index: usize) ?&Node {
1416 if (i < 1) return payload;1285 var i = index;
1417 i -= 1;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;
1418 }1309 }
14191310
1420 if (self.body) |body| {1311 pub fn firstToken(self: &ControlFlowExpression) Token {
1421 if (i < 1) return body;1312 return self.ltoken;
1422 i -= 1;
1423 }1313 }
14241314
1425 return null;1315 pub fn lastToken(self: &ControlFlowExpression) Token {
1426 }1316 if (self.rhs) |rhs| {
1317 return rhs.lastToken();
1318 }
14271319
1428 pub fn firstToken(self: &NodeSuspend) Token {1320 switch (self.kind) {
1429 return self.suspend_token;1321 Kind.Break => |maybe_label| {
1430 }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 {1334 return self.ltoken;
1433 if (self.body) |body| {
1434 return body.lastToken();
1435 }1335 }
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| {1352 if (self.body) |body| {
1438 return payload.lastToken();1353 if (i < 1) return body;
1354 i -= 1;
1355 }
1356
1357 return null;
1439 }1358 }
14401359
1441 return self.suspend_token;1360 pub fn firstToken(self: &Suspend) Token {
1442 }1361 return self.suspend_token;
1443};1362 }
14441363
1445pub const NodeIntegerLiteral = struct {1364 pub fn lastToken(self: &Suspend) Token {
1446 base: Node,1365 if (self.body) |body| {
1447 token: Token,1366 return body.lastToken();
1367 }
14481368
1449 pub fn iterate(self: &NodeIntegerLiteral, index: usize) ?&Node {1369 if (self.payload) |payload| {
1450 return null;1370 return payload.lastToken();
1451 }1371 }
14521372
1453 pub fn firstToken(self: &NodeIntegerLiteral) Token {1373 return self.suspend_token;
1454 return self.token;1374 }
1455 }1375 };
14561376
1457 pub fn lastToken(self: &NodeIntegerLiteral) Token {1377 pub const IntegerLiteral = struct {
1458 return self.token;1378 base: Node,
1459 }1379 token: Token,
1460};
14611380
1462pub const NodeFloatLiteral = struct {1381 pub fn iterate(self: &IntegerLiteral, index: usize) ?&Node {
1463 base: Node,1382 return null;
1464 token: Token,1383 }
14651384
1466 pub fn iterate(self: &NodeFloatLiteral, index: usize) ?&Node {1385 pub fn firstToken(self: &IntegerLiteral) Token {
1467 return null;1386 return self.token;
1468 }1387 }
14691388
1470 pub fn firstToken(self: &NodeFloatLiteral) Token {1389 pub fn lastToken(self: &IntegerLiteral) Token {
1471 return self.token;1390 return self.token;
1472 }1391 }
1392 };
14731393
1474 pub fn lastToken(self: &NodeFloatLiteral) Token {1394 pub const FloatLiteral = struct {
1475 return self.token;1395 base: Node,
1476 }1396 token: Token,
1477};
14781397
1479pub const NodeBuiltinCall = struct {1398 pub fn iterate(self: &FloatLiteral, index: usize) ?&Node {
1480 base: Node,1399 return null;
1481 builtin_token: Token,1400 }
1482 params: ArrayList(&Node),
1483 rparen_token: Token,
14841401
1485 pub fn iterate(self: &NodeBuiltinCall, index: usize) ?&Node {1402 pub fn firstToken(self: &FloatLiteral) Token {
1486 var i = index;1403 return self.token;
1404 }
14871405
1488 if (i < self.params.len) return self.params.at(i);1406 pub fn lastToken(self: &FloatLiteral) Token {
1489 i -= self.params.len;1407 return self.token;
1408 }
1409 };
14901410
1491 return null;1411 pub const BuiltinCall = struct {
1492 }1412 base: Node,
1413 builtin_token: Token,
1414 params: ArrayList(&Node),
1415 rparen_token: Token,
14931416
1494 pub fn firstToken(self: &NodeBuiltinCall) Token {1417 pub fn iterate(self: &BuiltinCall, index: usize) ?&Node {
1495 return self.builtin_token;1418 var i = index;
1496 }
14971419
1498 pub fn lastToken(self: &NodeBuiltinCall) Token {1420 if (i < self.params.len) return self.params.at(i);
1499 return self.rparen_token;1421 i -= self.params.len;
1500 }
1501};
15021422
1503pub const NodeStringLiteral = struct {1423 return null;
1504 base: Node,1424 }
1505 token: Token,
15061425
1507 pub fn iterate(self: &NodeStringLiteral, index: usize) ?&Node {1426 pub fn firstToken(self: &BuiltinCall) Token {
1508 return null;1427 return self.builtin_token;
1509 }1428 }
15101429
1511 pub fn firstToken(self: &NodeStringLiteral) Token {1430 pub fn lastToken(self: &BuiltinCall) Token {
1512 return self.token;1431 return self.rparen_token;
1513 }1432 }
1433 };
15141434
1515 pub fn lastToken(self: &NodeStringLiteral) Token {1435 pub const StringLiteral = struct {
1516 return self.token;1436 base: Node,
1517 }1437 token: Token,
1518};
15191438
1520pub const NodeMultilineStringLiteral = struct {1439 pub fn iterate(self: &StringLiteral, index: usize) ?&Node {
1521 base: Node,1440 return null;
1522 tokens: ArrayList(Token),1441 }
15231442
1524 pub fn iterate(self: &NodeMultilineStringLiteral, index: usize) ?&Node {1443 pub fn firstToken(self: &StringLiteral) Token {
1525 return null;1444 return self.token;
1526 }1445 }
15271446
1528 pub fn firstToken(self: &NodeMultilineStringLiteral) Token {1447 pub fn lastToken(self: &StringLiteral) Token {
1529 return self.tokens.at(0);1448 return self.token;
1530 }1449 }
1450 };
15311451
1532 pub fn lastToken(self: &NodeMultilineStringLiteral) Token {1452 pub const MultilineStringLiteral = struct {
1533 return self.tokens.at(self.tokens.len - 1);1453 base: Node,
1534 }1454 tokens: ArrayList(Token),
1535};
15361455
1537pub const NodeCharLiteral = struct {1456 pub fn iterate(self: &MultilineStringLiteral, index: usize) ?&Node {
1538 base: Node,1457 return null;
1539 token: Token,1458 }
15401459
1541 pub fn iterate(self: &NodeCharLiteral, index: usize) ?&Node {1460 pub fn firstToken(self: &MultilineStringLiteral) Token {
1542 return null;1461 return self.tokens.at(0);
1543 }1462 }
15441463
1545 pub fn firstToken(self: &NodeCharLiteral) Token {1464 pub fn lastToken(self: &MultilineStringLiteral) Token {
1546 return self.token;1465 return self.tokens.at(self.tokens.len - 1);
1547 }1466 }
1467 };
15481468
1549 pub fn lastToken(self: &NodeCharLiteral) Token {1469 pub const CharLiteral = struct {
1550 return self.token;1470 base: Node,
1551 }1471 token: Token,
1552};
15531472
1554pub const NodeBoolLiteral = struct {1473 pub fn iterate(self: &CharLiteral, index: usize) ?&Node {
1555 base: Node,1474 return null;
1556 token: Token,1475 }
15571476
1558 pub fn iterate(self: &NodeBoolLiteral, index: usize) ?&Node {1477 pub fn firstToken(self: &CharLiteral) Token {
1559 return null;1478 return self.token;
1560 }1479 }
15611480
1562 pub fn firstToken(self: &NodeBoolLiteral) Token {1481 pub fn lastToken(self: &CharLiteral) Token {
1563 return self.token;1482 return self.token;
1564 }1483 }
1484 };
15651485
1566 pub fn lastToken(self: &NodeBoolLiteral) Token {1486 pub const BoolLiteral = struct {
1567 return self.token;1487 base: Node,
1568 }1488 token: Token,
1569};
15701489
1571pub const NodeNullLiteral = struct {1490 pub fn iterate(self: &BoolLiteral, index: usize) ?&Node {
1572 base: Node,1491 return null;
1573 token: Token,1492 }
15741493
1575 pub fn iterate(self: &NodeNullLiteral, index: usize) ?&Node {1494 pub fn firstToken(self: &BoolLiteral) Token {
1576 return null;1495 return self.token;
1577 }1496 }
15781497
1579 pub fn firstToken(self: &NodeNullLiteral) Token {1498 pub fn lastToken(self: &BoolLiteral) Token {
1580 return self.token;1499 return self.token;
1581 }1500 }
1501 };
15821502
1583 pub fn lastToken(self: &NodeNullLiteral) Token {1503 pub const NullLiteral = struct {
1584 return self.token;1504 base: Node,
1585 }1505 token: Token,
1586};
15871506
1588pub const NodeUndefinedLiteral = struct {1507 pub fn iterate(self: &NullLiteral, index: usize) ?&Node {
1589 base: Node,1508 return null;
1590 token: Token,1509 }
15911510
1592 pub fn iterate(self: &NodeUndefinedLiteral, index: usize) ?&Node {1511 pub fn firstToken(self: &NullLiteral) Token {
1593 return null;1512 return self.token;
1594 }1513 }
15951514
1596 pub fn firstToken(self: &NodeUndefinedLiteral) Token {1515 pub fn lastToken(self: &NullLiteral) Token {
1597 return self.token;1516 return self.token;
1598 }1517 }
1518 };
15991519
1600 pub fn lastToken(self: &NodeUndefinedLiteral) Token {1520 pub const UndefinedLiteral = struct {
1601 return self.token;1521 base: Node,
1602 }1522 token: Token,
1603};
16041523
1605pub const NodeThisLiteral = struct {1524 pub fn iterate(self: &UndefinedLiteral, index: usize) ?&Node {
1606 base: Node,1525 return null;
1607 token: Token,1526 }
16081527
1609 pub fn iterate(self: &NodeThisLiteral, index: usize) ?&Node {1528 pub fn firstToken(self: &UndefinedLiteral) Token {
1610 return null;1529 return self.token;
1611 }1530 }
16121531
1613 pub fn firstToken(self: &NodeThisLiteral) Token {1532 pub fn lastToken(self: &UndefinedLiteral) Token {
1614 return self.token;1533 return self.token;
1615 }1534 }
1535 };
16161536
1617 pub fn lastToken(self: &NodeThisLiteral) Token {1537 pub const ThisLiteral = struct {
1618 return self.token;1538 base: Node,
1619 }1539 token: Token,
1620};
16211540
1622pub const NodeAsmOutput = struct {1541 pub fn iterate(self: &ThisLiteral, index: usize) ?&Node {
1623 base: Node,1542 return null;
1624 symbolic_name: &Node,1543 }
1625 constraint: &Node,
1626 kind: Kind,
16271544
1628 const Kind = union(enum) {1545 pub fn firstToken(self: &ThisLiteral) Token {
1629 Variable: &NodeIdentifier,1546 return self.token;
1630 Return: &Node1547 }
1548
1549 pub fn lastToken(self: &ThisLiteral) Token {
1550 return self.token;
1551 }
1631 };1552 };
16321553
1633 pub fn iterate(self: &NodeAsmOutput, index: usize) ?&Node {1554 pub const AsmOutput = struct {
1634 var i = index;1555 base: Node,
1556 symbolic_name: &Node,
1557 constraint: &Node,
1558 kind: Kind,
16351559
1636 if (i < 1) return self.symbolic_name;1560 const Kind = union(enum) {
1637 i -= 1;1561 Variable: &Identifier,
1562 Return: &Node
1563 };
16381564
1639 if (i < 1) return self.constraint;1565 pub fn iterate(self: &AsmOutput, index: usize) ?&Node {
1640 i -= 1;1566 var i = index;
16411567
1642 switch (self.kind) {1568 if (i < 1) return self.symbolic_name;
1643 Kind.Variable => |variable_name| {1569 i -= 1;
1644 if (i < 1) return &variable_name.base;1570
1645 i -= 1;1571 if (i < 1) return self.constraint;
1646 },1572 i -= 1;
1647 Kind.Return => |return_type| {1573
1648 if (i < 1) return return_type;1574 switch (self.kind) {
1649 i -= 1;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 }
1650 }1583 }
1651 }
16521584
1653 return null;1585 return null;
1654 }1586 }
16551587
1656 pub fn firstToken(self: &NodeAsmOutput) Token {1588 pub fn firstToken(self: &AsmOutput) Token {
1657 return self.symbolic_name.firstToken();1589 return self.symbolic_name.firstToken();
1658 }1590 }
16591591
1660 pub fn lastToken(self: &NodeAsmOutput) Token {1592 pub fn lastToken(self: &AsmOutput) Token {
1661 return switch (self.kind) {1593 return switch (self.kind) {
1662 Kind.Variable => |variable_name| variable_name.lastToken(),1594 Kind.Variable => |variable_name| variable_name.lastToken(),
1663 Kind.Return => |return_type| return_type.lastToken(),1595 Kind.Return => |return_type| return_type.lastToken(),
1664 };1596 };
1665 }1597 }
1666};1598 };
16671599
1668pub const NodeAsmInput = struct {1600 pub const AsmInput = struct {
1669 base: Node,1601 base: Node,
1670 symbolic_name: &Node,1602 symbolic_name: &Node,
1671 constraint: &Node,1603 constraint: &Node,
1672 expr: &Node,1604 expr: &Node,
16731605
1674 pub fn iterate(self: &NodeAsmInput, index: usize) ?&Node {1606 pub fn iterate(self: &AsmInput, index: usize) ?&Node {
1675 var i = index;1607 var i = index;
16761608
1677 if (i < 1) return self.symbolic_name;1609 if (i < 1) return self.symbolic_name;
1678 i -= 1;1610 i -= 1;
16791611
1680 if (i < 1) return self.constraint;1612 if (i < 1) return self.constraint;
1681 i -= 1;1613 i -= 1;
16821614
1683 if (i < 1) return self.expr;1615 if (i < 1) return self.expr;
1684 i -= 1;1616 i -= 1;
16851617
1686 return null;1618 return null;
1687 }1619 }
16881620
1689 pub fn firstToken(self: &NodeAsmInput) Token {1621 pub fn firstToken(self: &AsmInput) Token {
1690 return self.symbolic_name.firstToken();1622 return self.symbolic_name.firstToken();
1691 }1623 }
16921624
1693 pub fn lastToken(self: &NodeAsmInput) Token {1625 pub fn lastToken(self: &AsmInput) Token {
1694 return self.expr.lastToken();1626 return self.expr.lastToken();
1695 }1627 }
1696};1628 };
16971629
1698pub const NodeAsm = struct {1630 pub const Asm = struct {
1699 base: Node,1631 base: Node,
1700 asm_token: Token,1632 asm_token: Token,
1701 volatile_token: ?Token,1633 volatile_token: ?Token,
1702 template: &Node,1634 template: &Node,
1703 //tokens: ArrayList(AsmToken),1635 //tokens: ArrayList(AsmToken),
1704 outputs: ArrayList(&NodeAsmOutput),1636 outputs: ArrayList(&AsmOutput),
1705 inputs: ArrayList(&NodeAsmInput),1637 inputs: ArrayList(&AsmInput),
1706 cloppers: ArrayList(&Node),1638 cloppers: ArrayList(&Node),
1707 rparen: Token,1639 rparen: Token,
17081640
1709 pub fn iterate(self: &NodeAsm, index: usize) ?&Node {1641 pub fn iterate(self: &Asm, index: usize) ?&Node {
1710 var i = index;1642 var i = index;
17111643
1712 if (i < self.outputs.len) return &self.outputs.at(index).base;1644 if (i < self.outputs.len) return &self.outputs.at(index).base;
1713 i -= self.outputs.len;1645 i -= self.outputs.len;
17141646
1715 if (i < self.inputs.len) return &self.inputs.at(index).base;1647 if (i < self.inputs.len) return &self.inputs.at(index).base;
1716 i -= self.inputs.len;1648 i -= self.inputs.len;
17171649
1718 if (i < self.cloppers.len) return self.cloppers.at(index);1650 if (i < self.cloppers.len) return self.cloppers.at(index);
1719 i -= self.cloppers.len;1651 i -= self.cloppers.len;
17201652
1721 return null;1653 return null;
1722 }1654 }
17231655
1724 pub fn firstToken(self: &NodeAsm) Token {1656 pub fn firstToken(self: &Asm) Token {
1725 return self.asm_token;1657 return self.asm_token;
1726 }1658 }
17271659
1728 pub fn lastToken(self: &NodeAsm) Token {1660 pub fn lastToken(self: &Asm) Token {
1729 return self.rparen;1661 return self.rparen;
1730 }1662 }
1731};1663 };
17321664
1733pub const NodeUnreachable = struct {1665 pub const Unreachable = struct {
1734 base: Node,1666 base: Node,
1735 token: Token,1667 token: Token,
17361668
1737 pub fn iterate(self: &NodeUnreachable, index: usize) ?&Node {1669 pub fn iterate(self: &Unreachable, index: usize) ?&Node {
1738 return null;1670 return null;
1739 }1671 }
17401672
1741 pub fn firstToken(self: &NodeUnreachable) Token {1673 pub fn firstToken(self: &Unreachable) Token {
1742 return self.token;1674 return self.token;
1743 }1675 }
17441676
1745 pub fn lastToken(self: &NodeUnreachable) Token {1677 pub fn lastToken(self: &Unreachable) Token {
1746 return self.token;1678 return self.token;
1747 }1679 }
1748};1680 };
17491681
1750pub const NodeErrorType = struct {1682 pub const ErrorType = struct {
1751 base: Node,1683 base: Node,
1752 token: Token,1684 token: Token,
17531685
1754 pub fn iterate(self: &NodeErrorType, index: usize) ?&Node {1686 pub fn iterate(self: &ErrorType, index: usize) ?&Node {
1755 return null;1687 return null;
1756 }1688 }
17571689
1758 pub fn firstToken(self: &NodeErrorType) Token {1690 pub fn firstToken(self: &ErrorType) Token {
1759 return self.token;1691 return self.token;
1760 }1692 }
17611693
1762 pub fn lastToken(self: &NodeErrorType) Token {1694 pub fn lastToken(self: &ErrorType) Token {
1763 return self.token;1695 return self.token;
1764 }1696 }
1765};1697 };
17661698
1767pub const NodeVarType = struct {1699 pub const VarType = struct {
1768 base: Node,1700 base: Node,
1769 token: Token,1701 token: Token,
17701702
1771 pub fn iterate(self: &NodeVarType, index: usize) ?&Node {1703 pub fn iterate(self: &VarType, index: usize) ?&Node {
1772 return null;1704 return null;
1773 }1705 }
17741706
1775 pub fn firstToken(self: &NodeVarType) Token {1707 pub fn firstToken(self: &VarType) Token {
1776 return self.token;1708 return self.token;
1777 }1709 }
17781710
1779 pub fn lastToken(self: &NodeVarType) Token {1711 pub fn lastToken(self: &VarType) Token {
1780 return self.token;1712 return self.token;
1781 }1713 }
1782};1714 };
17831715
1784pub const NodeLineComment = struct {1716 pub const LineComment = struct {
1785 base: Node,1717 base: Node,
1786 lines: ArrayList(Token),1718 lines: ArrayList(Token),
17871719
1788 pub fn iterate(self: &NodeLineComment, index: usize) ?&Node {1720 pub fn iterate(self: &LineComment, index: usize) ?&Node {
1789 return null;1721 return null;
1790 }1722 }
17911723
1792 pub fn firstToken(self: &NodeLineComment) Token {1724 pub fn firstToken(self: &LineComment) Token {
1793 return self.lines.at(0);1725 return self.lines.at(0);
1794 }1726 }
17951727
1796 pub fn lastToken(self: &NodeLineComment) Token {1728 pub fn lastToken(self: &LineComment) Token {
1797 return self.lines.at(self.lines.len - 1);1729 return self.lines.at(self.lines.len - 1);
1798 }1730 }
1799};1731 };
18001732
1801pub const NodeTestDecl = struct {1733 pub const TestDecl = struct {
1802 base: Node,1734 base: Node,
1803 test_token: Token,1735 comments: ?&LineComment,
1804 name: &Node,1736 test_token: Token,
1805 body_node: &Node,1737 name: &Node,
1738 body_node: &Node,
18061739
1807 pub fn iterate(self: &NodeTestDecl, index: usize) ?&Node {1740 pub fn iterate(self: &TestDecl, index: usize) ?&Node {
1808 var i = index;1741 var i = index;
18091742
1810 if (i < 1) return self.body_node;1743 if (i < 1) return self.body_node;
1811 i -= 1;1744 i -= 1;
18121745
1813 return null;1746 return null;
1814 }1747 }
18151748
1816 pub fn firstToken(self: &NodeTestDecl) Token {1749 pub fn firstToken(self: &TestDecl) Token {
1817 return self.test_token;1750 return self.test_token;
1818 }1751 }
18191752
1820 pub fn lastToken(self: &NodeTestDecl) Token {1753 pub fn lastToken(self: &TestDecl) Token {
1821 return self.body_node.lastToken();1754 return self.body_node.lastToken();
1822 }1755 }
1756 };
1823};1757};
1758
std/zig/parser.zig+502-473
...@@ -18,10 +18,10 @@ pub const Parser = struct {...@@ -18,10 +18,10 @@ pub const Parser = struct {
18 put_back_tokens: [2]Token,18 put_back_tokens: [2]Token,
19 put_back_count: usize,19 put_back_count: usize,
20 source_file_name: []const u8,20 source_file_name: []const u8,
21 pending_line_comment_node: ?&ast.NodeLineComment,21 pending_line_comment_node: ?&ast.Node.LineComment,
2222
23 pub const Tree = struct {23 pub const Tree = struct {
24 root_node: &ast.NodeRoot,24 root_node: &ast.Node.Root,
25 arena_allocator: std.heap.ArenaAllocator,25 arena_allocator: std.heap.ArenaAllocator,
2626
27 pub fn deinit(self: &Tree) void {27 pub fn deinit(self: &Tree) void {
...@@ -66,22 +66,24 @@ pub const Parser = struct {...@@ -66,22 +66,24 @@ pub const Parser = struct {
66 extern_export_token: ?Token,66 extern_export_token: ?Token,
67 lib_name: ?&ast.Node,67 lib_name: ?&ast.Node,
68 list: &ArrayList(&ast.Node),68 list: &ArrayList(&ast.Node),
69 comments: ?&ast.Node.LineComment,
69 };70 };
7071
71 const TopLevelExternOrFieldCtx = struct {72 const TopLevelExternOrFieldCtx = struct {
72 visib_token: Token,73 visib_token: Token,
73 container_decl: &ast.NodeContainerDecl,74 container_decl: &ast.Node.ContainerDecl,
74 };75 };
7576
76 const ExternTypeCtx = struct {77 const ExternTypeCtx = struct {
77 opt_ctx: OptionalCtx,78 opt_ctx: OptionalCtx,
78 extern_token: Token,79 extern_token: Token,
80 comments: ?&ast.Node.LineComment,
79 };81 };
8082
81 const ContainerKindCtx = struct {83 const ContainerKindCtx = struct {
82 opt_ctx: OptionalCtx,84 opt_ctx: OptionalCtx,
83 ltoken: Token,85 ltoken: Token,
84 layout: ast.NodeContainerDecl.Layout,86 layout: ast.Node.ContainerDecl.Layout,
85 };87 };
8688
87 const ExpectTokenSave = struct {89 const ExpectTokenSave = struct {
...@@ -132,7 +134,7 @@ pub const Parser = struct {...@@ -132,7 +134,7 @@ pub const Parser = struct {
132134
133 const AsyncEndCtx = struct {135 const AsyncEndCtx = struct {
134 ctx: OptionalCtx,136 ctx: OptionalCtx,
135 attribute: &ast.NodeAsyncAttribute,137 attribute: &ast.Node.AsyncAttribute,
136 };138 };
137139
138 const ErrorTypeOrSetDeclCtx = struct {140 const ErrorTypeOrSetDeclCtx = struct {
...@@ -141,13 +143,13 @@ pub const Parser = struct {...@@ -141,13 +143,13 @@ pub const Parser = struct {
141 };143 };
142144
143 const ParamDeclEndCtx = struct {145 const ParamDeclEndCtx = struct {
144 fn_proto: &ast.NodeFnProto,146 fn_proto: &ast.Node.FnProto,
145 param_decl: &ast.NodeParamDecl,147 param_decl: &ast.Node.ParamDecl,
146 };148 };
147149
148 const ComptimeStatementCtx = struct {150 const ComptimeStatementCtx = struct {
149 comptime_token: Token,151 comptime_token: Token,
150 block: &ast.NodeBlock,152 block: &ast.Node.Block,
151 };153 };
152154
153 const OptionalCtx = union(enum) {155 const OptionalCtx = union(enum) {
...@@ -190,24 +192,24 @@ pub const Parser = struct {...@@ -190,24 +192,24 @@ pub const Parser = struct {
190 TopLevelExternOrField: TopLevelExternOrFieldCtx,192 TopLevelExternOrField: TopLevelExternOrFieldCtx,
191193
192 ContainerKind: ContainerKindCtx,194 ContainerKind: ContainerKindCtx,
193 ContainerInitArgStart: &ast.NodeContainerDecl,195 ContainerInitArgStart: &ast.Node.ContainerDecl,
194 ContainerInitArg: &ast.NodeContainerDecl,196 ContainerInitArg: &ast.Node.ContainerDecl,
195 ContainerDecl: &ast.NodeContainerDecl,197 ContainerDecl: &ast.Node.ContainerDecl,
196198
197 VarDecl: VarDeclCtx,199 VarDecl: VarDeclCtx,
198 VarDeclAlign: &ast.NodeVarDecl,200 VarDeclAlign: &ast.Node.VarDecl,
199 VarDeclEq: &ast.NodeVarDecl,201 VarDeclEq: &ast.Node.VarDecl,
200202
201 FnDef: &ast.NodeFnProto,203 FnDef: &ast.Node.FnProto,
202 FnProto: &ast.NodeFnProto,204 FnProto: &ast.Node.FnProto,
203 FnProtoAlign: &ast.NodeFnProto,205 FnProtoAlign: &ast.Node.FnProto,
204 FnProtoReturnType: &ast.NodeFnProto,206 FnProtoReturnType: &ast.Node.FnProto,
205207
206 ParamDecl: &ast.NodeFnProto,208 ParamDecl: &ast.Node.FnProto,
207 ParamDeclAliasOrComptime: &ast.NodeParamDecl,209 ParamDeclAliasOrComptime: &ast.Node.ParamDecl,
208 ParamDeclName: &ast.NodeParamDecl,210 ParamDeclName: &ast.Node.ParamDecl,
209 ParamDeclEnd: ParamDeclEndCtx,211 ParamDeclEnd: ParamDeclEndCtx,
210 ParamDeclComma: &ast.NodeFnProto,212 ParamDeclComma: &ast.Node.FnProto,
211213
212 MaybeLabeledExpression: MaybeLabeledExpressionCtx,214 MaybeLabeledExpression: MaybeLabeledExpressionCtx,
213 LabeledExpression: LabelCtx,215 LabeledExpression: LabelCtx,
...@@ -215,39 +217,39 @@ pub const Parser = struct {...@@ -215,39 +217,39 @@ pub const Parser = struct {
215 While: LoopCtx,217 While: LoopCtx,
216 WhileContinueExpr: &?&ast.Node,218 WhileContinueExpr: &?&ast.Node,
217 For: LoopCtx,219 For: LoopCtx,
218 Else: &?&ast.NodeElse,220 Else: &?&ast.Node.Else,
219221
220 Block: &ast.NodeBlock,222 Block: &ast.Node.Block,
221 Statement: &ast.NodeBlock,223 Statement: &ast.Node.Block,
222 ComptimeStatement: ComptimeStatementCtx,224 ComptimeStatement: ComptimeStatementCtx,
223 Semicolon: &&ast.Node,225 Semicolon: &&ast.Node,
224226
225 AsmOutputItems: &ArrayList(&ast.NodeAsmOutput),227 AsmOutputItems: &ArrayList(&ast.Node.AsmOutput),
226 AsmOutputReturnOrType: &ast.NodeAsmOutput,228 AsmOutputReturnOrType: &ast.Node.AsmOutput,
227 AsmInputItems: &ArrayList(&ast.NodeAsmInput),229 AsmInputItems: &ArrayList(&ast.Node.AsmInput),
228 AsmClopperItems: &ArrayList(&ast.Node),230 AsmClopperItems: &ArrayList(&ast.Node),
229231
230 ExprListItemOrEnd: ExprListCtx,232 ExprListItemOrEnd: ExprListCtx,
231 ExprListCommaOrEnd: ExprListCtx,233 ExprListCommaOrEnd: ExprListCtx,
232 FieldInitListItemOrEnd: ListSave(&ast.NodeFieldInitializer),234 FieldInitListItemOrEnd: ListSave(&ast.Node.FieldInitializer),
233 FieldInitListCommaOrEnd: ListSave(&ast.NodeFieldInitializer),235 FieldInitListCommaOrEnd: ListSave(&ast.Node.FieldInitializer),
234 FieldListCommaOrEnd: &ast.NodeContainerDecl,236 FieldListCommaOrEnd: &ast.Node.ContainerDecl,
235 IdentifierListItemOrEnd: ListSave(&ast.Node),237 IdentifierListItemOrEnd: ListSave(&ast.Node),
236 IdentifierListCommaOrEnd: ListSave(&ast.Node),238 IdentifierListCommaOrEnd: ListSave(&ast.Node),
237 SwitchCaseOrEnd: ListSave(&ast.NodeSwitchCase),239 SwitchCaseOrEnd: ListSave(&ast.Node.SwitchCase),
238 SwitchCaseCommaOrEnd: ListSave(&ast.NodeSwitchCase),240 SwitchCaseCommaOrEnd: ListSave(&ast.Node.SwitchCase),
239 SwitchCaseFirstItem: &ArrayList(&ast.Node),241 SwitchCaseFirstItem: &ArrayList(&ast.Node),
240 SwitchCaseItem: &ArrayList(&ast.Node),242 SwitchCaseItem: &ArrayList(&ast.Node),
241 SwitchCaseItemCommaOrEnd: &ArrayList(&ast.Node),243 SwitchCaseItemCommaOrEnd: &ArrayList(&ast.Node),
242244
243 SuspendBody: &ast.NodeSuspend,245 SuspendBody: &ast.Node.Suspend,
244 AsyncAllocator: &ast.NodeAsyncAttribute,246 AsyncAllocator: &ast.Node.AsyncAttribute,
245 AsyncEnd: AsyncEndCtx,247 AsyncEnd: AsyncEndCtx,
246248
247 ExternType: ExternTypeCtx,249 ExternType: ExternTypeCtx,
248 SliceOrArrayAccess: &ast.NodeSuffixOp,250 SliceOrArrayAccess: &ast.Node.SuffixOp,
249 SliceOrArrayType: &ast.NodePrefixOp,251 SliceOrArrayType: &ast.Node.PrefixOp,
250 AddrOfModifiers: &ast.NodePrefixOp.AddrOfInfo,252 AddrOfModifiers: &ast.Node.PrefixOp.AddrOfInfo,
251253
252 Payload: OptionalCtx,254 Payload: OptionalCtx,
253 PointerPayload: OptionalCtx,255 PointerPayload: OptionalCtx,
...@@ -310,8 +312,8 @@ pub const Parser = struct {...@@ -310,8 +312,8 @@ pub const Parser = struct {
310 errdefer arena_allocator.deinit();312 errdefer arena_allocator.deinit();
311313
312 const arena = &arena_allocator.allocator;314 const arena = &arena_allocator.allocator;
313 const root_node = try self.createNode(arena, ast.NodeRoot,315 const root_node = try self.createNode(arena, ast.Node.Root,
314 ast.NodeRoot {316 ast.Node.Root {
315 .base = undefined,317 .base = undefined,
316 .decls = ArrayList(&ast.Node).init(arena),318 .decls = ArrayList(&ast.Node).init(arena),
317 // initialized when we get the eof token319 // initialized when we get the eof token
...@@ -334,43 +336,19 @@ pub const Parser = struct {...@@ -334,43 +336,19 @@ pub const Parser = struct {
334 // warn("\n");336 // warn("\n");
335 //}337 //}
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
362 // This gives us 1 free append that can't fail339 // This gives us 1 free append that can't fail
363 const state = stack.pop();340 const state = stack.pop();
364341
365 switch (state) {342 switch (state) {
366 State.TopLevel => {343 State.TopLevel => {
344 const comments = try self.eatComments(arena);
367 const token = self.getNextToken();345 const token = self.getNextToken();
368 switch (token.id) {346 switch (token.id) {
369 Token.Id.Keyword_test => {347 Token.Id.Keyword_test => {
370 stack.append(State.TopLevel) catch unreachable;348 stack.append(State.TopLevel) catch unreachable;
371349
372 const block = try self.createNode(arena, ast.NodeBlock,350 const block = try self.createNode(arena, ast.Node.Block,
373 ast.NodeBlock {351 ast.Node.Block {
374 .base = undefined,352 .base = undefined,
375 .label = null,353 .label = null,
376 .lbrace = undefined,354 .lbrace = undefined,
...@@ -378,9 +356,10 @@ pub const Parser = struct {...@@ -378,9 +356,10 @@ pub const Parser = struct {
378 .rbrace = undefined,356 .rbrace = undefined,
379 }357 }
380 );358 );
381 const test_node = try self.createAttachNode(arena, &root_node.decls, ast.NodeTestDecl,359 const test_node = try self.createAttachNode(arena, &root_node.decls, ast.Node.TestDecl,
382 ast.NodeTestDecl {360 ast.Node.TestDecl {
383 .base = undefined,361 .base = undefined,
362 .comments = comments,
384 .test_token = token,363 .test_token = token,
385 .name = undefined,364 .name = undefined,
386 .body_node = &block.base,365 .body_node = &block.base,
...@@ -413,8 +392,8 @@ pub const Parser = struct {...@@ -413,8 +392,8 @@ pub const Parser = struct {
413 continue;392 continue;
414 },393 },
415 Token.Id.Keyword_comptime => {394 Token.Id.Keyword_comptime => {
416 const block = try self.createNode(arena, ast.NodeBlock,395 const block = try self.createNode(arena, ast.Node.Block,
417 ast.NodeBlock {396 ast.Node.Block {
418 .base = undefined,397 .base = undefined,
419 .label = null,398 .label = null,
420 .lbrace = undefined,399 .lbrace = undefined,
...@@ -422,8 +401,8 @@ pub const Parser = struct {...@@ -422,8 +401,8 @@ pub const Parser = struct {
422 .rbrace = undefined,401 .rbrace = undefined,
423 }402 }
424 );403 );
425 const node = try self.createAttachNode(arena, &root_node.decls, ast.NodeComptime,404 const node = try self.createAttachNode(arena, &root_node.decls, ast.Node.Comptime,
426 ast.NodeComptime {405 ast.Node.Comptime {
427 .base = undefined,406 .base = undefined,
428 .comptime_token = token,407 .comptime_token = token,
429 .expr = &block.base,408 .expr = &block.base,
...@@ -506,6 +485,7 @@ pub const Parser = struct {...@@ -506,6 +485,7 @@ pub const Parser = struct {
506 continue;485 continue;
507 },486 },
508 State.TopLevelDecl => |ctx| {487 State.TopLevelDecl => |ctx| {
488 const comments = try self.eatComments(arena);
509 const token = self.getNextToken();489 const token = self.getNextToken();
510 switch (token.id) {490 switch (token.id) {
511 Token.Id.Keyword_use => {491 Token.Id.Keyword_use => {
...@@ -513,8 +493,8 @@ pub const Parser = struct {...@@ -513,8 +493,8 @@ pub const Parser = struct {
513 return self.parseError(token, "Invalid token {}", @tagName((??ctx.extern_export_inline_token).id));493 return self.parseError(token, "Invalid token {}", @tagName((??ctx.extern_export_inline_token).id));
514 }494 }
515495
516 const node = try self.createAttachNode(arena, ctx.decls, ast.NodeUse,496 const node = try self.createAttachNode(arena, ctx.decls, ast.Node.Use,
517 ast.NodeUse {497 ast.Node.Use {
518 .base = undefined,498 .base = undefined,
519 .visib_token = ctx.visib_token,499 .visib_token = ctx.visib_token,
520 .expr = undefined,500 .expr = undefined,
...@@ -539,6 +519,7 @@ pub const Parser = struct {...@@ -539,6 +519,7 @@ pub const Parser = struct {
539519
540 stack.append(State {520 stack.append(State {
541 .VarDecl = VarDeclCtx {521 .VarDecl = VarDeclCtx {
522 .comments = comments,
542 .visib_token = ctx.visib_token,523 .visib_token = ctx.visib_token,
543 .lib_name = ctx.lib_name,524 .lib_name = ctx.lib_name,
544 .comptime_token = null,525 .comptime_token = null,
...@@ -551,9 +532,10 @@ pub const Parser = struct {...@@ -551,9 +532,10 @@ pub const Parser = struct {
551 },532 },
552 Token.Id.Keyword_fn, Token.Id.Keyword_nakedcc,533 Token.Id.Keyword_fn, Token.Id.Keyword_nakedcc,
553 Token.Id.Keyword_stdcallcc, Token.Id.Keyword_async => {534 Token.Id.Keyword_stdcallcc, Token.Id.Keyword_async => {
554 const fn_proto = try self.createAttachNode(arena, ctx.decls, ast.NodeFnProto,535 const fn_proto = try self.createAttachNode(arena, ctx.decls, ast.Node.FnProto,
555 ast.NodeFnProto {536 ast.Node.FnProto {
556 .base = undefined,537 .base = undefined,
538 .comments = comments,
557 .visib_token = ctx.visib_token,539 .visib_token = ctx.visib_token,
558 .name_token = null,540 .name_token = null,
559 .fn_token = undefined,541 .fn_token = undefined,
...@@ -583,8 +565,8 @@ pub const Parser = struct {...@@ -583,8 +565,8 @@ pub const Parser = struct {
583 continue;565 continue;
584 },566 },
585 Token.Id.Keyword_async => {567 Token.Id.Keyword_async => {
586 const async_node = try self.createNode(arena, ast.NodeAsyncAttribute,568 const async_node = try self.createNode(arena, ast.Node.AsyncAttribute,
587 ast.NodeAsyncAttribute {569 ast.Node.AsyncAttribute {
588 .base = undefined,570 .base = undefined,
589 .async_token = token,571 .async_token = token,
590 .allocator_type = null,572 .allocator_type = null,
...@@ -616,9 +598,9 @@ pub const Parser = struct {...@@ -616,9 +598,9 @@ pub const Parser = struct {
616 },598 },
617 State.TopLevelExternOrField => |ctx| {599 State.TopLevelExternOrField => |ctx| {
618 if (self.eatToken(Token.Id.Identifier)) |identifier| {600 if (self.eatToken(Token.Id.Identifier)) |identifier| {
619 std.debug.assert(ctx.container_decl.kind == ast.NodeContainerDecl.Kind.Struct);601 std.debug.assert(ctx.container_decl.kind == ast.Node.ContainerDecl.Kind.Struct);
620 const node = try self.createAttachNode(arena, &ctx.container_decl.fields_and_decls, ast.NodeStructField,602 const node = try self.createAttachNode(arena, &ctx.container_decl.fields_and_decls, ast.Node.StructField,
621 ast.NodeStructField {603 ast.Node.StructField {
622 .base = undefined,604 .base = undefined,
623 .visib_token = ctx.visib_token,605 .visib_token = ctx.visib_token,
624 .name_token = identifier,606 .name_token = identifier,
...@@ -647,15 +629,15 @@ pub const Parser = struct {...@@ -647,15 +629,15 @@ pub const Parser = struct {
647629
648 State.ContainerKind => |ctx| {630 State.ContainerKind => |ctx| {
649 const token = self.getNextToken();631 const token = self.getNextToken();
650 const node = try self.createToCtxNode(arena, ctx.opt_ctx, ast.NodeContainerDecl,632 const node = try self.createToCtxNode(arena, ctx.opt_ctx, ast.Node.ContainerDecl,
651 ast.NodeContainerDecl {633 ast.Node.ContainerDecl {
652 .base = undefined,634 .base = undefined,
653 .ltoken = ctx.ltoken,635 .ltoken = ctx.ltoken,
654 .layout = ctx.layout,636 .layout = ctx.layout,
655 .kind = switch (token.id) {637 .kind = switch (token.id) {
656 Token.Id.Keyword_struct => ast.NodeContainerDecl.Kind.Struct,638 Token.Id.Keyword_struct => ast.Node.ContainerDecl.Kind.Struct,
657 Token.Id.Keyword_union => ast.NodeContainerDecl.Kind.Union,639 Token.Id.Keyword_union => ast.Node.ContainerDecl.Kind.Union,
658 Token.Id.Keyword_enum => ast.NodeContainerDecl.Kind.Enum,640 Token.Id.Keyword_enum => ast.Node.ContainerDecl.Kind.Enum,
659 else => {641 else => {
660 return self.parseError(token, "expected {}, {} or {}, found {}",642 return self.parseError(token, "expected {}, {} or {}, found {}",
661 @tagName(Token.Id.Keyword_struct),643 @tagName(Token.Id.Keyword_struct),
...@@ -664,7 +646,7 @@ pub const Parser = struct {...@@ -664,7 +646,7 @@ pub const Parser = struct {
664 @tagName(token.id));646 @tagName(token.id));
665 },647 },
666 },648 },
667 .init_arg_expr = ast.NodeContainerDecl.InitArg.None,649 .init_arg_expr = ast.Node.ContainerDecl.InitArg.None,
668 .fields_and_decls = ArrayList(&ast.Node).init(arena),650 .fields_and_decls = ArrayList(&ast.Node).init(arena),
669 .rbrace_token = undefined,651 .rbrace_token = undefined,
670 }652 }
...@@ -690,11 +672,11 @@ pub const Parser = struct {...@@ -690,11 +672,11 @@ pub const Parser = struct {
690 const init_arg_token = self.getNextToken();672 const init_arg_token = self.getNextToken();
691 switch (init_arg_token.id) {673 switch (init_arg_token.id) {
692 Token.Id.Keyword_enum => {674 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;
694 },676 },
695 else => {677 else => {
696 self.putBackToken(init_arg_token);678 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 };
698 stack.append(State { .Expression = OptionalCtx { .Required = &container_decl.init_arg_expr.Type } }) catch unreachable;680 stack.append(State { .Expression = OptionalCtx { .Required = &container_decl.init_arg_expr.Type } }) catch unreachable;
699 },681 },
700 }682 }
...@@ -705,9 +687,9 @@ pub const Parser = struct {...@@ -705,9 +687,9 @@ pub const Parser = struct {
705 switch (token.id) {687 switch (token.id) {
706 Token.Id.Identifier => {688 Token.Id.Identifier => {
707 switch (container_decl.kind) {689 switch (container_decl.kind) {
708 ast.NodeContainerDecl.Kind.Struct => {690 ast.Node.ContainerDecl.Kind.Struct => {
709 const node = try self.createAttachNode(arena, &container_decl.fields_and_decls, ast.NodeStructField,691 const node = try self.createAttachNode(arena, &container_decl.fields_and_decls, ast.Node.StructField,
710 ast.NodeStructField {692 ast.Node.StructField {
711 .base = undefined,693 .base = undefined,
712 .visib_token = null,694 .visib_token = null,
713 .name_token = token,695 .name_token = token,
...@@ -720,9 +702,9 @@ pub const Parser = struct {...@@ -720,9 +702,9 @@ pub const Parser = struct {
720 try stack.append(State { .ExpectToken = Token.Id.Colon });702 try stack.append(State { .ExpectToken = Token.Id.Colon });
721 continue;703 continue;
722 },704 },
723 ast.NodeContainerDecl.Kind.Union => {705 ast.Node.ContainerDecl.Kind.Union => {
724 const node = try self.createAttachNode(arena, &container_decl.fields_and_decls, ast.NodeUnionTag,706 const node = try self.createAttachNode(arena, &container_decl.fields_and_decls, ast.Node.UnionTag,
725 ast.NodeUnionTag {707 ast.Node.UnionTag {
726 .base = undefined,708 .base = undefined,
727 .name_token = token,709 .name_token = token,
728 .type_expr = null,710 .type_expr = null,
...@@ -734,9 +716,9 @@ pub const Parser = struct {...@@ -734,9 +716,9 @@ pub const Parser = struct {
734 try stack.append(State { .IfToken = Token.Id.Colon });716 try stack.append(State { .IfToken = Token.Id.Colon });
735 continue;717 continue;
736 },718 },
737 ast.NodeContainerDecl.Kind.Enum => {719 ast.Node.ContainerDecl.Kind.Enum => {
738 const node = try self.createAttachNode(arena, &container_decl.fields_and_decls, ast.NodeEnumTag,720 const node = try self.createAttachNode(arena, &container_decl.fields_and_decls, ast.Node.EnumTag,
739 ast.NodeEnumTag {721 ast.Node.EnumTag {
740 .base = undefined,722 .base = undefined,
741 .name_token = token,723 .name_token = token,
742 .value = null,724 .value = null,
...@@ -752,7 +734,7 @@ pub const Parser = struct {...@@ -752,7 +734,7 @@ pub const Parser = struct {
752 },734 },
753 Token.Id.Keyword_pub => {735 Token.Id.Keyword_pub => {
754 switch (container_decl.kind) {736 switch (container_decl.kind) {
755 ast.NodeContainerDecl.Kind.Struct => {737 ast.Node.ContainerDecl.Kind.Struct => {
756 try stack.append(State {738 try stack.append(State {
757 .TopLevelExternOrField = TopLevelExternOrFieldCtx {739 .TopLevelExternOrField = TopLevelExternOrFieldCtx {
758 .visib_token = token,740 .visib_token = token,
...@@ -809,9 +791,10 @@ pub const Parser = struct {...@@ -809,9 +791,10 @@ pub const Parser = struct {
809791
810792
811 State.VarDecl => |ctx| {793 State.VarDecl => |ctx| {
812 const var_decl = try self.createAttachNode(arena, ctx.list, ast.NodeVarDecl,794 const var_decl = try self.createAttachNode(arena, ctx.list, ast.Node.VarDecl,
813 ast.NodeVarDecl {795 ast.Node.VarDecl {
814 .base = undefined,796 .base = undefined,
797 .comments = ctx.comments,
815 .visib_token = ctx.visib_token,798 .visib_token = ctx.visib_token,
816 .mut_token = ctx.mut_token,799 .mut_token = ctx.mut_token,
817 .comptime_token = ctx.comptime_token,800 .comptime_token = ctx.comptime_token,
...@@ -881,8 +864,8 @@ pub const Parser = struct {...@@ -881,8 +864,8 @@ pub const Parser = struct {
881 const token = self.getNextToken();864 const token = self.getNextToken();
882 switch(token.id) {865 switch(token.id) {
883 Token.Id.LBrace => {866 Token.Id.LBrace => {
884 const block = try self.createNode(arena, ast.NodeBlock,867 const block = try self.createNode(arena, ast.Node.Block,
885 ast.NodeBlock {868 ast.Node.Block {
886 .base = undefined,869 .base = undefined,
887 .label = null,870 .label = null,
888 .lbrace = token,871 .lbrace = token,
...@@ -924,7 +907,7 @@ pub const Parser = struct {...@@ -924,7 +907,7 @@ pub const Parser = struct {
924 const token = self.getNextToken();907 const token = self.getNextToken();
925 switch (token.id) {908 switch (token.id) {
926 Token.Id.Bang => {909 Token.Id.Bang => {
927 fn_proto.return_type = ast.NodeFnProto.ReturnType { .InferErrorSet = undefined };910 fn_proto.return_type = ast.Node.FnProto.ReturnType { .InferErrorSet = undefined };
928 stack.append(State {911 stack.append(State {
929 .TypeExprBegin = OptionalCtx { .Required = &fn_proto.return_type.InferErrorSet },912 .TypeExprBegin = OptionalCtx { .Required = &fn_proto.return_type.InferErrorSet },
930 }) catch unreachable;913 }) catch unreachable;
...@@ -934,15 +917,15 @@ pub const Parser = struct {...@@ -934,15 +917,15 @@ pub const Parser = struct {
934 // TODO: this is a special case. Remove this when #760 is fixed917 // TODO: this is a special case. Remove this when #760 is fixed
935 if (token.id == Token.Id.Keyword_error) {918 if (token.id == Token.Id.Keyword_error) {
936 if (self.isPeekToken(Token.Id.LBrace)) {919 if (self.isPeekToken(Token.Id.LBrace)) {
937 fn_proto.return_type = ast.NodeFnProto.ReturnType {920 fn_proto.return_type = ast.Node.FnProto.ReturnType {
938 .Explicit = &(try self.createLiteral(arena, ast.NodeErrorType, token)).base921 .Explicit = &(try self.createLiteral(arena, ast.Node.ErrorType, token)).base
939 };922 };
940 continue;923 continue;
941 }924 }
942 }925 }
943926
944 self.putBackToken(token);927 self.putBackToken(token);
945 fn_proto.return_type = ast.NodeFnProto.ReturnType { .Explicit = undefined };928 fn_proto.return_type = ast.Node.FnProto.ReturnType { .Explicit = undefined };
946 stack.append(State { .TypeExprBegin = OptionalCtx { .Required = &fn_proto.return_type.Explicit }, }) catch unreachable;929 stack.append(State { .TypeExprBegin = OptionalCtx { .Required = &fn_proto.return_type.Explicit }, }) catch unreachable;
947 continue;930 continue;
948 },931 },
...@@ -954,8 +937,8 @@ pub const Parser = struct {...@@ -954,8 +937,8 @@ pub const Parser = struct {
954 if (self.eatToken(Token.Id.RParen)) |_| {937 if (self.eatToken(Token.Id.RParen)) |_| {
955 continue;938 continue;
956 }939 }
957 const param_decl = try self.createAttachNode(arena, &fn_proto.params, ast.NodeParamDecl,940 const param_decl = try self.createAttachNode(arena, &fn_proto.params, ast.Node.ParamDecl,
958 ast.NodeParamDecl {941 ast.Node.ParamDecl {
959 .base = undefined,942 .base = undefined,
960 .comptime_token = null,943 .comptime_token = null,
961 .noalias_token = null,944 .noalias_token = null,
...@@ -1026,15 +1009,15 @@ pub const Parser = struct {...@@ -1026,15 +1009,15 @@ pub const Parser = struct {
1026 continue;1009 continue;
1027 }1010 }
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);
1030 continue;1013 continue;
1031 },1014 },
1032 State.LabeledExpression => |ctx| {1015 State.LabeledExpression => |ctx| {
1033 const token = self.getNextToken();1016 const token = self.getNextToken();
1034 switch (token.id) {1017 switch (token.id) {
1035 Token.Id.LBrace => {1018 Token.Id.LBrace => {
1036 const block = try self.createToCtxNode(arena, ctx.opt_ctx, ast.NodeBlock,1019 const block = try self.createToCtxNode(arena, ctx.opt_ctx, ast.Node.Block,
1037 ast.NodeBlock {1020 ast.Node.Block {
1038 .base = undefined,1021 .base = undefined,
1039 .label = ctx.label,1022 .label = ctx.label,
1040 .lbrace = token,1023 .lbrace = token,
...@@ -1123,8 +1106,8 @@ pub const Parser = struct {...@@ -1123,8 +1106,8 @@ pub const Parser = struct {
1123 }1106 }
1124 },1107 },
1125 State.While => |ctx| {1108 State.While => |ctx| {
1126 const node = try self.createToCtxNode(arena, ctx.opt_ctx, ast.NodeWhile,1109 const node = try self.createToCtxNode(arena, ctx.opt_ctx, ast.Node.While,
1127 ast.NodeWhile {1110 ast.Node.While {
1128 .base = undefined,1111 .base = undefined,
1129 .label = ctx.label,1112 .label = ctx.label,
1130 .inline_token = ctx.inline_token,1113 .inline_token = ctx.inline_token,
...@@ -1153,8 +1136,8 @@ pub const Parser = struct {...@@ -1153,8 +1136,8 @@ pub const Parser = struct {
1153 continue;1136 continue;
1154 },1137 },
1155 State.For => |ctx| {1138 State.For => |ctx| {
1156 const node = try self.createToCtxNode(arena, ctx.opt_ctx, ast.NodeFor,1139 const node = try self.createToCtxNode(arena, ctx.opt_ctx, ast.Node.For,
1157 ast.NodeFor {1140 ast.Node.For {
1158 .base = undefined,1141 .base = undefined,
1159 .label = ctx.label,1142 .label = ctx.label,
1160 .inline_token = ctx.inline_token,1143 .inline_token = ctx.inline_token,
...@@ -1175,8 +1158,8 @@ pub const Parser = struct {...@@ -1175,8 +1158,8 @@ pub const Parser = struct {
1175 },1158 },
1176 State.Else => |dest| {1159 State.Else => |dest| {
1177 if (self.eatToken(Token.Id.Keyword_else)) |else_token| {1160 if (self.eatToken(Token.Id.Keyword_else)) |else_token| {
1178 const node = try self.createNode(arena, ast.NodeElse,1161 const node = try self.createNode(arena, ast.Node.Else,
1179 ast.NodeElse {1162 ast.Node.Else {
1180 .base = undefined,1163 .base = undefined,
1181 .else_token = else_token,1164 .else_token = else_token,
1182 .payload = null,1165 .payload = null,
...@@ -1210,6 +1193,7 @@ pub const Parser = struct {...@@ -1210,6 +1193,7 @@ pub const Parser = struct {
1210 }1193 }
1211 },1194 },
1212 State.Statement => |block| {1195 State.Statement => |block| {
1196 const comments = try self.eatComments(arena);
1213 const token = self.getNextToken();1197 const token = self.getNextToken();
1214 switch (token.id) {1198 switch (token.id) {
1215 Token.Id.Keyword_comptime => {1199 Token.Id.Keyword_comptime => {
...@@ -1224,6 +1208,7 @@ pub const Parser = struct {...@@ -1224,6 +1208,7 @@ pub const Parser = struct {
1224 Token.Id.Keyword_var, Token.Id.Keyword_const => {1208 Token.Id.Keyword_var, Token.Id.Keyword_const => {
1225 stack.append(State {1209 stack.append(State {
1226 .VarDecl = VarDeclCtx {1210 .VarDecl = VarDeclCtx {
1211 .comments = comments,
1227 .visib_token = null,1212 .visib_token = null,
1228 .comptime_token = null,1213 .comptime_token = null,
1229 .extern_export_token = null,1214 .extern_export_token = null,
...@@ -1235,13 +1220,13 @@ pub const Parser = struct {...@@ -1235,13 +1220,13 @@ pub const Parser = struct {
1235 continue;1220 continue;
1236 },1221 },
1237 Token.Id.Keyword_defer, Token.Id.Keyword_errdefer => {1222 Token.Id.Keyword_defer, Token.Id.Keyword_errdefer => {
1238 const node = try self.createAttachNode(arena, &block.statements, ast.NodeDefer,1223 const node = try self.createAttachNode(arena, &block.statements, ast.Node.Defer,
1239 ast.NodeDefer {1224 ast.Node.Defer {
1240 .base = undefined,1225 .base = undefined,
1241 .defer_token = token,1226 .defer_token = token,
1242 .kind = switch (token.id) {1227 .kind = switch (token.id) {
1243 Token.Id.Keyword_defer => ast.NodeDefer.Kind.Unconditional,1228 Token.Id.Keyword_defer => ast.Node.Defer.Kind.Unconditional,
1244 Token.Id.Keyword_errdefer => ast.NodeDefer.Kind.Error,1229 Token.Id.Keyword_errdefer => ast.Node.Defer.Kind.Error,
1245 else => unreachable,1230 else => unreachable,
1246 },1231 },
1247 .expr = undefined,1232 .expr = undefined,
...@@ -1252,8 +1237,8 @@ pub const Parser = struct {...@@ -1252,8 +1237,8 @@ pub const Parser = struct {
1252 continue;1237 continue;
1253 },1238 },
1254 Token.Id.LBrace => {1239 Token.Id.LBrace => {
1255 const inner_block = try self.createAttachNode(arena, &block.statements, ast.NodeBlock,1240 const inner_block = try self.createAttachNode(arena, &block.statements, ast.Node.Block,
1256 ast.NodeBlock {1241 ast.Node.Block {
1257 .base = undefined,1242 .base = undefined,
1258 .label = null,1243 .label = null,
1259 .lbrace = token,1244 .lbrace = token,
...@@ -1274,11 +1259,13 @@ pub const Parser = struct {...@@ -1274,11 +1259,13 @@ pub const Parser = struct {
1274 }1259 }
1275 },1260 },
1276 State.ComptimeStatement => |ctx| {1261 State.ComptimeStatement => |ctx| {
1262 const comments = try self.eatComments(arena);
1277 const token = self.getNextToken();1263 const token = self.getNextToken();
1278 switch (token.id) {1264 switch (token.id) {
1279 Token.Id.Keyword_var, Token.Id.Keyword_const => {1265 Token.Id.Keyword_var, Token.Id.Keyword_const => {
1280 stack.append(State {1266 stack.append(State {
1281 .VarDecl = VarDeclCtx {1267 .VarDecl = VarDeclCtx {
1268 .comments = comments,
1282 .visib_token = null,1269 .visib_token = null,
1283 .comptime_token = ctx.comptime_token,1270 .comptime_token = ctx.comptime_token,
1284 .extern_export_token = null,1271 .extern_export_token = null,
...@@ -1316,8 +1303,8 @@ pub const Parser = struct {...@@ -1316,8 +1303,8 @@ pub const Parser = struct {
1316 continue;1303 continue;
1317 }1304 }
13181305
1319 const node = try self.createNode(arena, ast.NodeAsmOutput,1306 const node = try self.createNode(arena, ast.Node.AsmOutput,
1320 ast.NodeAsmOutput {1307 ast.Node.AsmOutput {
1321 .base = undefined,1308 .base = undefined,
1322 .symbolic_name = undefined,1309 .symbolic_name = undefined,
1323 .constraint = undefined,1310 .constraint = undefined,
...@@ -1340,11 +1327,11 @@ pub const Parser = struct {...@@ -1340,11 +1327,11 @@ pub const Parser = struct {
1340 const token = self.getNextToken();1327 const token = self.getNextToken();
1341 switch (token.id) {1328 switch (token.id) {
1342 Token.Id.Identifier => {1329 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) };
1344 continue;1331 continue;
1345 },1332 },
1346 Token.Id.Arrow => {1333 Token.Id.Arrow => {
1347 node.kind = ast.NodeAsmOutput.Kind { .Return = undefined };1334 node.kind = ast.Node.AsmOutput.Kind { .Return = undefined };
1348 try stack.append(State { .TypeExprBegin = OptionalCtx { .Required = &node.kind.Return } });1335 try stack.append(State { .TypeExprBegin = OptionalCtx { .Required = &node.kind.Return } });
1349 continue;1336 continue;
1350 },1337 },
...@@ -1362,8 +1349,8 @@ pub const Parser = struct {...@@ -1362,8 +1349,8 @@ pub const Parser = struct {
1362 continue;1349 continue;
1363 }1350 }
13641351
1365 const node = try self.createNode(arena, ast.NodeAsmInput,1352 const node = try self.createNode(arena, ast.Node.AsmInput,
1366 ast.NodeAsmInput {1353 ast.Node.AsmInput {
1367 .base = undefined,1354 .base = undefined,
1368 .symbolic_name = undefined,1355 .symbolic_name = undefined,
1369 .constraint = undefined,1356 .constraint = undefined,
...@@ -1415,8 +1402,8 @@ pub const Parser = struct {...@@ -1415,8 +1402,8 @@ pub const Parser = struct {
1415 continue;1402 continue;
1416 }1403 }
14171404
1418 const node = try self.createNode(arena, ast.NodeFieldInitializer,1405 const node = try self.createNode(arena, ast.Node.FieldInitializer,
1419 ast.NodeFieldInitializer {1406 ast.Node.FieldInitializer {
1420 .base = undefined,1407 .base = undefined,
1421 .period_token = undefined,1408 .period_token = undefined,
1422 .name_token = undefined,1409 .name_token = undefined,
...@@ -1485,8 +1472,8 @@ pub const Parser = struct {...@@ -1485,8 +1472,8 @@ pub const Parser = struct {
1485 continue;1472 continue;
1486 }1473 }
14871474
1488 const node = try self.createNode(arena, ast.NodeSwitchCase,1475 const node = try self.createNode(arena, ast.Node.SwitchCase,
1489 ast.NodeSwitchCase {1476 ast.Node.SwitchCase {
1490 .base = undefined,1477 .base = undefined,
1491 .items = ArrayList(&ast.Node).init(arena),1478 .items = ArrayList(&ast.Node).init(arena),
1492 .payload = null,1479 .payload = null,
...@@ -1512,8 +1499,8 @@ pub const Parser = struct {...@@ -1512,8 +1499,8 @@ pub const Parser = struct {
1512 State.SwitchCaseFirstItem => |case_items| {1499 State.SwitchCaseFirstItem => |case_items| {
1513 const token = self.getNextToken();1500 const token = self.getNextToken();
1514 if (token.id == Token.Id.Keyword_else) {1501 if (token.id == Token.Id.Keyword_else) {
1515 const else_node = try self.createAttachNode(arena, case_items, ast.NodeSwitchElse,1502 const else_node = try self.createAttachNode(arena, case_items, ast.Node.SwitchElse,
1516 ast.NodeSwitchElse {1503 ast.Node.SwitchElse {
1517 .base = undefined,1504 .base = undefined,
1518 .token = token,1505 .token = token,
1519 }1506 }
...@@ -1564,24 +1551,24 @@ pub const Parser = struct {...@@ -1564,24 +1551,24 @@ pub const Parser = struct {
15641551
1565 switch (node.id) {1552 switch (node.id) {
1566 ast.Node.Id.FnProto => {1553 ast.Node.Id.FnProto => {
1567 const fn_proto = @fieldParentPtr(ast.NodeFnProto, "base", node);1554 const fn_proto = @fieldParentPtr(ast.Node.FnProto, "base", node);
1568 fn_proto.async_attr = ctx.attribute;1555 fn_proto.async_attr = ctx.attribute;
1569 continue;1556 continue;
1570 },1557 },
1571 ast.Node.Id.SuffixOp => {1558 ast.Node.Id.SuffixOp => {
1572 const suffix_op = @fieldParentPtr(ast.NodeSuffixOp, "base", node);1559 const suffix_op = @fieldParentPtr(ast.Node.SuffixOp, "base", node);
1573 if (suffix_op.op == ast.NodeSuffixOp.SuffixOp.Call) {1560 if (suffix_op.op == ast.Node.SuffixOp.Op.Call) {
1574 suffix_op.op.Call.async_attr = ctx.attribute;1561 suffix_op.op.Call.async_attr = ctx.attribute;
1575 continue;1562 continue;
1576 }1563 }
15771564
1578 return self.parseError(node.firstToken(), "expected {}, found {}.",1565 return self.parseError(node.firstToken(), "expected {}, found {}.",
1579 @tagName(ast.NodeSuffixOp.SuffixOp.Call),1566 @tagName(ast.Node.SuffixOp.Op.Call),
1580 @tagName(suffix_op.op));1567 @tagName(suffix_op.op));
1581 },1568 },
1582 else => {1569 else => {
1583 return self.parseError(node.firstToken(), "expected {} or {}, found {}.",1570 return self.parseError(node.firstToken(), "expected {} or {}, found {}.",
1584 @tagName(ast.NodeSuffixOp.SuffixOp.Call),1571 @tagName(ast.Node.SuffixOp.Op.Call),
1585 @tagName(ast.Node.Id.FnProto),1572 @tagName(ast.Node.Id.FnProto),
1586 @tagName(node.id));1573 @tagName(node.id));
1587 }1574 }
...@@ -1591,9 +1578,10 @@ pub const Parser = struct {...@@ -1591,9 +1578,10 @@ pub const Parser = struct {
15911578
1592 State.ExternType => |ctx| {1579 State.ExternType => |ctx| {
1593 if (self.eatToken(Token.Id.Keyword_fn)) |fn_token| {1580 if (self.eatToken(Token.Id.Keyword_fn)) |fn_token| {
1594 const fn_proto = try self.createToCtxNode(arena, ctx.opt_ctx, ast.NodeFnProto,1581 const fn_proto = try self.createToCtxNode(arena, ctx.opt_ctx, ast.Node.FnProto,
1595 ast.NodeFnProto {1582 ast.Node.FnProto {
1596 .base = undefined,1583 .base = undefined,
1584 .comments = ctx.comments,
1597 .visib_token = null,1585 .visib_token = null,
1598 .name_token = null,1586 .name_token = null,
1599 .fn_token = fn_token,1587 .fn_token = fn_token,
...@@ -1616,7 +1604,7 @@ pub const Parser = struct {...@@ -1616,7 +1604,7 @@ pub const Parser = struct {
1616 .ContainerKind = ContainerKindCtx {1604 .ContainerKind = ContainerKindCtx {
1617 .opt_ctx = ctx.opt_ctx,1605 .opt_ctx = ctx.opt_ctx,
1618 .ltoken = ctx.extern_token,1606 .ltoken = ctx.extern_token,
1619 .layout = ast.NodeContainerDecl.Layout.Extern,1607 .layout = ast.Node.ContainerDecl.Layout.Extern,
1620 },1608 },
1621 }) catch unreachable;1609 }) catch unreachable;
1622 continue;1610 continue;
...@@ -1626,8 +1614,8 @@ pub const Parser = struct {...@@ -1626,8 +1614,8 @@ pub const Parser = struct {
1626 switch (token.id) {1614 switch (token.id) {
1627 Token.Id.Ellipsis2 => {1615 Token.Id.Ellipsis2 => {
1628 const start = node.op.ArrayAccess;1616 const start = node.op.ArrayAccess;
1629 node.op = ast.NodeSuffixOp.SuffixOp {1617 node.op = ast.Node.SuffixOp.Op {
1630 .Slice = ast.NodeSuffixOp.SliceRange {1618 .Slice = ast.Node.SuffixOp.SliceRange {
1631 .start = start,1619 .start = start,
1632 .end = null,1620 .end = null,
1633 }1621 }
...@@ -1653,8 +1641,8 @@ pub const Parser = struct {...@@ -1653,8 +1641,8 @@ pub const Parser = struct {
1653 },1641 },
1654 State.SliceOrArrayType => |node| {1642 State.SliceOrArrayType => |node| {
1655 if (self.eatToken(Token.Id.RBracket)) |_| {1643 if (self.eatToken(Token.Id.RBracket)) |_| {
1656 node.op = ast.NodePrefixOp.PrefixOp {1644 node.op = ast.Node.PrefixOp.Op {
1657 .SliceType = ast.NodePrefixOp.AddrOfInfo {1645 .SliceType = ast.Node.PrefixOp.AddrOfInfo {
1658 .align_expr = null,1646 .align_expr = null,
1659 .bit_offset_start_token = null,1647 .bit_offset_start_token = null,
1660 .bit_offset_end_token = null,1648 .bit_offset_end_token = null,
...@@ -1667,7 +1655,7 @@ pub const Parser = struct {...@@ -1667,7 +1655,7 @@ pub const Parser = struct {
1667 continue;1655 continue;
1668 }1656 }
16691657
1670 node.op = ast.NodePrefixOp.PrefixOp { .ArrayType = undefined };1658 node.op = ast.Node.PrefixOp.Op { .ArrayType = undefined };
1671 stack.append(State { .TypeExprBegin = OptionalCtx { .Required = &node.rhs } }) catch unreachable;1659 stack.append(State { .TypeExprBegin = OptionalCtx { .Required = &node.rhs } }) catch unreachable;
1672 try stack.append(State { .ExpectToken = Token.Id.RBracket });1660 try stack.append(State { .ExpectToken = Token.Id.RBracket });
1673 try stack.append(State { .Expression = OptionalCtx { .Required = &node.op.ArrayType } });1661 try stack.append(State { .Expression = OptionalCtx { .Required = &node.op.ArrayType } });
...@@ -1723,8 +1711,8 @@ pub const Parser = struct {...@@ -1723,8 +1711,8 @@ pub const Parser = struct {
1723 continue;1711 continue;
1724 }1712 }
17251713
1726 const node = try self.createToCtxNode(arena, opt_ctx, ast.NodePayload,1714 const node = try self.createToCtxNode(arena, opt_ctx, ast.Node.Payload,
1727 ast.NodePayload {1715 ast.Node.Payload {
1728 .base = undefined,1716 .base = undefined,
1729 .lpipe = token,1717 .lpipe = token,
1730 .error_symbol = undefined,1718 .error_symbol = undefined,
...@@ -1754,8 +1742,8 @@ pub const Parser = struct {...@@ -1754,8 +1742,8 @@ pub const Parser = struct {
1754 continue;1742 continue;
1755 }1743 }
17561744
1757 const node = try self.createToCtxNode(arena, opt_ctx, ast.NodePointerPayload,1745 const node = try self.createToCtxNode(arena, opt_ctx, ast.Node.PointerPayload,
1758 ast.NodePointerPayload {1746 ast.Node.PointerPayload {
1759 .base = undefined,1747 .base = undefined,
1760 .lpipe = token,1748 .lpipe = token,
1761 .ptr_token = null,1749 .ptr_token = null,
...@@ -1792,8 +1780,8 @@ pub const Parser = struct {...@@ -1792,8 +1780,8 @@ pub const Parser = struct {
1792 continue;1780 continue;
1793 }1781 }
17941782
1795 const node = try self.createToCtxNode(arena, opt_ctx, ast.NodePointerIndexPayload,1783 const node = try self.createToCtxNode(arena, opt_ctx, ast.Node.PointerIndexPayload,
1796 ast.NodePointerIndexPayload {1784 ast.Node.PointerIndexPayload {
1797 .base = undefined,1785 .base = undefined,
1798 .lpipe = token,1786 .lpipe = token,
1799 .ptr_token = null,1787 .ptr_token = null,
...@@ -1826,8 +1814,8 @@ pub const Parser = struct {...@@ -1826,8 +1814,8 @@ pub const Parser = struct {
1826 const token = self.getNextToken();1814 const token = self.getNextToken();
1827 switch (token.id) {1815 switch (token.id) {
1828 Token.Id.Keyword_return, Token.Id.Keyword_break, Token.Id.Keyword_continue => {1816 Token.Id.Keyword_return, Token.Id.Keyword_break, Token.Id.Keyword_continue => {
1829 const node = try self.createToCtxNode(arena, opt_ctx, ast.NodeControlFlowExpression,1817 const node = try self.createToCtxNode(arena, opt_ctx, ast.Node.ControlFlowExpression,
1830 ast.NodeControlFlowExpression {1818 ast.Node.ControlFlowExpression {
1831 .base = undefined,1819 .base = undefined,
1832 .ltoken = token,1820 .ltoken = token,
1833 .kind = undefined,1821 .kind = undefined,
...@@ -1839,31 +1827,31 @@ pub const Parser = struct {...@@ -1839,31 +1827,31 @@ pub const Parser = struct {
18391827
1840 switch (token.id) {1828 switch (token.id) {
1841 Token.Id.Keyword_break => {1829 Token.Id.Keyword_break => {
1842 node.kind = ast.NodeControlFlowExpression.Kind { .Break = null };1830 node.kind = ast.Node.ControlFlowExpression.Kind { .Break = null };
1843 try stack.append(State { .Identifier = OptionalCtx { .RequiredNull = &node.kind.Break } });1831 try stack.append(State { .Identifier = OptionalCtx { .RequiredNull = &node.kind.Break } });
1844 try stack.append(State { .IfToken = Token.Id.Colon });1832 try stack.append(State { .IfToken = Token.Id.Colon });
1845 },1833 },
1846 Token.Id.Keyword_continue => {1834 Token.Id.Keyword_continue => {
1847 node.kind = ast.NodeControlFlowExpression.Kind { .Continue = null };1835 node.kind = ast.Node.ControlFlowExpression.Kind { .Continue = null };
1848 try stack.append(State { .Identifier = OptionalCtx { .RequiredNull = &node.kind.Continue } });1836 try stack.append(State { .Identifier = OptionalCtx { .RequiredNull = &node.kind.Continue } });
1849 try stack.append(State { .IfToken = Token.Id.Colon });1837 try stack.append(State { .IfToken = Token.Id.Colon });
1850 },1838 },
1851 Token.Id.Keyword_return => {1839 Token.Id.Keyword_return => {
1852 node.kind = ast.NodeControlFlowExpression.Kind.Return;1840 node.kind = ast.Node.ControlFlowExpression.Kind.Return;
1853 },1841 },
1854 else => unreachable,1842 else => unreachable,
1855 }1843 }
1856 continue;1844 continue;
1857 },1845 },
1858 Token.Id.Keyword_try, Token.Id.Keyword_cancel, Token.Id.Keyword_resume => {1846 Token.Id.Keyword_try, Token.Id.Keyword_cancel, Token.Id.Keyword_resume => {
1859 const node = try self.createToCtxNode(arena, opt_ctx, ast.NodePrefixOp,1847 const node = try self.createToCtxNode(arena, opt_ctx, ast.Node.PrefixOp,
1860 ast.NodePrefixOp {1848 ast.Node.PrefixOp {
1861 .base = undefined,1849 .base = undefined,
1862 .op_token = token,1850 .op_token = token,
1863 .op = switch (token.id) {1851 .op = switch (token.id) {
1864 Token.Id.Keyword_try => ast.NodePrefixOp.PrefixOp { .Try = void{} },1852 Token.Id.Keyword_try => ast.Node.PrefixOp.Op { .Try = void{} },
1865 Token.Id.Keyword_cancel => ast.NodePrefixOp.PrefixOp { .Cancel = void{} },1853 Token.Id.Keyword_cancel => ast.Node.PrefixOp.Op { .Cancel = void{} },
1866 Token.Id.Keyword_resume => ast.NodePrefixOp.PrefixOp { .Resume = void{} },1854 Token.Id.Keyword_resume => ast.Node.PrefixOp.Op { .Resume = void{} },
1867 else => unreachable,1855 else => unreachable,
1868 },1856 },
1869 .rhs = undefined,1857 .rhs = undefined,
...@@ -1891,12 +1879,12 @@ pub const Parser = struct {...@@ -1891,12 +1879,12 @@ pub const Parser = struct {
1891 const lhs = opt_ctx.get() ?? continue;1879 const lhs = opt_ctx.get() ?? continue;
18921880
1893 if (self.eatToken(Token.Id.Ellipsis3)) |ellipsis3| {1881 if (self.eatToken(Token.Id.Ellipsis3)) |ellipsis3| {
1894 const node = try self.createToCtxNode(arena, opt_ctx, ast.NodeInfixOp,1882 const node = try self.createToCtxNode(arena, opt_ctx, ast.Node.InfixOp,
1895 ast.NodeInfixOp {1883 ast.Node.InfixOp {
1896 .base = undefined,1884 .base = undefined,
1897 .lhs = lhs,1885 .lhs = lhs,
1898 .op_token = ellipsis3,1886 .op_token = ellipsis3,
1899 .op = ast.NodeInfixOp.InfixOp.Range,1887 .op = ast.Node.InfixOp.Op.Range,
1900 .rhs = undefined,1888 .rhs = undefined,
1901 }1889 }
1902 );1890 );
...@@ -1915,8 +1903,8 @@ pub const Parser = struct {...@@ -1915,8 +1903,8 @@ pub const Parser = struct {
19151903
1916 const token = self.getNextToken();1904 const token = self.getNextToken();
1917 if (tokenIdToAssignment(token.id)) |ass_id| {1905 if (tokenIdToAssignment(token.id)) |ass_id| {
1918 const node = try self.createToCtxNode(arena, opt_ctx, ast.NodeInfixOp,1906 const node = try self.createToCtxNode(arena, opt_ctx, ast.Node.InfixOp,
1919 ast.NodeInfixOp {1907 ast.Node.InfixOp {
1920 .base = undefined,1908 .base = undefined,
1921 .lhs = lhs,1909 .lhs = lhs,
1922 .op_token = token,1910 .op_token = token,
...@@ -1944,8 +1932,8 @@ pub const Parser = struct {...@@ -1944,8 +1932,8 @@ pub const Parser = struct {
19441932
1945 const token = self.getNextToken();1933 const token = self.getNextToken();
1946 if (tokenIdToUnwrapExpr(token.id)) |unwrap_id| {1934 if (tokenIdToUnwrapExpr(token.id)) |unwrap_id| {
1947 const node = try self.createToCtxNode(arena, opt_ctx, ast.NodeInfixOp,1935 const node = try self.createToCtxNode(arena, opt_ctx, ast.Node.InfixOp,
1948 ast.NodeInfixOp {1936 ast.Node.InfixOp {
1949 .base = undefined,1937 .base = undefined,
1950 .lhs = lhs,1938 .lhs = lhs,
1951 .op_token = token,1939 .op_token = token,
...@@ -1957,7 +1945,7 @@ pub const Parser = struct {...@@ -1957,7 +1945,7 @@ pub const Parser = struct {
1957 stack.append(State { .UnwrapExpressionEnd = opt_ctx.toRequired() }) catch unreachable;1945 stack.append(State { .UnwrapExpressionEnd = opt_ctx.toRequired() }) catch unreachable;
1958 try stack.append(State { .Expression = OptionalCtx { .Required = &node.rhs } });1946 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) {
1961 try stack.append(State { .Payload = OptionalCtx { .Optional = &node.op.Catch } });1949 try stack.append(State { .Payload = OptionalCtx { .Optional = &node.op.Catch } });
1962 }1950 }
1963 continue;1951 continue;
...@@ -1977,12 +1965,12 @@ pub const Parser = struct {...@@ -1977,12 +1965,12 @@ pub const Parser = struct {
1977 const lhs = opt_ctx.get() ?? continue;1965 const lhs = opt_ctx.get() ?? continue;
19781966
1979 if (self.eatToken(Token.Id.Keyword_or)) |or_token| {1967 if (self.eatToken(Token.Id.Keyword_or)) |or_token| {
1980 const node = try self.createToCtxNode(arena, opt_ctx, ast.NodeInfixOp,1968 const node = try self.createToCtxNode(arena, opt_ctx, ast.Node.InfixOp,
1981 ast.NodeInfixOp {1969 ast.Node.InfixOp {
1982 .base = undefined,1970 .base = undefined,
1983 .lhs = lhs,1971 .lhs = lhs,
1984 .op_token = or_token,1972 .op_token = or_token,
1985 .op = ast.NodeInfixOp.InfixOp.BoolOr,1973 .op = ast.Node.InfixOp.Op.BoolOr,
1986 .rhs = undefined,1974 .rhs = undefined,
1987 }1975 }
1988 );1976 );
...@@ -2002,12 +1990,12 @@ pub const Parser = struct {...@@ -2002,12 +1990,12 @@ pub const Parser = struct {
2002 const lhs = opt_ctx.get() ?? continue;1990 const lhs = opt_ctx.get() ?? continue;
20031991
2004 if (self.eatToken(Token.Id.Keyword_and)) |and_token| {1992 if (self.eatToken(Token.Id.Keyword_and)) |and_token| {
2005 const node = try self.createToCtxNode(arena, opt_ctx, ast.NodeInfixOp,1993 const node = try self.createToCtxNode(arena, opt_ctx, ast.Node.InfixOp,
2006 ast.NodeInfixOp {1994 ast.Node.InfixOp {
2007 .base = undefined,1995 .base = undefined,
2008 .lhs = lhs,1996 .lhs = lhs,
2009 .op_token = and_token,1997 .op_token = and_token,
2010 .op = ast.NodeInfixOp.InfixOp.BoolAnd,1998 .op = ast.Node.InfixOp.Op.BoolAnd,
2011 .rhs = undefined,1999 .rhs = undefined,
2012 }2000 }
2013 );2001 );
...@@ -2028,8 +2016,8 @@ pub const Parser = struct {...@@ -2028,8 +2016,8 @@ pub const Parser = struct {
20282016
2029 const token = self.getNextToken();2017 const token = self.getNextToken();
2030 if (tokenIdToComparison(token.id)) |comp_id| {2018 if (tokenIdToComparison(token.id)) |comp_id| {
2031 const node = try self.createToCtxNode(arena, opt_ctx, ast.NodeInfixOp,2019 const node = try self.createToCtxNode(arena, opt_ctx, ast.Node.InfixOp,
2032 ast.NodeInfixOp {2020 ast.Node.InfixOp {
2033 .base = undefined,2021 .base = undefined,
2034 .lhs = lhs,2022 .lhs = lhs,
2035 .op_token = token,2023 .op_token = token,
...@@ -2056,12 +2044,12 @@ pub const Parser = struct {...@@ -2056,12 +2044,12 @@ pub const Parser = struct {
2056 const lhs = opt_ctx.get() ?? continue;2044 const lhs = opt_ctx.get() ?? continue;
20572045
2058 if (self.eatToken(Token.Id.Pipe)) |pipe| {2046 if (self.eatToken(Token.Id.Pipe)) |pipe| {
2059 const node = try self.createToCtxNode(arena, opt_ctx, ast.NodeInfixOp,2047 const node = try self.createToCtxNode(arena, opt_ctx, ast.Node.InfixOp,
2060 ast.NodeInfixOp {2048 ast.Node.InfixOp {
2061 .base = undefined,2049 .base = undefined,
2062 .lhs = lhs,2050 .lhs = lhs,
2063 .op_token = pipe,2051 .op_token = pipe,
2064 .op = ast.NodeInfixOp.InfixOp.BitOr,2052 .op = ast.Node.InfixOp.Op.BitOr,
2065 .rhs = undefined,2053 .rhs = undefined,
2066 }2054 }
2067 );2055 );
...@@ -2081,12 +2069,12 @@ pub const Parser = struct {...@@ -2081,12 +2069,12 @@ pub const Parser = struct {
2081 const lhs = opt_ctx.get() ?? continue;2069 const lhs = opt_ctx.get() ?? continue;
20822070
2083 if (self.eatToken(Token.Id.Caret)) |caret| {2071 if (self.eatToken(Token.Id.Caret)) |caret| {
2084 const node = try self.createToCtxNode(arena, opt_ctx, ast.NodeInfixOp,2072 const node = try self.createToCtxNode(arena, opt_ctx, ast.Node.InfixOp,
2085 ast.NodeInfixOp {2073 ast.Node.InfixOp {
2086 .base = undefined,2074 .base = undefined,
2087 .lhs = lhs,2075 .lhs = lhs,
2088 .op_token = caret,2076 .op_token = caret,
2089 .op = ast.NodeInfixOp.InfixOp.BitXor,2077 .op = ast.Node.InfixOp.Op.BitXor,
2090 .rhs = undefined,2078 .rhs = undefined,
2091 }2079 }
2092 );2080 );
...@@ -2106,12 +2094,12 @@ pub const Parser = struct {...@@ -2106,12 +2094,12 @@ pub const Parser = struct {
2106 const lhs = opt_ctx.get() ?? continue;2094 const lhs = opt_ctx.get() ?? continue;
21072095
2108 if (self.eatToken(Token.Id.Ampersand)) |ampersand| {2096 if (self.eatToken(Token.Id.Ampersand)) |ampersand| {
2109 const node = try self.createToCtxNode(arena, opt_ctx, ast.NodeInfixOp,2097 const node = try self.createToCtxNode(arena, opt_ctx, ast.Node.InfixOp,
2110 ast.NodeInfixOp {2098 ast.Node.InfixOp {
2111 .base = undefined,2099 .base = undefined,
2112 .lhs = lhs,2100 .lhs = lhs,
2113 .op_token = ampersand,2101 .op_token = ampersand,
2114 .op = ast.NodeInfixOp.InfixOp.BitAnd,2102 .op = ast.Node.InfixOp.Op.BitAnd,
2115 .rhs = undefined,2103 .rhs = undefined,
2116 }2104 }
2117 );2105 );
...@@ -2132,8 +2120,8 @@ pub const Parser = struct {...@@ -2132,8 +2120,8 @@ pub const Parser = struct {
21322120
2133 const token = self.getNextToken();2121 const token = self.getNextToken();
2134 if (tokenIdToBitShift(token.id)) |bitshift_id| {2122 if (tokenIdToBitShift(token.id)) |bitshift_id| {
2135 const node = try self.createToCtxNode(arena, opt_ctx, ast.NodeInfixOp,2123 const node = try self.createToCtxNode(arena, opt_ctx, ast.Node.InfixOp,
2136 ast.NodeInfixOp {2124 ast.Node.InfixOp {
2137 .base = undefined,2125 .base = undefined,
2138 .lhs = lhs,2126 .lhs = lhs,
2139 .op_token = token,2127 .op_token = token,
...@@ -2161,8 +2149,8 @@ pub const Parser = struct {...@@ -2161,8 +2149,8 @@ pub const Parser = struct {
21612149
2162 const token = self.getNextToken();2150 const token = self.getNextToken();
2163 if (tokenIdToAddition(token.id)) |add_id| {2151 if (tokenIdToAddition(token.id)) |add_id| {
2164 const node = try self.createToCtxNode(arena, opt_ctx, ast.NodeInfixOp,2152 const node = try self.createToCtxNode(arena, opt_ctx, ast.Node.InfixOp,
2165 ast.NodeInfixOp {2153 ast.Node.InfixOp {
2166 .base = undefined,2154 .base = undefined,
2167 .lhs = lhs,2155 .lhs = lhs,
2168 .op_token = token,2156 .op_token = token,
...@@ -2190,8 +2178,8 @@ pub const Parser = struct {...@@ -2190,8 +2178,8 @@ pub const Parser = struct {
21902178
2191 const token = self.getNextToken();2179 const token = self.getNextToken();
2192 if (tokenIdToMultiply(token.id)) |mult_id| {2180 if (tokenIdToMultiply(token.id)) |mult_id| {
2193 const node = try self.createToCtxNode(arena, opt_ctx, ast.NodeInfixOp,2181 const node = try self.createToCtxNode(arena, opt_ctx, ast.Node.InfixOp,
2194 ast.NodeInfixOp {2182 ast.Node.InfixOp {
2195 .base = undefined,2183 .base = undefined,
2196 .lhs = lhs,2184 .lhs = lhs,
2197 .op_token = token,2185 .op_token = token,
...@@ -2219,12 +2207,12 @@ pub const Parser = struct {...@@ -2219,12 +2207,12 @@ pub const Parser = struct {
2219 const lhs = opt_ctx.get() ?? continue;2207 const lhs = opt_ctx.get() ?? continue;
22202208
2221 if (self.isPeekToken(Token.Id.Period)) {2209 if (self.isPeekToken(Token.Id.Period)) {
2222 const node = try self.createToCtxNode(arena, opt_ctx, ast.NodeSuffixOp,2210 const node = try self.createToCtxNode(arena, opt_ctx, ast.Node.SuffixOp,
2223 ast.NodeSuffixOp {2211 ast.Node.SuffixOp {
2224 .base = undefined,2212 .base = undefined,
2225 .lhs = lhs,2213 .lhs = lhs,
2226 .op = ast.NodeSuffixOp.SuffixOp {2214 .op = ast.Node.SuffixOp.Op {
2227 .StructInitializer = ArrayList(&ast.NodeFieldInitializer).init(arena),2215 .StructInitializer = ArrayList(&ast.Node.FieldInitializer).init(arena),
2228 },2216 },
2229 .rtoken = undefined,2217 .rtoken = undefined,
2230 }2218 }
...@@ -2232,7 +2220,7 @@ pub const Parser = struct {...@@ -2232,7 +2220,7 @@ pub const Parser = struct {
2232 stack.append(State { .CurlySuffixExpressionEnd = opt_ctx.toRequired() }) catch unreachable;2220 stack.append(State { .CurlySuffixExpressionEnd = opt_ctx.toRequired() }) catch unreachable;
2233 try stack.append(State { .IfToken = Token.Id.LBrace });2221 try stack.append(State { .IfToken = Token.Id.LBrace });
2234 try stack.append(State {2222 try stack.append(State {
2235 .FieldInitListItemOrEnd = ListSave(&ast.NodeFieldInitializer) {2223 .FieldInitListItemOrEnd = ListSave(&ast.Node.FieldInitializer) {
2236 .list = &node.op.StructInitializer,2224 .list = &node.op.StructInitializer,
2237 .ptr = &node.rtoken,2225 .ptr = &node.rtoken,
2238 }2226 }
...@@ -2240,11 +2228,11 @@ pub const Parser = struct {...@@ -2240,11 +2228,11 @@ pub const Parser = struct {
2240 continue;2228 continue;
2241 }2229 }
22422230
2243 const node = try self.createToCtxNode(arena, opt_ctx, ast.NodeSuffixOp,2231 const node = try self.createToCtxNode(arena, opt_ctx, ast.Node.SuffixOp,
2244 ast.NodeSuffixOp {2232 ast.Node.SuffixOp {
2245 .base = undefined,2233 .base = undefined,
2246 .lhs = lhs,2234 .lhs = lhs,
2247 .op = ast.NodeSuffixOp.SuffixOp {2235 .op = ast.Node.SuffixOp.Op {
2248 .ArrayInitializer = ArrayList(&ast.Node).init(arena),2236 .ArrayInitializer = ArrayList(&ast.Node).init(arena),
2249 },2237 },
2250 .rtoken = undefined,2238 .rtoken = undefined,
...@@ -2272,12 +2260,12 @@ pub const Parser = struct {...@@ -2272,12 +2260,12 @@ pub const Parser = struct {
2272 const lhs = opt_ctx.get() ?? continue;2260 const lhs = opt_ctx.get() ?? continue;
22732261
2274 if (self.eatToken(Token.Id.Bang)) |bang| {2262 if (self.eatToken(Token.Id.Bang)) |bang| {
2275 const node = try self.createToCtxNode(arena, opt_ctx, ast.NodeInfixOp,2263 const node = try self.createToCtxNode(arena, opt_ctx, ast.Node.InfixOp,
2276 ast.NodeInfixOp {2264 ast.Node.InfixOp {
2277 .base = undefined,2265 .base = undefined,
2278 .lhs = lhs,2266 .lhs = lhs,
2279 .op_token = bang,2267 .op_token = bang,
2280 .op = ast.NodeInfixOp.InfixOp.ErrorUnion,2268 .op = ast.Node.InfixOp.Op.ErrorUnion,
2281 .rhs = undefined,2269 .rhs = undefined,
2282 }2270 }
2283 );2271 );
...@@ -2290,8 +2278,8 @@ pub const Parser = struct {...@@ -2290,8 +2278,8 @@ pub const Parser = struct {
2290 State.PrefixOpExpression => |opt_ctx| {2278 State.PrefixOpExpression => |opt_ctx| {
2291 const token = self.getNextToken();2279 const token = self.getNextToken();
2292 if (tokenIdToPrefixOp(token.id)) |prefix_id| {2280 if (tokenIdToPrefixOp(token.id)) |prefix_id| {
2293 var node = try self.createToCtxNode(arena, opt_ctx, ast.NodePrefixOp,2281 var node = try self.createToCtxNode(arena, opt_ctx, ast.Node.PrefixOp,
2294 ast.NodePrefixOp {2282 ast.Node.PrefixOp {
2295 .base = undefined,2283 .base = undefined,
2296 .op_token = token,2284 .op_token = token,
2297 .op = prefix_id,2285 .op = prefix_id,
...@@ -2301,8 +2289,8 @@ pub const Parser = struct {...@@ -2301,8 +2289,8 @@ pub const Parser = struct {
23012289
2302 // Treat '**' token as two derefs2290 // Treat '**' token as two derefs
2303 if (token.id == Token.Id.AsteriskAsterisk) {2291 if (token.id == Token.Id.AsteriskAsterisk) {
2304 const child = try self.createNode(arena, ast.NodePrefixOp,2292 const child = try self.createNode(arena, ast.Node.PrefixOp,
2305 ast.NodePrefixOp {2293 ast.Node.PrefixOp {
2306 .base = undefined,2294 .base = undefined,
2307 .op_token = token,2295 .op_token = token,
2308 .op = prefix_id,2296 .op = prefix_id,
...@@ -2314,7 +2302,7 @@ pub const Parser = struct {...@@ -2314,7 +2302,7 @@ pub const Parser = struct {
2314 }2302 }
23152303
2316 stack.append(State { .TypeExprBegin = OptionalCtx { .Required = &node.rhs } }) catch unreachable;2304 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) {
2318 try stack.append(State { .AddrOfModifiers = &node.op.AddrOf });2306 try stack.append(State { .AddrOfModifiers = &node.op.AddrOf });
2319 }2307 }
2320 continue;2308 continue;
...@@ -2327,8 +2315,8 @@ pub const Parser = struct {...@@ -2327,8 +2315,8 @@ pub const Parser = struct {
23272315
2328 State.SuffixOpExpressionBegin => |opt_ctx| {2316 State.SuffixOpExpressionBegin => |opt_ctx| {
2329 if (self.eatToken(Token.Id.Keyword_async)) |async_token| {2317 if (self.eatToken(Token.Id.Keyword_async)) |async_token| {
2330 const async_node = try self.createNode(arena, ast.NodeAsyncAttribute,2318 const async_node = try self.createNode(arena, ast.Node.AsyncAttribute,
2331 ast.NodeAsyncAttribute {2319 ast.Node.AsyncAttribute {
2332 .base = undefined,2320 .base = undefined,
2333 .async_token = async_token,2321 .async_token = async_token,
2334 .allocator_type = null,2322 .allocator_type = null,
...@@ -2358,12 +2346,12 @@ pub const Parser = struct {...@@ -2358,12 +2346,12 @@ pub const Parser = struct {
2358 const token = self.getNextToken();2346 const token = self.getNextToken();
2359 switch (token.id) {2347 switch (token.id) {
2360 Token.Id.LParen => {2348 Token.Id.LParen => {
2361 const node = try self.createToCtxNode(arena, opt_ctx, ast.NodeSuffixOp,2349 const node = try self.createToCtxNode(arena, opt_ctx, ast.Node.SuffixOp,
2362 ast.NodeSuffixOp {2350 ast.Node.SuffixOp {
2363 .base = undefined,2351 .base = undefined,
2364 .lhs = lhs,2352 .lhs = lhs,
2365 .op = ast.NodeSuffixOp.SuffixOp {2353 .op = ast.Node.SuffixOp.Op {
2366 .Call = ast.NodeSuffixOp.CallInfo {2354 .Call = ast.Node.SuffixOp.CallInfo {
2367 .params = ArrayList(&ast.Node).init(arena),2355 .params = ArrayList(&ast.Node).init(arena),
2368 .async_attr = null,2356 .async_attr = null,
2369 }2357 }
...@@ -2382,11 +2370,11 @@ pub const Parser = struct {...@@ -2382,11 +2370,11 @@ pub const Parser = struct {
2382 continue;2370 continue;
2383 },2371 },
2384 Token.Id.LBracket => {2372 Token.Id.LBracket => {
2385 const node = try self.createToCtxNode(arena, opt_ctx, ast.NodeSuffixOp,2373 const node = try self.createToCtxNode(arena, opt_ctx, ast.Node.SuffixOp,
2386 ast.NodeSuffixOp {2374 ast.Node.SuffixOp {
2387 .base = undefined,2375 .base = undefined,
2388 .lhs = lhs,2376 .lhs = lhs,
2389 .op = ast.NodeSuffixOp.SuffixOp {2377 .op = ast.Node.SuffixOp.Op {
2390 .ArrayAccess = undefined,2378 .ArrayAccess = undefined,
2391 },2379 },
2392 .rtoken = undefined2380 .rtoken = undefined
...@@ -2398,12 +2386,12 @@ pub const Parser = struct {...@@ -2398,12 +2386,12 @@ pub const Parser = struct {
2398 continue;2386 continue;
2399 },2387 },
2400 Token.Id.Period => {2388 Token.Id.Period => {
2401 const node = try self.createToCtxNode(arena, opt_ctx, ast.NodeInfixOp,2389 const node = try self.createToCtxNode(arena, opt_ctx, ast.Node.InfixOp,
2402 ast.NodeInfixOp {2390 ast.Node.InfixOp {
2403 .base = undefined,2391 .base = undefined,
2404 .lhs = lhs,2392 .lhs = lhs,
2405 .op_token = token,2393 .op_token = token,
2406 .op = ast.NodeInfixOp.InfixOp.Period,2394 .op = ast.Node.InfixOp.Op.Period,
2407 .rhs = undefined,2395 .rhs = undefined,
2408 }2396 }
2409 );2397 );
...@@ -2422,39 +2410,39 @@ pub const Parser = struct {...@@ -2422,39 +2410,39 @@ pub const Parser = struct {
2422 const token = self.getNextToken();2410 const token = self.getNextToken();
2423 switch (token.id) {2411 switch (token.id) {
2424 Token.Id.IntegerLiteral => {2412 Token.Id.IntegerLiteral => {
2425 _ = try self.createToCtxLiteral(arena, opt_ctx, ast.NodeStringLiteral, token);2413 _ = try self.createToCtxLiteral(arena, opt_ctx, ast.Node.StringLiteral, token);
2426 continue;2414 continue;
2427 },2415 },
2428 Token.Id.FloatLiteral => {2416 Token.Id.FloatLiteral => {
2429 _ = try self.createToCtxLiteral(arena, opt_ctx, ast.NodeFloatLiteral, token);2417 _ = try self.createToCtxLiteral(arena, opt_ctx, ast.Node.FloatLiteral, token);
2430 continue;2418 continue;
2431 },2419 },
2432 Token.Id.CharLiteral => {2420 Token.Id.CharLiteral => {
2433 _ = try self.createToCtxLiteral(arena, opt_ctx, ast.NodeCharLiteral, token);2421 _ = try self.createToCtxLiteral(arena, opt_ctx, ast.Node.CharLiteral, token);
2434 continue;2422 continue;
2435 },2423 },
2436 Token.Id.Keyword_undefined => {2424 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);
2438 continue;2426 continue;
2439 },2427 },
2440 Token.Id.Keyword_true, Token.Id.Keyword_false => {2428 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);
2442 continue;2430 continue;
2443 },2431 },
2444 Token.Id.Keyword_null => {2432 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);
2446 continue;2434 continue;
2447 },2435 },
2448 Token.Id.Keyword_this => {2436 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);
2450 continue;2438 continue;
2451 },2439 },
2452 Token.Id.Keyword_var => {2440 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);
2454 continue;2442 continue;
2455 },2443 },
2456 Token.Id.Keyword_unreachable => {2444 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);
2458 continue;2446 continue;
2459 },2447 },
2460 Token.Id.StringLiteral, Token.Id.MultilineStringLiteralLine => {2448 Token.Id.StringLiteral, Token.Id.MultilineStringLiteralLine => {
...@@ -2462,8 +2450,8 @@ pub const Parser = struct {...@@ -2462,8 +2450,8 @@ pub const Parser = struct {
2462 continue;2450 continue;
2463 },2451 },
2464 Token.Id.LParen => {2452 Token.Id.LParen => {
2465 const node = try self.createToCtxNode(arena, opt_ctx, ast.NodeGroupedExpression,2453 const node = try self.createToCtxNode(arena, opt_ctx, ast.Node.GroupedExpression,
2466 ast.NodeGroupedExpression {2454 ast.Node.GroupedExpression {
2467 .base = undefined,2455 .base = undefined,
2468 .lparen = token,2456 .lparen = token,
2469 .expr = undefined,2457 .expr = undefined,
...@@ -2480,8 +2468,8 @@ pub const Parser = struct {...@@ -2480,8 +2468,8 @@ pub const Parser = struct {
2480 continue;2468 continue;
2481 },2469 },
2482 Token.Id.Builtin => {2470 Token.Id.Builtin => {
2483 const node = try self.createToCtxNode(arena, opt_ctx, ast.NodeBuiltinCall,2471 const node = try self.createToCtxNode(arena, opt_ctx, ast.Node.BuiltinCall,
2484 ast.NodeBuiltinCall {2472 ast.Node.BuiltinCall {
2485 .base = undefined,2473 .base = undefined,
2486 .builtin_token = token,2474 .builtin_token = token,
2487 .params = ArrayList(&ast.Node).init(arena),2475 .params = ArrayList(&ast.Node).init(arena),
...@@ -2499,8 +2487,8 @@ pub const Parser = struct {...@@ -2499,8 +2487,8 @@ pub const Parser = struct {
2499 continue;2487 continue;
2500 },2488 },
2501 Token.Id.LBracket => {2489 Token.Id.LBracket => {
2502 const node = try self.createToCtxNode(arena, opt_ctx, ast.NodePrefixOp,2490 const node = try self.createToCtxNode(arena, opt_ctx, ast.Node.PrefixOp,
2503 ast.NodePrefixOp {2491 ast.Node.PrefixOp {
2504 .base = undefined,2492 .base = undefined,
2505 .op_token = token,2493 .op_token = token,
2506 .op = undefined,2494 .op = undefined,
...@@ -2524,7 +2512,7 @@ pub const Parser = struct {...@@ -2524,7 +2512,7 @@ pub const Parser = struct {
2524 .ContainerKind = ContainerKindCtx {2512 .ContainerKind = ContainerKindCtx {
2525 .opt_ctx = opt_ctx,2513 .opt_ctx = opt_ctx,
2526 .ltoken = token,2514 .ltoken = token,
2527 .layout = ast.NodeContainerDecl.Layout.Packed,2515 .layout = ast.Node.ContainerDecl.Layout.Packed,
2528 },2516 },
2529 }) catch unreachable;2517 }) catch unreachable;
2530 continue;2518 continue;
...@@ -2534,6 +2522,7 @@ pub const Parser = struct {...@@ -2534,6 +2522,7 @@ pub const Parser = struct {
2534 .ExternType = ExternTypeCtx {2522 .ExternType = ExternTypeCtx {
2535 .opt_ctx = opt_ctx,2523 .opt_ctx = opt_ctx,
2536 .extern_token = token,2524 .extern_token = token,
2525 .comments = null,
2537 },2526 },
2538 }) catch unreachable;2527 }) catch unreachable;
2539 continue;2528 continue;
...@@ -2544,7 +2533,7 @@ pub const Parser = struct {...@@ -2544,7 +2533,7 @@ pub const Parser = struct {
2544 .ContainerKind = ContainerKindCtx {2533 .ContainerKind = ContainerKindCtx {
2545 .opt_ctx = opt_ctx,2534 .opt_ctx = opt_ctx,
2546 .ltoken = token,2535 .ltoken = token,
2547 .layout = ast.NodeContainerDecl.Layout.Auto,2536 .layout = ast.Node.ContainerDecl.Layout.Auto,
2548 },2537 },
2549 }) catch unreachable;2538 }) catch unreachable;
2550 continue;2539 continue;
...@@ -2559,9 +2548,10 @@ pub const Parser = struct {...@@ -2559,9 +2548,10 @@ pub const Parser = struct {
2559 continue;2548 continue;
2560 },2549 },
2561 Token.Id.Keyword_fn => {2550 Token.Id.Keyword_fn => {
2562 const fn_proto = try self.createToCtxNode(arena, opt_ctx, ast.NodeFnProto,2551 const fn_proto = try self.createToCtxNode(arena, opt_ctx, ast.Node.FnProto,
2563 ast.NodeFnProto {2552 ast.Node.FnProto {
2564 .base = undefined,2553 .base = undefined,
2554 .comments = null,
2565 .visib_token = null,2555 .visib_token = null,
2566 .name_token = null,2556 .name_token = null,
2567 .fn_token = token,2557 .fn_token = token,
...@@ -2580,9 +2570,10 @@ pub const Parser = struct {...@@ -2580,9 +2570,10 @@ pub const Parser = struct {
2580 continue;2570 continue;
2581 },2571 },
2582 Token.Id.Keyword_nakedcc, Token.Id.Keyword_stdcallcc => {2572 Token.Id.Keyword_nakedcc, Token.Id.Keyword_stdcallcc => {
2583 const fn_proto = try self.createToCtxNode(arena, opt_ctx, ast.NodeFnProto,2573 const fn_proto = try self.createToCtxNode(arena, opt_ctx, ast.Node.FnProto,
2584 ast.NodeFnProto {2574 ast.Node.FnProto {
2585 .base = undefined,2575 .base = undefined,
2576 .comments = null,
2586 .visib_token = null,2577 .visib_token = null,
2587 .name_token = null,2578 .name_token = null,
2588 .fn_token = undefined,2579 .fn_token = undefined,
...@@ -2607,15 +2598,15 @@ pub const Parser = struct {...@@ -2607,15 +2598,15 @@ pub const Parser = struct {
2607 continue;2598 continue;
2608 },2599 },
2609 Token.Id.Keyword_asm => {2600 Token.Id.Keyword_asm => {
2610 const node = try self.createToCtxNode(arena, opt_ctx, ast.NodeAsm,2601 const node = try self.createToCtxNode(arena, opt_ctx, ast.Node.Asm,
2611 ast.NodeAsm {2602 ast.Node.Asm {
2612 .base = undefined,2603 .base = undefined,
2613 .asm_token = token,2604 .asm_token = token,
2614 .volatile_token = null,2605 .volatile_token = null,
2615 .template = undefined,2606 .template = undefined,
2616 //.tokens = ArrayList(ast.NodeAsm.AsmToken).init(arena),2607 //.tokens = ArrayList(ast.Node.Asm.AsmToken).init(arena),
2617 .outputs = ArrayList(&ast.NodeAsmOutput).init(arena),2608 .outputs = ArrayList(&ast.Node.AsmOutput).init(arena),
2618 .inputs = ArrayList(&ast.NodeAsmInput).init(arena),2609 .inputs = ArrayList(&ast.Node.AsmInput).init(arena),
2619 .cloppers = ArrayList(&ast.Node).init(arena),2610 .cloppers = ArrayList(&ast.Node).init(arena),
2620 .rparen = undefined,2611 .rparen = undefined,
2621 }2612 }
...@@ -2666,12 +2657,12 @@ pub const Parser = struct {...@@ -2666,12 +2657,12 @@ pub const Parser = struct {
26662657
2667 State.ErrorTypeOrSetDecl => |ctx| {2658 State.ErrorTypeOrSetDecl => |ctx| {
2668 if (self.eatToken(Token.Id.LBrace) == null) {2659 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);
2670 continue;2661 continue;
2671 }2662 }
26722663
2673 const node = try self.createToCtxNode(arena, ctx.opt_ctx, ast.NodeErrorSetDecl,2664 const node = try self.createToCtxNode(arena, ctx.opt_ctx, ast.Node.ErrorSetDecl,
2674 ast.NodeErrorSetDecl {2665 ast.Node.ErrorSetDecl {
2675 .base = undefined,2666 .base = undefined,
2676 .error_token = ctx.error_token,2667 .error_token = ctx.error_token,
2677 .decls = ArrayList(&ast.Node).init(arena),2668 .decls = ArrayList(&ast.Node).init(arena),
...@@ -2702,7 +2693,7 @@ pub const Parser = struct {...@@ -2702,7 +2693,7 @@ pub const Parser = struct {
2702 },2693 },
2703 State.Identifier => |opt_ctx| {2694 State.Identifier => |opt_ctx| {
2704 if (self.eatToken(Token.Id.Identifier)) |ident_token| {2695 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);
2706 continue;2697 continue;
2707 }2698 }
27082699
...@@ -2750,6 +2741,33 @@ pub const Parser = struct {...@@ -2750,6 +2741,33 @@ pub const Parser = struct {
2750 }2741 }
2751 }2742 }
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
2753 fn requireSemiColon(node: &const ast.Node) bool {2771 fn requireSemiColon(node: &const ast.Node) bool {
2754 var n = node;2772 var n = node;
2755 while (true) {2773 while (true) {
...@@ -2770,7 +2788,7 @@ pub const Parser = struct {...@@ -2770,7 +2788,7 @@ pub const Parser = struct {
2770 ast.Node.Id.LineComment,2788 ast.Node.Id.LineComment,
2771 ast.Node.Id.TestDecl => return false,2789 ast.Node.Id.TestDecl => return false,
2772 ast.Node.Id.While => {2790 ast.Node.Id.While => {
2773 const while_node = @fieldParentPtr(ast.NodeWhile, "base", n);2791 const while_node = @fieldParentPtr(ast.Node.While, "base", n);
2774 if (while_node.@"else") |@"else"| {2792 if (while_node.@"else") |@"else"| {
2775 n = @"else".base;2793 n = @"else".base;
2776 continue;2794 continue;
...@@ -2779,7 +2797,7 @@ pub const Parser = struct {...@@ -2779,7 +2797,7 @@ pub const Parser = struct {
2779 return while_node.body.id != ast.Node.Id.Block;2797 return while_node.body.id != ast.Node.Id.Block;
2780 },2798 },
2781 ast.Node.Id.For => {2799 ast.Node.Id.For => {
2782 const for_node = @fieldParentPtr(ast.NodeFor, "base", n);2800 const for_node = @fieldParentPtr(ast.Node.For, "base", n);
2783 if (for_node.@"else") |@"else"| {2801 if (for_node.@"else") |@"else"| {
2784 n = @"else".base;2802 n = @"else".base;
2785 continue;2803 continue;
...@@ -2788,7 +2806,7 @@ pub const Parser = struct {...@@ -2788,7 +2806,7 @@ pub const Parser = struct {
2788 return for_node.body.id != ast.Node.Id.Block;2806 return for_node.body.id != ast.Node.Id.Block;
2789 },2807 },
2790 ast.Node.Id.If => {2808 ast.Node.Id.If => {
2791 const if_node = @fieldParentPtr(ast.NodeIf, "base", n);2809 const if_node = @fieldParentPtr(ast.Node.If, "base", n);
2792 if (if_node.@"else") |@"else"| {2810 if (if_node.@"else") |@"else"| {
2793 n = @"else".base;2811 n = @"else".base;
2794 continue;2812 continue;
...@@ -2797,20 +2815,20 @@ pub const Parser = struct {...@@ -2797,20 +2815,20 @@ pub const Parser = struct {
2797 return if_node.body.id != ast.Node.Id.Block;2815 return if_node.body.id != ast.Node.Id.Block;
2798 },2816 },
2799 ast.Node.Id.Else => {2817 ast.Node.Id.Else => {
2800 const else_node = @fieldParentPtr(ast.NodeElse, "base", n);2818 const else_node = @fieldParentPtr(ast.Node.Else, "base", n);
2801 n = else_node.body;2819 n = else_node.body;
2802 continue;2820 continue;
2803 },2821 },
2804 ast.Node.Id.Defer => {2822 ast.Node.Id.Defer => {
2805 const defer_node = @fieldParentPtr(ast.NodeDefer, "base", n);2823 const defer_node = @fieldParentPtr(ast.Node.Defer, "base", n);
2806 return defer_node.expr.id != ast.Node.Id.Block;2824 return defer_node.expr.id != ast.Node.Id.Block;
2807 },2825 },
2808 ast.Node.Id.Comptime => {2826 ast.Node.Id.Comptime => {
2809 const comptime_node = @fieldParentPtr(ast.NodeComptime, "base", n);2827 const comptime_node = @fieldParentPtr(ast.Node.Comptime, "base", n);
2810 return comptime_node.expr.id != ast.Node.Id.Block;2828 return comptime_node.expr.id != ast.Node.Id.Block;
2811 },2829 },
2812 ast.Node.Id.Suspend => {2830 ast.Node.Id.Suspend => {
2813 const suspend_node = @fieldParentPtr(ast.NodeSuspend, "base", n);2831 const suspend_node = @fieldParentPtr(ast.Node.Suspend, "base", n);
2814 if (suspend_node.body) |body| {2832 if (suspend_node.body) |body| {
2815 return body.id != ast.Node.Id.Block;2833 return body.id != ast.Node.Id.Block;
2816 }2834 }
...@@ -2825,11 +2843,11 @@ pub const Parser = struct {...@@ -2825,11 +2843,11 @@ pub const Parser = struct {
2825 fn parseStringLiteral(self: &Parser, arena: &mem.Allocator, token: &const Token) !?&ast.Node {2843 fn parseStringLiteral(self: &Parser, arena: &mem.Allocator, token: &const Token) !?&ast.Node {
2826 switch (token.id) {2844 switch (token.id) {
2827 Token.Id.StringLiteral => {2845 Token.Id.StringLiteral => {
2828 return &(try self.createLiteral(arena, ast.NodeStringLiteral, token)).base;2846 return &(try self.createLiteral(arena, ast.Node.StringLiteral, token)).base;
2829 },2847 },
2830 Token.Id.MultilineStringLiteralLine => {2848 Token.Id.MultilineStringLiteralLine => {
2831 const node = try self.createNode(arena, ast.NodeMultilineStringLiteral,2849 const node = try self.createNode(arena, ast.Node.MultilineStringLiteral,
2832 ast.NodeMultilineStringLiteral {2850 ast.Node.MultilineStringLiteral {
2833 .base = undefined,2851 .base = undefined,
2834 .tokens = ArrayList(Token).init(arena),2852 .tokens = ArrayList(Token).init(arena),
2835 }2853 }
...@@ -2856,8 +2874,8 @@ pub const Parser = struct {...@@ -2856,8 +2874,8 @@ pub const Parser = struct {
2856 fn parseBlockExpr(self: &Parser, stack: &ArrayList(State), arena: &mem.Allocator, ctx: &const OptionalCtx, token: &const Token) !bool {2874 fn parseBlockExpr(self: &Parser, stack: &ArrayList(State), arena: &mem.Allocator, ctx: &const OptionalCtx, token: &const Token) !bool {
2857 switch (token.id) {2875 switch (token.id) {
2858 Token.Id.Keyword_suspend => {2876 Token.Id.Keyword_suspend => {
2859 const node = try self.createToCtxNode(arena, ctx, ast.NodeSuspend,2877 const node = try self.createToCtxNode(arena, ctx, ast.Node.Suspend,
2860 ast.NodeSuspend {2878 ast.Node.Suspend {
2861 .base = undefined,2879 .base = undefined,
2862 .suspend_token = *token,2880 .suspend_token = *token,
2863 .payload = null,2881 .payload = null,
...@@ -2870,8 +2888,8 @@ pub const Parser = struct {...@@ -2870,8 +2888,8 @@ pub const Parser = struct {
2870 return true;2888 return true;
2871 },2889 },
2872 Token.Id.Keyword_if => {2890 Token.Id.Keyword_if => {
2873 const node = try self.createToCtxNode(arena, ctx, ast.NodeIf,2891 const node = try self.createToCtxNode(arena, ctx, ast.Node.If,
2874 ast.NodeIf {2892 ast.Node.If {
2875 .base = undefined,2893 .base = undefined,
2876 .if_token = *token,2894 .if_token = *token,
2877 .condition = undefined,2895 .condition = undefined,
...@@ -2912,18 +2930,18 @@ pub const Parser = struct {...@@ -2912,18 +2930,18 @@ pub const Parser = struct {
2912 return true;2930 return true;
2913 },2931 },
2914 Token.Id.Keyword_switch => {2932 Token.Id.Keyword_switch => {
2915 const node = try self.createToCtxNode(arena, ctx, ast.NodeSwitch,2933 const node = try self.createToCtxNode(arena, ctx, ast.Node.Switch,
2916 ast.NodeSwitch {2934 ast.Node.Switch {
2917 .base = undefined,2935 .base = undefined,
2918 .switch_token = *token,2936 .switch_token = *token,
2919 .expr = undefined,2937 .expr = undefined,
2920 .cases = ArrayList(&ast.NodeSwitchCase).init(arena),2938 .cases = ArrayList(&ast.Node.SwitchCase).init(arena),
2921 .rbrace = undefined,2939 .rbrace = undefined,
2922 }2940 }
2923 );2941 );
29242942
2925 stack.append(State {2943 stack.append(State {
2926 .SwitchCaseOrEnd = ListSave(&ast.NodeSwitchCase) {2944 .SwitchCaseOrEnd = ListSave(&ast.Node.SwitchCase) {
2927 .list = &node.cases,2945 .list = &node.cases,
2928 .ptr = &node.rbrace,2946 .ptr = &node.rbrace,
2929 },2947 },
...@@ -2935,8 +2953,8 @@ pub const Parser = struct {...@@ -2935,8 +2953,8 @@ pub const Parser = struct {
2935 return true;2953 return true;
2936 },2954 },
2937 Token.Id.Keyword_comptime => {2955 Token.Id.Keyword_comptime => {
2938 const node = try self.createToCtxNode(arena, ctx, ast.NodeComptime,2956 const node = try self.createToCtxNode(arena, ctx, ast.Node.Comptime,
2939 ast.NodeComptime {2957 ast.Node.Comptime {
2940 .base = undefined,2958 .base = undefined,
2941 .comptime_token = *token,2959 .comptime_token = *token,
2942 .expr = undefined,2960 .expr = undefined,
...@@ -2946,8 +2964,8 @@ pub const Parser = struct {...@@ -2946,8 +2964,8 @@ pub const Parser = struct {
2946 return true;2964 return true;
2947 },2965 },
2948 Token.Id.LBrace => {2966 Token.Id.LBrace => {
2949 const block = try self.createToCtxNode(arena, ctx, ast.NodeBlock,2967 const block = try self.createToCtxNode(arena, ctx, ast.Node.Block,
2950 ast.NodeBlock {2968 ast.Node.Block {
2951 .base = undefined,2969 .base = undefined,
2952 .label = null,2970 .label = null,
2953 .lbrace = *token,2971 .lbrace = *token,
...@@ -2978,88 +2996,88 @@ pub const Parser = struct {...@@ -2978,88 +2996,88 @@ pub const Parser = struct {
2978 }2996 }
2979 }2997 }
29802998
2981 fn tokenIdToAssignment(id: &const Token.Id) ?ast.NodeInfixOp.InfixOp {2999 fn tokenIdToAssignment(id: &const Token.Id) ?ast.Node.InfixOp.Op {
2982 // TODO: We have to cast all cases because of this:3000 // TODO: We have to cast all cases because of this:
2983 // error: expected type '?InfixOp', found '?@TagType(InfixOp)'3001 // error: expected type '?InfixOp', found '?@TagType(InfixOp)'
2984 return switch (*id) {3002 return switch (*id) {
2985 Token.Id.AmpersandEqual => ast.NodeInfixOp.InfixOp { .AssignBitAnd = void{} },3003 Token.Id.AmpersandEqual => ast.Node.InfixOp.Op { .AssignBitAnd = void{} },
2986 Token.Id.AngleBracketAngleBracketLeftEqual => ast.NodeInfixOp.InfixOp { .AssignBitShiftLeft = void{} },3004 Token.Id.AngleBracketAngleBracketLeftEqual => ast.Node.InfixOp.Op { .AssignBitShiftLeft = void{} },
2987 Token.Id.AngleBracketAngleBracketRightEqual => ast.NodeInfixOp.InfixOp { .AssignBitShiftRight = void{} },3005 Token.Id.AngleBracketAngleBracketRightEqual => ast.Node.InfixOp.Op { .AssignBitShiftRight = void{} },
2988 Token.Id.AsteriskEqual => ast.NodeInfixOp.InfixOp { .AssignTimes = void{} },3006 Token.Id.AsteriskEqual => ast.Node.InfixOp.Op { .AssignTimes = void{} },
2989 Token.Id.AsteriskPercentEqual => ast.NodeInfixOp.InfixOp { .AssignTimesWarp = void{} },3007 Token.Id.AsteriskPercentEqual => ast.Node.InfixOp.Op { .AssignTimesWarp = void{} },
2990 Token.Id.CaretEqual => ast.NodeInfixOp.InfixOp { .AssignBitXor = void{} },3008 Token.Id.CaretEqual => ast.Node.InfixOp.Op { .AssignBitXor = void{} },
2991 Token.Id.Equal => ast.NodeInfixOp.InfixOp { .Assign = void{} },3009 Token.Id.Equal => ast.Node.InfixOp.Op { .Assign = void{} },
2992 Token.Id.MinusEqual => ast.NodeInfixOp.InfixOp { .AssignMinus = void{} },3010 Token.Id.MinusEqual => ast.Node.InfixOp.Op { .AssignMinus = void{} },
2993 Token.Id.MinusPercentEqual => ast.NodeInfixOp.InfixOp { .AssignMinusWrap = void{} },3011 Token.Id.MinusPercentEqual => ast.Node.InfixOp.Op { .AssignMinusWrap = void{} },
2994 Token.Id.PercentEqual => ast.NodeInfixOp.InfixOp { .AssignMod = void{} },3012 Token.Id.PercentEqual => ast.Node.InfixOp.Op { .AssignMod = void{} },
2995 Token.Id.PipeEqual => ast.NodeInfixOp.InfixOp { .AssignBitOr = void{} },3013 Token.Id.PipeEqual => ast.Node.InfixOp.Op { .AssignBitOr = void{} },
2996 Token.Id.PlusEqual => ast.NodeInfixOp.InfixOp { .AssignPlus = void{} },3014 Token.Id.PlusEqual => ast.Node.InfixOp.Op { .AssignPlus = void{} },
2997 Token.Id.PlusPercentEqual => ast.NodeInfixOp.InfixOp { .AssignPlusWrap = void{} },3015 Token.Id.PlusPercentEqual => ast.Node.InfixOp.Op { .AssignPlusWrap = void{} },
2998 Token.Id.SlashEqual => ast.NodeInfixOp.InfixOp { .AssignDiv = void{} },3016 Token.Id.SlashEqual => ast.Node.InfixOp.Op { .AssignDiv = void{} },
2999 else => null,3017 else => null,
3000 };3018 };
3001 }3019 }
30023020
3003 fn tokenIdToUnwrapExpr(id: @TagType(Token.Id)) ?ast.NodeInfixOp.InfixOp {3021 fn tokenIdToUnwrapExpr(id: @TagType(Token.Id)) ?ast.Node.InfixOp.Op {
3004 return switch (id) {3022 return switch (id) {
3005 Token.Id.Keyword_catch => ast.NodeInfixOp.InfixOp { .Catch = null },3023 Token.Id.Keyword_catch => ast.Node.InfixOp.Op { .Catch = null },
3006 Token.Id.QuestionMarkQuestionMark => ast.NodeInfixOp.InfixOp { .UnwrapMaybe = void{} },3024 Token.Id.QuestionMarkQuestionMark => ast.Node.InfixOp.Op { .UnwrapMaybe = void{} },
3007 else => null,3025 else => null,
3008 };3026 };
3009 }3027 }
30103028
3011 fn tokenIdToComparison(id: @TagType(Token.Id)) ?ast.NodeInfixOp.InfixOp {3029 fn tokenIdToComparison(id: @TagType(Token.Id)) ?ast.Node.InfixOp.Op {
3012 return switch (id) {3030 return switch (id) {
3013 Token.Id.BangEqual => ast.NodeInfixOp.InfixOp { .BangEqual = void{} },3031 Token.Id.BangEqual => ast.Node.InfixOp.Op { .BangEqual = void{} },
3014 Token.Id.EqualEqual => ast.NodeInfixOp.InfixOp { .EqualEqual = void{} },3032 Token.Id.EqualEqual => ast.Node.InfixOp.Op { .EqualEqual = void{} },
3015 Token.Id.AngleBracketLeft => ast.NodeInfixOp.InfixOp { .LessThan = void{} },3033 Token.Id.AngleBracketLeft => ast.Node.InfixOp.Op { .LessThan = void{} },
3016 Token.Id.AngleBracketLeftEqual => ast.NodeInfixOp.InfixOp { .LessOrEqual = void{} },3034 Token.Id.AngleBracketLeftEqual => ast.Node.InfixOp.Op { .LessOrEqual = void{} },
3017 Token.Id.AngleBracketRight => ast.NodeInfixOp.InfixOp { .GreaterThan = void{} },3035 Token.Id.AngleBracketRight => ast.Node.InfixOp.Op { .GreaterThan = void{} },
3018 Token.Id.AngleBracketRightEqual => ast.NodeInfixOp.InfixOp { .GreaterOrEqual = void{} },3036 Token.Id.AngleBracketRightEqual => ast.Node.InfixOp.Op { .GreaterOrEqual = void{} },
3019 else => null,3037 else => null,
3020 };3038 };
3021 }3039 }
30223040
3023 fn tokenIdToBitShift(id: @TagType(Token.Id)) ?ast.NodeInfixOp.InfixOp {3041 fn tokenIdToBitShift(id: @TagType(Token.Id)) ?ast.Node.InfixOp.Op {
3024 return switch (id) {3042 return switch (id) {
3025 Token.Id.AngleBracketAngleBracketLeft => ast.NodeInfixOp.InfixOp { .BitShiftLeft = void{} },3043 Token.Id.AngleBracketAngleBracketLeft => ast.Node.InfixOp.Op { .BitShiftLeft = void{} },
3026 Token.Id.AngleBracketAngleBracketRight => ast.NodeInfixOp.InfixOp { .BitShiftRight = void{} },3044 Token.Id.AngleBracketAngleBracketRight => ast.Node.InfixOp.Op { .BitShiftRight = void{} },
3027 else => null,3045 else => null,
3028 };3046 };
3029 }3047 }
30303048
3031 fn tokenIdToAddition(id: @TagType(Token.Id)) ?ast.NodeInfixOp.InfixOp {3049 fn tokenIdToAddition(id: @TagType(Token.Id)) ?ast.Node.InfixOp.Op {
3032 return switch (id) {3050 return switch (id) {
3033 Token.Id.Minus => ast.NodeInfixOp.InfixOp { .Sub = void{} },3051 Token.Id.Minus => ast.Node.InfixOp.Op { .Sub = void{} },
3034 Token.Id.MinusPercent => ast.NodeInfixOp.InfixOp { .SubWrap = void{} },3052 Token.Id.MinusPercent => ast.Node.InfixOp.Op { .SubWrap = void{} },
3035 Token.Id.Plus => ast.NodeInfixOp.InfixOp { .Add = void{} },3053 Token.Id.Plus => ast.Node.InfixOp.Op { .Add = void{} },
3036 Token.Id.PlusPercent => ast.NodeInfixOp.InfixOp { .AddWrap = void{} },3054 Token.Id.PlusPercent => ast.Node.InfixOp.Op { .AddWrap = void{} },
3037 Token.Id.PlusPlus => ast.NodeInfixOp.InfixOp { .ArrayCat = void{} },3055 Token.Id.PlusPlus => ast.Node.InfixOp.Op { .ArrayCat = void{} },
3038 else => null,3056 else => null,
3039 };3057 };
3040 }3058 }
30413059
3042 fn tokenIdToMultiply(id: @TagType(Token.Id)) ?ast.NodeInfixOp.InfixOp {3060 fn tokenIdToMultiply(id: @TagType(Token.Id)) ?ast.Node.InfixOp.Op {
3043 return switch (id) {3061 return switch (id) {
3044 Token.Id.Slash => ast.NodeInfixOp.InfixOp { .Div = void{} },3062 Token.Id.Slash => ast.Node.InfixOp.Op { .Div = void{} },
3045 Token.Id.Asterisk => ast.NodeInfixOp.InfixOp { .Mult = void{} },3063 Token.Id.Asterisk => ast.Node.InfixOp.Op { .Mult = void{} },
3046 Token.Id.AsteriskAsterisk => ast.NodeInfixOp.InfixOp { .ArrayMult = void{} },3064 Token.Id.AsteriskAsterisk => ast.Node.InfixOp.Op { .ArrayMult = void{} },
3047 Token.Id.AsteriskPercent => ast.NodeInfixOp.InfixOp { .MultWrap = void{} },3065 Token.Id.AsteriskPercent => ast.Node.InfixOp.Op { .MultWrap = void{} },
3048 Token.Id.Percent => ast.NodeInfixOp.InfixOp { .Mod = void{} },3066 Token.Id.Percent => ast.Node.InfixOp.Op { .Mod = void{} },
3049 Token.Id.PipePipe => ast.NodeInfixOp.InfixOp { .MergeErrorSets = void{} },3067 Token.Id.PipePipe => ast.Node.InfixOp.Op { .MergeErrorSets = void{} },
3050 else => null,3068 else => null,
3051 };3069 };
3052 }3070 }
30533071
3054 fn tokenIdToPrefixOp(id: @TagType(Token.Id)) ?ast.NodePrefixOp.PrefixOp {3072 fn tokenIdToPrefixOp(id: @TagType(Token.Id)) ?ast.Node.PrefixOp.Op {
3055 return switch (id) {3073 return switch (id) {
3056 Token.Id.Bang => ast.NodePrefixOp.PrefixOp { .BoolNot = void{} },3074 Token.Id.Bang => ast.Node.PrefixOp.Op { .BoolNot = void{} },
3057 Token.Id.Tilde => ast.NodePrefixOp.PrefixOp { .BitNot = void{} },3075 Token.Id.Tilde => ast.Node.PrefixOp.Op { .BitNot = void{} },
3058 Token.Id.Minus => ast.NodePrefixOp.PrefixOp { .Negation = void{} },3076 Token.Id.Minus => ast.Node.PrefixOp.Op { .Negation = void{} },
3059 Token.Id.MinusPercent => ast.NodePrefixOp.PrefixOp { .NegationWrap = void{} },3077 Token.Id.MinusPercent => ast.Node.PrefixOp.Op { .NegationWrap = void{} },
3060 Token.Id.Asterisk, Token.Id.AsteriskAsterisk => ast.NodePrefixOp.PrefixOp { .Deref = void{} },3078 Token.Id.Asterisk, Token.Id.AsteriskAsterisk => ast.Node.PrefixOp.Op { .Deref = void{} },
3061 Token.Id.Ampersand => ast.NodePrefixOp.PrefixOp {3079 Token.Id.Ampersand => ast.Node.PrefixOp.Op {
3062 .AddrOf = ast.NodePrefixOp.AddrOfInfo {3080 .AddrOf = ast.Node.PrefixOp.AddrOfInfo {
3063 .align_expr = null,3081 .align_expr = null,
3064 .bit_offset_start_token = null,3082 .bit_offset_start_token = null,
3065 .bit_offset_end_token = null,3083 .bit_offset_end_token = null,
...@@ -3067,10 +3085,10 @@ pub const Parser = struct {...@@ -3067,10 +3085,10 @@ pub const Parser = struct {
3067 .volatile_token = null,3085 .volatile_token = null,
3068 },3086 },
3069 },3087 },
3070 Token.Id.QuestionMark => ast.NodePrefixOp.PrefixOp { .MaybeType = void{} },3088 Token.Id.QuestionMark => ast.Node.PrefixOp.Op { .MaybeType = void{} },
3071 Token.Id.QuestionMarkQuestionMark => ast.NodePrefixOp.PrefixOp { .UnwrapMaybe = void{} },3089 Token.Id.QuestionMarkQuestionMark => ast.Node.PrefixOp.Op { .UnwrapMaybe = void{} },
3072 Token.Id.Keyword_await => ast.NodePrefixOp.PrefixOp { .Await = void{} },3090 Token.Id.Keyword_await => ast.Node.PrefixOp.Op { .Await = void{} },
3073 Token.Id.Keyword_try => ast.NodePrefixOp.PrefixOp { .Try = void{ } },3091 Token.Id.Keyword_try => ast.Node.PrefixOp.Op { .Try = void{ } },
3074 else => null,3092 else => null,
3075 };3093 };
3076 }3094 }
...@@ -3080,11 +3098,7 @@ pub const Parser = struct {...@@ -3080,11 +3098,7 @@ pub const Parser = struct {
3080 *node = *init_to;3098 *node = *init_to;
3081 node.base = blk: {3099 node.base = blk: {
3082 const id = ast.Node.typeToId(T);3100 const id = ast.Node.typeToId(T);
3083 if (self.pending_line_comment_node) |comment_node| {3101 break :blk ast.Node {.id = id};
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 };
3088 };3102 };
30893103
3090 return node;3104 return node;
...@@ -3183,7 +3197,7 @@ pub const Parser = struct {...@@ -3183,7 +3197,7 @@ pub const Parser = struct {
3183 indent: usize,3197 indent: usize,
3184 };3198 };
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 {
3187 var stack = self.initUtilityArrayList(RenderAstFrame);3201 var stack = self.initUtilityArrayList(RenderAstFrame);
3188 defer self.deinitUtilityArrayList(stack);3202 defer self.deinitUtilityArrayList(stack);
31893203
...@@ -3215,14 +3229,14 @@ pub const Parser = struct {...@@ -3215,14 +3229,14 @@ pub const Parser = struct {
3215 ParamDecl: &ast.Node,3229 ParamDecl: &ast.Node,
3216 Text: []const u8,3230 Text: []const u8,
3217 Expression: &ast.Node,3231 Expression: &ast.Node,
3218 VarDecl: &ast.NodeVarDecl,3232 VarDecl: &ast.Node.VarDecl,
3219 Statement: &ast.Node,3233 Statement: &ast.Node,
3220 FieldInitializer: &ast.NodeFieldInitializer,3234 FieldInitializer: &ast.Node.FieldInitializer,
3221 PrintIndent,3235 PrintIndent,
3222 Indent: usize,3236 Indent: usize,
3223 };3237 };
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 {
3226 var stack = self.initUtilityArrayList(RenderState);3240 var stack = self.initUtilityArrayList(RenderState);
3227 defer self.deinitUtilityArrayList(stack);3241 defer self.deinitUtilityArrayList(stack);
32283242
...@@ -3256,7 +3270,8 @@ pub const Parser = struct {...@@ -3256,7 +3270,8 @@ pub const Parser = struct {
3256 RenderState.TopLevelDecl => |decl| {3270 RenderState.TopLevelDecl => |decl| {
3257 switch (decl.id) {3271 switch (decl.id) {
3258 ast.Node.Id.FnProto => {3272 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
3261 if (fn_proto.body_node) |body_node| {3276 if (fn_proto.body_node) |body_node| {
3262 stack.append(RenderState { .Expression = body_node}) catch unreachable;3277 stack.append(RenderState { .Expression = body_node}) catch unreachable;
...@@ -3268,7 +3283,7 @@ pub const Parser = struct {...@@ -3268,7 +3283,7 @@ pub const Parser = struct {
3268 try stack.append(RenderState { .Expression = decl });3283 try stack.append(RenderState { .Expression = decl });
3269 },3284 },
3270 ast.Node.Id.Use => {3285 ast.Node.Id.Use => {
3271 const use_decl = @fieldParentPtr(ast.NodeUse, "base", decl);3286 const use_decl = @fieldParentPtr(ast.Node.Use, "base", decl);
3272 if (use_decl.visib_token) |visib_token| {3287 if (use_decl.visib_token) |visib_token| {
3273 try stream.print("{} ", self.tokenizer.getTokenSlice(visib_token));3288 try stream.print("{} ", self.tokenizer.getTokenSlice(visib_token));
3274 }3289 }
...@@ -3277,18 +3292,19 @@ pub const Parser = struct {...@@ -3277,18 +3292,19 @@ pub const Parser = struct {
3277 try stack.append(RenderState { .Expression = use_decl.expr });3292 try stack.append(RenderState { .Expression = use_decl.expr });
3278 },3293 },
3279 ast.Node.Id.VarDecl => {3294 ast.Node.Id.VarDecl => {
3280 const var_decl = @fieldParentPtr(ast.NodeVarDecl, "base", decl);3295 const var_decl = @fieldParentPtr(ast.Node.VarDecl, "base", decl);
3281 try stack.append(RenderState { .VarDecl = var_decl});3296 try stack.append(RenderState { .VarDecl = var_decl});
3282 },3297 },
3283 ast.Node.Id.TestDecl => {3298 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);
3285 try stream.print("test ");3301 try stream.print("test ");
3286 try stack.append(RenderState { .Expression = test_decl.body_node });3302 try stack.append(RenderState { .Expression = test_decl.body_node });
3287 try stack.append(RenderState { .Text = " " });3303 try stack.append(RenderState { .Text = " " });
3288 try stack.append(RenderState { .Expression = test_decl.name });3304 try stack.append(RenderState { .Expression = test_decl.name });
3289 },3305 },
3290 ast.Node.Id.StructField => {3306 ast.Node.Id.StructField => {
3291 const field = @fieldParentPtr(ast.NodeStructField, "base", decl);3307 const field = @fieldParentPtr(ast.Node.StructField, "base", decl);
3292 if (field.visib_token) |visib_token| {3308 if (field.visib_token) |visib_token| {
3293 try stream.print("{} ", self.tokenizer.getTokenSlice(visib_token));3309 try stream.print("{} ", self.tokenizer.getTokenSlice(visib_token));
3294 }3310 }
...@@ -3296,7 +3312,7 @@ pub const Parser = struct {...@@ -3296,7 +3312,7 @@ pub const Parser = struct {
3296 try stack.append(RenderState { .Expression = field.type_expr});3312 try stack.append(RenderState { .Expression = field.type_expr});
3297 },3313 },
3298 ast.Node.Id.UnionTag => {3314 ast.Node.Id.UnionTag => {
3299 const tag = @fieldParentPtr(ast.NodeUnionTag, "base", decl);3315 const tag = @fieldParentPtr(ast.Node.UnionTag, "base", decl);
3300 try stream.print("{}", self.tokenizer.getTokenSlice(tag.name_token));3316 try stream.print("{}", self.tokenizer.getTokenSlice(tag.name_token));
33013317
3302 if (tag.type_expr) |type_expr| {3318 if (tag.type_expr) |type_expr| {
...@@ -3305,7 +3321,7 @@ pub const Parser = struct {...@@ -3305,7 +3321,7 @@ pub const Parser = struct {
3305 }3321 }
3306 },3322 },
3307 ast.Node.Id.EnumTag => {3323 ast.Node.Id.EnumTag => {
3308 const tag = @fieldParentPtr(ast.NodeEnumTag, "base", decl);3324 const tag = @fieldParentPtr(ast.Node.EnumTag, "base", decl);
3309 try stream.print("{}", self.tokenizer.getTokenSlice(tag.name_token));3325 try stream.print("{}", self.tokenizer.getTokenSlice(tag.name_token));
33103326
3311 if (tag.value) |value| {3327 if (tag.value) |value| {
...@@ -3324,6 +3340,7 @@ pub const Parser = struct {...@@ -3324,6 +3340,7 @@ pub const Parser = struct {
3324 },3340 },
33253341
3326 RenderState.FieldInitializer => |field_init| {3342 RenderState.FieldInitializer => |field_init| {
3343 //TODO try self.renderComments(stream, field_init, indent);
3327 try stream.print(".{}", self.tokenizer.getTokenSlice(field_init.name_token));3344 try stream.print(".{}", self.tokenizer.getTokenSlice(field_init.name_token));
3328 try stream.print(" = ");3345 try stream.print(" = ");
3329 try stack.append(RenderState { .Expression = field_init.expr });3346 try stack.append(RenderState { .Expression = field_init.expr });
...@@ -3369,7 +3386,8 @@ pub const Parser = struct {...@@ -3369,7 +3386,8 @@ pub const Parser = struct {
3369 },3386 },
33703387
3371 RenderState.ParamDecl => |base| {3388 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);
3373 if (param_decl.comptime_token) |comptime_token| {3391 if (param_decl.comptime_token) |comptime_token| {
3374 try stream.print("{} ", self.tokenizer.getTokenSlice(comptime_token));3392 try stream.print("{} ", self.tokenizer.getTokenSlice(comptime_token));
3375 }3393 }
...@@ -3390,11 +3408,11 @@ pub const Parser = struct {...@@ -3390,11 +3408,11 @@ pub const Parser = struct {
3390 },3408 },
3391 RenderState.Expression => |base| switch (base.id) {3409 RenderState.Expression => |base| switch (base.id) {
3392 ast.Node.Id.Identifier => {3410 ast.Node.Id.Identifier => {
3393 const identifier = @fieldParentPtr(ast.NodeIdentifier, "base", base);3411 const identifier = @fieldParentPtr(ast.Node.Identifier, "base", base);
3394 try stream.print("{}", self.tokenizer.getTokenSlice(identifier.token));3412 try stream.print("{}", self.tokenizer.getTokenSlice(identifier.token));
3395 },3413 },
3396 ast.Node.Id.Block => {3414 ast.Node.Id.Block => {
3397 const block = @fieldParentPtr(ast.NodeBlock, "base", base);3415 const block = @fieldParentPtr(ast.Node.Block, "base", base);
3398 if (block.label) |label| {3416 if (block.label) |label| {
3399 try stream.print("{}: ", self.tokenizer.getTokenSlice(label));3417 try stream.print("{}: ", self.tokenizer.getTokenSlice(label));
3400 }3418 }
...@@ -3430,17 +3448,17 @@ pub const Parser = struct {...@@ -3430,17 +3448,17 @@ pub const Parser = struct {
3430 }3448 }
3431 },3449 },
3432 ast.Node.Id.Defer => {3450 ast.Node.Id.Defer => {
3433 const defer_node = @fieldParentPtr(ast.NodeDefer, "base", base);3451 const defer_node = @fieldParentPtr(ast.Node.Defer, "base", base);
3434 try stream.print("{} ", self.tokenizer.getTokenSlice(defer_node.defer_token));3452 try stream.print("{} ", self.tokenizer.getTokenSlice(defer_node.defer_token));
3435 try stack.append(RenderState { .Expression = defer_node.expr });3453 try stack.append(RenderState { .Expression = defer_node.expr });
3436 },3454 },
3437 ast.Node.Id.Comptime => {3455 ast.Node.Id.Comptime => {
3438 const comptime_node = @fieldParentPtr(ast.NodeComptime, "base", base);3456 const comptime_node = @fieldParentPtr(ast.Node.Comptime, "base", base);
3439 try stream.print("{} ", self.tokenizer.getTokenSlice(comptime_node.comptime_token));3457 try stream.print("{} ", self.tokenizer.getTokenSlice(comptime_node.comptime_token));
3440 try stack.append(RenderState { .Expression = comptime_node.expr });3458 try stack.append(RenderState { .Expression = comptime_node.expr });
3441 },3459 },
3442 ast.Node.Id.AsyncAttribute => {3460 ast.Node.Id.AsyncAttribute => {
3443 const async_attr = @fieldParentPtr(ast.NodeAsyncAttribute, "base", base);3461 const async_attr = @fieldParentPtr(ast.Node.AsyncAttribute, "base", base);
3444 try stream.print("{}", self.tokenizer.getTokenSlice(async_attr.async_token));3462 try stream.print("{}", self.tokenizer.getTokenSlice(async_attr.async_token));
34453463
3446 if (async_attr.allocator_type) |allocator_type| {3464 if (async_attr.allocator_type) |allocator_type| {
...@@ -3450,7 +3468,7 @@ pub const Parser = struct {...@@ -3450,7 +3468,7 @@ pub const Parser = struct {
3450 }3468 }
3451 },3469 },
3452 ast.Node.Id.Suspend => {3470 ast.Node.Id.Suspend => {
3453 const suspend_node = @fieldParentPtr(ast.NodeSuspend, "base", base);3471 const suspend_node = @fieldParentPtr(ast.Node.Suspend, "base", base);
3454 try stream.print("{}", self.tokenizer.getTokenSlice(suspend_node.suspend_token));3472 try stream.print("{}", self.tokenizer.getTokenSlice(suspend_node.suspend_token));
34553473
3456 if (suspend_node.body) |body| {3474 if (suspend_node.body) |body| {
...@@ -3464,10 +3482,10 @@ pub const Parser = struct {...@@ -3464,10 +3482,10 @@ pub const Parser = struct {
3464 }3482 }
3465 },3483 },
3466 ast.Node.Id.InfixOp => {3484 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);
3468 try stack.append(RenderState { .Expression = prefix_op_node.rhs });3486 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) {
3471 if (prefix_op_node.op.Catch) |payload| {3489 if (prefix_op_node.op.Catch) |payload| {
3472 try stack.append(RenderState { .Text = " " });3490 try stack.append(RenderState { .Text = " " });
3473 try stack.append(RenderState { .Expression = payload });3491 try stack.append(RenderState { .Expression = payload });
...@@ -3475,49 +3493,49 @@ pub const Parser = struct {...@@ -3475,49 +3493,49 @@ pub const Parser = struct {
3475 try stack.append(RenderState { .Text = " catch " });3493 try stack.append(RenderState { .Text = " catch " });
3476 } else {3494 } else {
3477 const text = switch (prefix_op_node.op) {3495 const text = switch (prefix_op_node.op) {
3478 ast.NodeInfixOp.InfixOp.Add => " + ",3496 ast.Node.InfixOp.Op.Add => " + ",
3479 ast.NodeInfixOp.InfixOp.AddWrap => " +% ",3497 ast.Node.InfixOp.Op.AddWrap => " +% ",
3480 ast.NodeInfixOp.InfixOp.ArrayCat => " ++ ",3498 ast.Node.InfixOp.Op.ArrayCat => " ++ ",
3481 ast.NodeInfixOp.InfixOp.ArrayMult => " ** ",3499 ast.Node.InfixOp.Op.ArrayMult => " ** ",
3482 ast.NodeInfixOp.InfixOp.Assign => " = ",3500 ast.Node.InfixOp.Op.Assign => " = ",
3483 ast.NodeInfixOp.InfixOp.AssignBitAnd => " &= ",3501 ast.Node.InfixOp.Op.AssignBitAnd => " &= ",
3484 ast.NodeInfixOp.InfixOp.AssignBitOr => " |= ",3502 ast.Node.InfixOp.Op.AssignBitOr => " |= ",
3485 ast.NodeInfixOp.InfixOp.AssignBitShiftLeft => " <<= ",3503 ast.Node.InfixOp.Op.AssignBitShiftLeft => " <<= ",
3486 ast.NodeInfixOp.InfixOp.AssignBitShiftRight => " >>= ",3504 ast.Node.InfixOp.Op.AssignBitShiftRight => " >>= ",
3487 ast.NodeInfixOp.InfixOp.AssignBitXor => " ^= ",3505 ast.Node.InfixOp.Op.AssignBitXor => " ^= ",
3488 ast.NodeInfixOp.InfixOp.AssignDiv => " /= ",3506 ast.Node.InfixOp.Op.AssignDiv => " /= ",
3489 ast.NodeInfixOp.InfixOp.AssignMinus => " -= ",3507 ast.Node.InfixOp.Op.AssignMinus => " -= ",
3490 ast.NodeInfixOp.InfixOp.AssignMinusWrap => " -%= ",3508 ast.Node.InfixOp.Op.AssignMinusWrap => " -%= ",
3491 ast.NodeInfixOp.InfixOp.AssignMod => " %= ",3509 ast.Node.InfixOp.Op.AssignMod => " %= ",
3492 ast.NodeInfixOp.InfixOp.AssignPlus => " += ",3510 ast.Node.InfixOp.Op.AssignPlus => " += ",
3493 ast.NodeInfixOp.InfixOp.AssignPlusWrap => " +%= ",3511 ast.Node.InfixOp.Op.AssignPlusWrap => " +%= ",
3494 ast.NodeInfixOp.InfixOp.AssignTimes => " *= ",3512 ast.Node.InfixOp.Op.AssignTimes => " *= ",
3495 ast.NodeInfixOp.InfixOp.AssignTimesWarp => " *%= ",3513 ast.Node.InfixOp.Op.AssignTimesWarp => " *%= ",
3496 ast.NodeInfixOp.InfixOp.BangEqual => " != ",3514 ast.Node.InfixOp.Op.BangEqual => " != ",
3497 ast.NodeInfixOp.InfixOp.BitAnd => " & ",3515 ast.Node.InfixOp.Op.BitAnd => " & ",
3498 ast.NodeInfixOp.InfixOp.BitOr => " | ",3516 ast.Node.InfixOp.Op.BitOr => " | ",
3499 ast.NodeInfixOp.InfixOp.BitShiftLeft => " << ",3517 ast.Node.InfixOp.Op.BitShiftLeft => " << ",
3500 ast.NodeInfixOp.InfixOp.BitShiftRight => " >> ",3518 ast.Node.InfixOp.Op.BitShiftRight => " >> ",
3501 ast.NodeInfixOp.InfixOp.BitXor => " ^ ",3519 ast.Node.InfixOp.Op.BitXor => " ^ ",
3502 ast.NodeInfixOp.InfixOp.BoolAnd => " and ",3520 ast.Node.InfixOp.Op.BoolAnd => " and ",
3503 ast.NodeInfixOp.InfixOp.BoolOr => " or ",3521 ast.Node.InfixOp.Op.BoolOr => " or ",
3504 ast.NodeInfixOp.InfixOp.Div => " / ",3522 ast.Node.InfixOp.Op.Div => " / ",
3505 ast.NodeInfixOp.InfixOp.EqualEqual => " == ",3523 ast.Node.InfixOp.Op.EqualEqual => " == ",
3506 ast.NodeInfixOp.InfixOp.ErrorUnion => "!",3524 ast.Node.InfixOp.Op.ErrorUnion => "!",
3507 ast.NodeInfixOp.InfixOp.GreaterOrEqual => " >= ",3525 ast.Node.InfixOp.Op.GreaterOrEqual => " >= ",
3508 ast.NodeInfixOp.InfixOp.GreaterThan => " > ",3526 ast.Node.InfixOp.Op.GreaterThan => " > ",
3509 ast.NodeInfixOp.InfixOp.LessOrEqual => " <= ",3527 ast.Node.InfixOp.Op.LessOrEqual => " <= ",
3510 ast.NodeInfixOp.InfixOp.LessThan => " < ",3528 ast.Node.InfixOp.Op.LessThan => " < ",
3511 ast.NodeInfixOp.InfixOp.MergeErrorSets => " || ",3529 ast.Node.InfixOp.Op.MergeErrorSets => " || ",
3512 ast.NodeInfixOp.InfixOp.Mod => " % ",3530 ast.Node.InfixOp.Op.Mod => " % ",
3513 ast.NodeInfixOp.InfixOp.Mult => " * ",3531 ast.Node.InfixOp.Op.Mult => " * ",
3514 ast.NodeInfixOp.InfixOp.MultWrap => " *% ",3532 ast.Node.InfixOp.Op.MultWrap => " *% ",
3515 ast.NodeInfixOp.InfixOp.Period => ".",3533 ast.Node.InfixOp.Op.Period => ".",
3516 ast.NodeInfixOp.InfixOp.Sub => " - ",3534 ast.Node.InfixOp.Op.Sub => " - ",
3517 ast.NodeInfixOp.InfixOp.SubWrap => " -% ",3535 ast.Node.InfixOp.Op.SubWrap => " -% ",
3518 ast.NodeInfixOp.InfixOp.UnwrapMaybe => " ?? ",3536 ast.Node.InfixOp.Op.UnwrapMaybe => " ?? ",
3519 ast.NodeInfixOp.InfixOp.Range => " ... ",3537 ast.Node.InfixOp.Op.Range => " ... ",
3520 ast.NodeInfixOp.InfixOp.Catch => unreachable,3538 ast.Node.InfixOp.Op.Catch => unreachable,
3521 };3539 };
35223540
3523 try stack.append(RenderState { .Text = text });3541 try stack.append(RenderState { .Text = text });
...@@ -3525,10 +3543,10 @@ pub const Parser = struct {...@@ -3525,10 +3543,10 @@ pub const Parser = struct {
3525 try stack.append(RenderState { .Expression = prefix_op_node.lhs });3543 try stack.append(RenderState { .Expression = prefix_op_node.lhs });
3526 },3544 },
3527 ast.Node.Id.PrefixOp => {3545 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);
3529 try stack.append(RenderState { .Expression = prefix_op_node.rhs });3547 try stack.append(RenderState { .Expression = prefix_op_node.rhs });
3530 switch (prefix_op_node.op) {3548 switch (prefix_op_node.op) {
3531 ast.NodePrefixOp.PrefixOp.AddrOf => |addr_of_info| {3549 ast.Node.PrefixOp.Op.AddrOf => |addr_of_info| {
3532 try stream.write("&");3550 try stream.write("&");
3533 if (addr_of_info.volatile_token != null) {3551 if (addr_of_info.volatile_token != null) {
3534 try stack.append(RenderState { .Text = "volatile "});3552 try stack.append(RenderState { .Text = "volatile "});
...@@ -3542,7 +3560,7 @@ pub const Parser = struct {...@@ -3542,7 +3560,7 @@ pub const Parser = struct {
3542 try stack.append(RenderState { .Expression = align_expr});3560 try stack.append(RenderState { .Expression = align_expr});
3543 }3561 }
3544 },3562 },
3545 ast.NodePrefixOp.PrefixOp.SliceType => |addr_of_info| {3563 ast.Node.PrefixOp.Op.SliceType => |addr_of_info| {
3546 try stream.write("[]");3564 try stream.write("[]");
3547 if (addr_of_info.volatile_token != null) {3565 if (addr_of_info.volatile_token != null) {
3548 try stack.append(RenderState { .Text = "volatile "});3566 try stack.append(RenderState { .Text = "volatile "});
...@@ -3556,29 +3574,29 @@ pub const Parser = struct {...@@ -3556,29 +3574,29 @@ pub const Parser = struct {
3556 try stack.append(RenderState { .Expression = align_expr});3574 try stack.append(RenderState { .Expression = align_expr});
3557 }3575 }
3558 },3576 },
3559 ast.NodePrefixOp.PrefixOp.ArrayType => |array_index| {3577 ast.Node.PrefixOp.Op.ArrayType => |array_index| {
3560 try stack.append(RenderState { .Text = "]"});3578 try stack.append(RenderState { .Text = "]"});
3561 try stack.append(RenderState { .Expression = array_index});3579 try stack.append(RenderState { .Expression = array_index});
3562 try stack.append(RenderState { .Text = "["});3580 try stack.append(RenderState { .Text = "["});
3563 },3581 },
3564 ast.NodePrefixOp.PrefixOp.BitNot => try stream.write("~"),3582 ast.Node.PrefixOp.Op.BitNot => try stream.write("~"),
3565 ast.NodePrefixOp.PrefixOp.BoolNot => try stream.write("!"),3583 ast.Node.PrefixOp.Op.BoolNot => try stream.write("!"),
3566 ast.NodePrefixOp.PrefixOp.Deref => try stream.write("*"),3584 ast.Node.PrefixOp.Op.Deref => try stream.write("*"),
3567 ast.NodePrefixOp.PrefixOp.Negation => try stream.write("-"),3585 ast.Node.PrefixOp.Op.Negation => try stream.write("-"),
3568 ast.NodePrefixOp.PrefixOp.NegationWrap => try stream.write("-%"),3586 ast.Node.PrefixOp.Op.NegationWrap => try stream.write("-%"),
3569 ast.NodePrefixOp.PrefixOp.Try => try stream.write("try "),3587 ast.Node.PrefixOp.Op.Try => try stream.write("try "),
3570 ast.NodePrefixOp.PrefixOp.UnwrapMaybe => try stream.write("??"),3588 ast.Node.PrefixOp.Op.UnwrapMaybe => try stream.write("??"),
3571 ast.NodePrefixOp.PrefixOp.MaybeType => try stream.write("?"),3589 ast.Node.PrefixOp.Op.MaybeType => try stream.write("?"),
3572 ast.NodePrefixOp.PrefixOp.Await => try stream.write("await "),3590 ast.Node.PrefixOp.Op.Await => try stream.write("await "),
3573 ast.NodePrefixOp.PrefixOp.Cancel => try stream.write("cancel "),3591 ast.Node.PrefixOp.Op.Cancel => try stream.write("cancel "),
3574 ast.NodePrefixOp.PrefixOp.Resume => try stream.write("resume "),3592 ast.Node.PrefixOp.Op.Resume => try stream.write("resume "),
3575 }3593 }
3576 },3594 },
3577 ast.Node.Id.SuffixOp => {3595 ast.Node.Id.SuffixOp => {
3578 const suffix_op = @fieldParentPtr(ast.NodeSuffixOp, "base", base);3596 const suffix_op = @fieldParentPtr(ast.Node.SuffixOp, "base", base);
35793597
3580 switch (suffix_op.op) {3598 switch (suffix_op.op) {
3581 ast.NodeSuffixOp.SuffixOp.Call => |call_info| {3599 ast.Node.SuffixOp.Op.Call => |call_info| {
3582 try stack.append(RenderState { .Text = ")"});3600 try stack.append(RenderState { .Text = ")"});
3583 var i = call_info.params.len;3601 var i = call_info.params.len;
3584 while (i != 0) {3602 while (i != 0) {
...@@ -3597,13 +3615,13 @@ pub const Parser = struct {...@@ -3597,13 +3615,13 @@ pub const Parser = struct {
3597 try stack.append(RenderState { .Expression = &async_attr.base });3615 try stack.append(RenderState { .Expression = &async_attr.base });
3598 }3616 }
3599 },3617 },
3600 ast.NodeSuffixOp.SuffixOp.ArrayAccess => |index_expr| {3618 ast.Node.SuffixOp.Op.ArrayAccess => |index_expr| {
3601 try stack.append(RenderState { .Text = "]"});3619 try stack.append(RenderState { .Text = "]"});
3602 try stack.append(RenderState { .Expression = index_expr});3620 try stack.append(RenderState { .Expression = index_expr});
3603 try stack.append(RenderState { .Text = "["});3621 try stack.append(RenderState { .Text = "["});
3604 try stack.append(RenderState { .Expression = suffix_op.lhs });3622 try stack.append(RenderState { .Expression = suffix_op.lhs });
3605 },3623 },
3606 ast.NodeSuffixOp.SuffixOp.Slice => |range| {3624 ast.Node.SuffixOp.Op.Slice => |range| {
3607 try stack.append(RenderState { .Text = "]"});3625 try stack.append(RenderState { .Text = "]"});
3608 if (range.end) |end| {3626 if (range.end) |end| {
3609 try stack.append(RenderState { .Expression = end});3627 try stack.append(RenderState { .Expression = end});
...@@ -3613,7 +3631,7 @@ pub const Parser = struct {...@@ -3613,7 +3631,7 @@ pub const Parser = struct {
3613 try stack.append(RenderState { .Text = "["});3631 try stack.append(RenderState { .Text = "["});
3614 try stack.append(RenderState { .Expression = suffix_op.lhs });3632 try stack.append(RenderState { .Expression = suffix_op.lhs });
3615 },3633 },
3616 ast.NodeSuffixOp.SuffixOp.StructInitializer => |field_inits| {3634 ast.Node.SuffixOp.Op.StructInitializer => |field_inits| {
3617 if (field_inits.len == 0) {3635 if (field_inits.len == 0) {
3618 try stack.append(RenderState { .Text = "{}" });3636 try stack.append(RenderState { .Text = "{}" });
3619 try stack.append(RenderState { .Expression = suffix_op.lhs });3637 try stack.append(RenderState { .Expression = suffix_op.lhs });
...@@ -3634,7 +3652,7 @@ pub const Parser = struct {...@@ -3634,7 +3652,7 @@ pub const Parser = struct {
3634 try stack.append(RenderState { .Text = " {\n"});3652 try stack.append(RenderState { .Text = " {\n"});
3635 try stack.append(RenderState { .Expression = suffix_op.lhs });3653 try stack.append(RenderState { .Expression = suffix_op.lhs });
3636 },3654 },
3637 ast.NodeSuffixOp.SuffixOp.ArrayInitializer => |exprs| {3655 ast.Node.SuffixOp.Op.ArrayInitializer => |exprs| {
3638 if (exprs.len == 0) {3656 if (exprs.len == 0) {
3639 try stack.append(RenderState { .Text = "{}" });3657 try stack.append(RenderState { .Text = "{}" });
3640 try stack.append(RenderState { .Expression = suffix_op.lhs });3658 try stack.append(RenderState { .Expression = suffix_op.lhs });
...@@ -3658,7 +3676,7 @@ pub const Parser = struct {...@@ -3658,7 +3676,7 @@ pub const Parser = struct {
3658 }3676 }
3659 },3677 },
3660 ast.Node.Id.ControlFlowExpression => {3678 ast.Node.Id.ControlFlowExpression => {
3661 const flow_expr = @fieldParentPtr(ast.NodeControlFlowExpression, "base", base);3679 const flow_expr = @fieldParentPtr(ast.Node.ControlFlowExpression, "base", base);
36623680
3663 if (flow_expr.rhs) |rhs| {3681 if (flow_expr.rhs) |rhs| {
3664 try stack.append(RenderState { .Expression = rhs });3682 try stack.append(RenderState { .Expression = rhs });
...@@ -3666,34 +3684,34 @@ pub const Parser = struct {...@@ -3666,34 +3684,34 @@ pub const Parser = struct {
3666 }3684 }
36673685
3668 switch (flow_expr.kind) {3686 switch (flow_expr.kind) {
3669 ast.NodeControlFlowExpression.Kind.Break => |maybe_label| {3687 ast.Node.ControlFlowExpression.Kind.Break => |maybe_label| {
3670 try stream.print("break");3688 try stream.print("break");
3671 if (maybe_label) |label| {3689 if (maybe_label) |label| {
3672 try stream.print(" :");3690 try stream.print(" :");
3673 try stack.append(RenderState { .Expression = label });3691 try stack.append(RenderState { .Expression = label });
3674 }3692 }
3675 },3693 },
3676 ast.NodeControlFlowExpression.Kind.Continue => |maybe_label| {3694 ast.Node.ControlFlowExpression.Kind.Continue => |maybe_label| {
3677 try stream.print("continue");3695 try stream.print("continue");
3678 if (maybe_label) |label| {3696 if (maybe_label) |label| {
3679 try stream.print(" :");3697 try stream.print(" :");
3680 try stack.append(RenderState { .Expression = label });3698 try stack.append(RenderState { .Expression = label });
3681 }3699 }
3682 },3700 },
3683 ast.NodeControlFlowExpression.Kind.Return => {3701 ast.Node.ControlFlowExpression.Kind.Return => {
3684 try stream.print("return");3702 try stream.print("return");
3685 },3703 },
36863704
3687 }3705 }
3688 },3706 },
3689 ast.Node.Id.Payload => {3707 ast.Node.Id.Payload => {
3690 const payload = @fieldParentPtr(ast.NodePayload, "base", base);3708 const payload = @fieldParentPtr(ast.Node.Payload, "base", base);
3691 try stack.append(RenderState { .Text = "|"});3709 try stack.append(RenderState { .Text = "|"});
3692 try stack.append(RenderState { .Expression = payload.error_symbol });3710 try stack.append(RenderState { .Expression = payload.error_symbol });
3693 try stack.append(RenderState { .Text = "|"});3711 try stack.append(RenderState { .Text = "|"});
3694 },3712 },
3695 ast.Node.Id.PointerPayload => {3713 ast.Node.Id.PointerPayload => {
3696 const payload = @fieldParentPtr(ast.NodePointerPayload, "base", base);3714 const payload = @fieldParentPtr(ast.Node.PointerPayload, "base", base);
3697 try stack.append(RenderState { .Text = "|"});3715 try stack.append(RenderState { .Text = "|"});
3698 try stack.append(RenderState { .Expression = payload.value_symbol });3716 try stack.append(RenderState { .Expression = payload.value_symbol });
36993717
...@@ -3704,7 +3722,7 @@ pub const Parser = struct {...@@ -3704,7 +3722,7 @@ pub const Parser = struct {
3704 try stack.append(RenderState { .Text = "|"});3722 try stack.append(RenderState { .Text = "|"});
3705 },3723 },
3706 ast.Node.Id.PointerIndexPayload => {3724 ast.Node.Id.PointerIndexPayload => {
3707 const payload = @fieldParentPtr(ast.NodePointerIndexPayload, "base", base);3725 const payload = @fieldParentPtr(ast.Node.PointerIndexPayload, "base", base);
3708 try stack.append(RenderState { .Text = "|"});3726 try stack.append(RenderState { .Text = "|"});
37093727
3710 if (payload.index_symbol) |index_symbol| {3728 if (payload.index_symbol) |index_symbol| {
...@@ -3721,69 +3739,69 @@ pub const Parser = struct {...@@ -3721,69 +3739,69 @@ pub const Parser = struct {
3721 try stack.append(RenderState { .Text = "|"});3739 try stack.append(RenderState { .Text = "|"});
3722 },3740 },
3723 ast.Node.Id.GroupedExpression => {3741 ast.Node.Id.GroupedExpression => {
3724 const grouped_expr = @fieldParentPtr(ast.NodeGroupedExpression, "base", base);3742 const grouped_expr = @fieldParentPtr(ast.Node.GroupedExpression, "base", base);
3725 try stack.append(RenderState { .Text = ")"});3743 try stack.append(RenderState { .Text = ")"});
3726 try stack.append(RenderState { .Expression = grouped_expr.expr });3744 try stack.append(RenderState { .Expression = grouped_expr.expr });
3727 try stack.append(RenderState { .Text = "("});3745 try stack.append(RenderState { .Text = "("});
3728 },3746 },
3729 ast.Node.Id.FieldInitializer => {3747 ast.Node.Id.FieldInitializer => {
3730 const field_init = @fieldParentPtr(ast.NodeFieldInitializer, "base", base);3748 const field_init = @fieldParentPtr(ast.Node.FieldInitializer, "base", base);
3731 try stream.print(".{} = ", self.tokenizer.getTokenSlice(field_init.name_token));3749 try stream.print(".{} = ", self.tokenizer.getTokenSlice(field_init.name_token));
3732 try stack.append(RenderState { .Expression = field_init.expr });3750 try stack.append(RenderState { .Expression = field_init.expr });
3733 },3751 },
3734 ast.Node.Id.IntegerLiteral => {3752 ast.Node.Id.IntegerLiteral => {
3735 const integer_literal = @fieldParentPtr(ast.NodeIntegerLiteral, "base", base);3753 const integer_literal = @fieldParentPtr(ast.Node.IntegerLiteral, "base", base);
3736 try stream.print("{}", self.tokenizer.getTokenSlice(integer_literal.token));3754 try stream.print("{}", self.tokenizer.getTokenSlice(integer_literal.token));
3737 },3755 },
3738 ast.Node.Id.FloatLiteral => {3756 ast.Node.Id.FloatLiteral => {
3739 const float_literal = @fieldParentPtr(ast.NodeFloatLiteral, "base", base);3757 const float_literal = @fieldParentPtr(ast.Node.FloatLiteral, "base", base);
3740 try stream.print("{}", self.tokenizer.getTokenSlice(float_literal.token));3758 try stream.print("{}", self.tokenizer.getTokenSlice(float_literal.token));
3741 },3759 },
3742 ast.Node.Id.StringLiteral => {3760 ast.Node.Id.StringLiteral => {
3743 const string_literal = @fieldParentPtr(ast.NodeStringLiteral, "base", base);3761 const string_literal = @fieldParentPtr(ast.Node.StringLiteral, "base", base);
3744 try stream.print("{}", self.tokenizer.getTokenSlice(string_literal.token));3762 try stream.print("{}", self.tokenizer.getTokenSlice(string_literal.token));
3745 },3763 },
3746 ast.Node.Id.CharLiteral => {3764 ast.Node.Id.CharLiteral => {
3747 const char_literal = @fieldParentPtr(ast.NodeCharLiteral, "base", base);3765 const char_literal = @fieldParentPtr(ast.Node.CharLiteral, "base", base);
3748 try stream.print("{}", self.tokenizer.getTokenSlice(char_literal.token));3766 try stream.print("{}", self.tokenizer.getTokenSlice(char_literal.token));
3749 },3767 },
3750 ast.Node.Id.BoolLiteral => {3768 ast.Node.Id.BoolLiteral => {
3751 const bool_literal = @fieldParentPtr(ast.NodeCharLiteral, "base", base);3769 const bool_literal = @fieldParentPtr(ast.Node.CharLiteral, "base", base);
3752 try stream.print("{}", self.tokenizer.getTokenSlice(bool_literal.token));3770 try stream.print("{}", self.tokenizer.getTokenSlice(bool_literal.token));
3753 },3771 },
3754 ast.Node.Id.NullLiteral => {3772 ast.Node.Id.NullLiteral => {
3755 const null_literal = @fieldParentPtr(ast.NodeNullLiteral, "base", base);3773 const null_literal = @fieldParentPtr(ast.Node.NullLiteral, "base", base);
3756 try stream.print("{}", self.tokenizer.getTokenSlice(null_literal.token));3774 try stream.print("{}", self.tokenizer.getTokenSlice(null_literal.token));
3757 },3775 },
3758 ast.Node.Id.ThisLiteral => {3776 ast.Node.Id.ThisLiteral => {
3759 const this_literal = @fieldParentPtr(ast.NodeThisLiteral, "base", base);3777 const this_literal = @fieldParentPtr(ast.Node.ThisLiteral, "base", base);
3760 try stream.print("{}", self.tokenizer.getTokenSlice(this_literal.token));3778 try stream.print("{}", self.tokenizer.getTokenSlice(this_literal.token));
3761 },3779 },
3762 ast.Node.Id.Unreachable => {3780 ast.Node.Id.Unreachable => {
3763 const unreachable_node = @fieldParentPtr(ast.NodeUnreachable, "base", base);3781 const unreachable_node = @fieldParentPtr(ast.Node.Unreachable, "base", base);
3764 try stream.print("{}", self.tokenizer.getTokenSlice(unreachable_node.token));3782 try stream.print("{}", self.tokenizer.getTokenSlice(unreachable_node.token));
3765 },3783 },
3766 ast.Node.Id.ErrorType => {3784 ast.Node.Id.ErrorType => {
3767 const error_type = @fieldParentPtr(ast.NodeErrorType, "base", base);3785 const error_type = @fieldParentPtr(ast.Node.ErrorType, "base", base);
3768 try stream.print("{}", self.tokenizer.getTokenSlice(error_type.token));3786 try stream.print("{}", self.tokenizer.getTokenSlice(error_type.token));
3769 },3787 },
3770 ast.Node.Id.VarType => {3788 ast.Node.Id.VarType => {
3771 const var_type = @fieldParentPtr(ast.NodeVarType, "base", base);3789 const var_type = @fieldParentPtr(ast.Node.VarType, "base", base);
3772 try stream.print("{}", self.tokenizer.getTokenSlice(var_type.token));3790 try stream.print("{}", self.tokenizer.getTokenSlice(var_type.token));
3773 },3791 },
3774 ast.Node.Id.ContainerDecl => {3792 ast.Node.Id.ContainerDecl => {
3775 const container_decl = @fieldParentPtr(ast.NodeContainerDecl, "base", base);3793 const container_decl = @fieldParentPtr(ast.Node.ContainerDecl, "base", base);
37763794
3777 switch (container_decl.layout) {3795 switch (container_decl.layout) {
3778 ast.NodeContainerDecl.Layout.Packed => try stream.print("packed "),3796 ast.Node.ContainerDecl.Layout.Packed => try stream.print("packed "),
3779 ast.NodeContainerDecl.Layout.Extern => try stream.print("extern "),3797 ast.Node.ContainerDecl.Layout.Extern => try stream.print("extern "),
3780 ast.NodeContainerDecl.Layout.Auto => { },3798 ast.Node.ContainerDecl.Layout.Auto => { },
3781 }3799 }
37823800
3783 switch (container_decl.kind) {3801 switch (container_decl.kind) {
3784 ast.NodeContainerDecl.Kind.Struct => try stream.print("struct"),3802 ast.Node.ContainerDecl.Kind.Struct => try stream.print("struct"),
3785 ast.NodeContainerDecl.Kind.Enum => try stream.print("enum"),3803 ast.Node.ContainerDecl.Kind.Enum => try stream.print("enum"),
3786 ast.NodeContainerDecl.Kind.Union => try stream.print("union"),3804 ast.Node.ContainerDecl.Kind.Union => try stream.print("union"),
3787 }3805 }
37883806
3789 try stack.append(RenderState { .Text = "}"});3807 try stack.append(RenderState { .Text = "}"});
...@@ -3823,9 +3841,9 @@ pub const Parser = struct {...@@ -3823,9 +3841,9 @@ pub const Parser = struct {
3823 try stack.append(RenderState { .Text = "{"});3841 try stack.append(RenderState { .Text = "{"});
38243842
3825 switch (container_decl.init_arg_expr) {3843 switch (container_decl.init_arg_expr) {
3826 ast.NodeContainerDecl.InitArg.None => try stack.append(RenderState { .Text = " "}),3844 ast.Node.ContainerDecl.InitArg.None => try stack.append(RenderState { .Text = " "}),
3827 ast.NodeContainerDecl.InitArg.Enum => try stack.append(RenderState { .Text = "(enum) "}),3845 ast.Node.ContainerDecl.InitArg.Enum => try stack.append(RenderState { .Text = "(enum) "}),
3828 ast.NodeContainerDecl.InitArg.Type => |type_expr| {3846 ast.Node.ContainerDecl.InitArg.Type => |type_expr| {
3829 try stack.append(RenderState { .Text = ") "});3847 try stack.append(RenderState { .Text = ") "});
3830 try stack.append(RenderState { .Expression = type_expr});3848 try stack.append(RenderState { .Expression = type_expr});
3831 try stack.append(RenderState { .Text = "("});3849 try stack.append(RenderState { .Text = "("});
...@@ -3833,7 +3851,7 @@ pub const Parser = struct {...@@ -3833,7 +3851,7 @@ pub const Parser = struct {
3833 }3851 }
3834 },3852 },
3835 ast.Node.Id.ErrorSetDecl => {3853 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);
3837 try stream.print("error ");3855 try stream.print("error ");
38383856
3839 try stack.append(RenderState { .Text = "}"});3857 try stack.append(RenderState { .Text = "}"});
...@@ -3866,7 +3884,7 @@ pub const Parser = struct {...@@ -3866,7 +3884,7 @@ pub const Parser = struct {
3866 try stack.append(RenderState { .Text = "{"});3884 try stack.append(RenderState { .Text = "{"});
3867 },3885 },
3868 ast.Node.Id.MultilineStringLiteral => {3886 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);
3870 try stream.print("\n");3888 try stream.print("\n");
38713889
3872 var i : usize = 0;3890 var i : usize = 0;
...@@ -3878,11 +3896,11 @@ pub const Parser = struct {...@@ -3878,11 +3896,11 @@ pub const Parser = struct {
3878 try stream.writeByteNTimes(' ', indent + indent_delta);3896 try stream.writeByteNTimes(' ', indent + indent_delta);
3879 },3897 },
3880 ast.Node.Id.UndefinedLiteral => {3898 ast.Node.Id.UndefinedLiteral => {
3881 const undefined_literal = @fieldParentPtr(ast.NodeUndefinedLiteral, "base", base);3899 const undefined_literal = @fieldParentPtr(ast.Node.UndefinedLiteral, "base", base);
3882 try stream.print("{}", self.tokenizer.getTokenSlice(undefined_literal.token));3900 try stream.print("{}", self.tokenizer.getTokenSlice(undefined_literal.token));
3883 },3901 },
3884 ast.Node.Id.BuiltinCall => {3902 ast.Node.Id.BuiltinCall => {
3885 const builtin_call = @fieldParentPtr(ast.NodeBuiltinCall, "base", base);3903 const builtin_call = @fieldParentPtr(ast.Node.BuiltinCall, "base", base);
3886 try stream.print("{}(", self.tokenizer.getTokenSlice(builtin_call.builtin_token));3904 try stream.print("{}(", self.tokenizer.getTokenSlice(builtin_call.builtin_token));
3887 try stack.append(RenderState { .Text = ")"});3905 try stack.append(RenderState { .Text = ")"});
3888 var i = builtin_call.params.len;3906 var i = builtin_call.params.len;
...@@ -3896,13 +3914,13 @@ pub const Parser = struct {...@@ -3896,13 +3914,13 @@ pub const Parser = struct {
3896 }3914 }
3897 },3915 },
3898 ast.Node.Id.FnProto => {3916 ast.Node.Id.FnProto => {
3899 const fn_proto = @fieldParentPtr(ast.NodeFnProto, "base", base);3917 const fn_proto = @fieldParentPtr(ast.Node.FnProto, "base", base);
39003918
3901 switch (fn_proto.return_type) {3919 switch (fn_proto.return_type) {
3902 ast.NodeFnProto.ReturnType.Explicit => |node| {3920 ast.Node.FnProto.ReturnType.Explicit => |node| {
3903 try stack.append(RenderState { .Expression = node});3921 try stack.append(RenderState { .Expression = node});
3904 },3922 },
3905 ast.NodeFnProto.ReturnType.InferErrorSet => |node| {3923 ast.Node.FnProto.ReturnType.InferErrorSet => |node| {
3906 try stack.append(RenderState { .Expression = node});3924 try stack.append(RenderState { .Expression = node});
3907 try stack.append(RenderState { .Text = "!"});3925 try stack.append(RenderState { .Text = "!"});
3908 },3926 },
...@@ -3960,7 +3978,7 @@ pub const Parser = struct {...@@ -3960,7 +3978,7 @@ pub const Parser = struct {
3960 },3978 },
3961 ast.Node.Id.LineComment => @panic("TODO render line comment in an expression"),3979 ast.Node.Id.LineComment => @panic("TODO render line comment in an expression"),
3962 ast.Node.Id.Switch => {3980 ast.Node.Id.Switch => {
3963 const switch_node = @fieldParentPtr(ast.NodeSwitch, "base", base);3981 const switch_node = @fieldParentPtr(ast.Node.Switch, "base", base);
3964 try stream.print("{} (", self.tokenizer.getTokenSlice(switch_node.switch_token));3982 try stream.print("{} (", self.tokenizer.getTokenSlice(switch_node.switch_token));
39653983
3966 try stack.append(RenderState { .Text = "}"});3984 try stack.append(RenderState { .Text = "}"});
...@@ -3994,7 +4012,7 @@ pub const Parser = struct {...@@ -3994,7 +4012,7 @@ pub const Parser = struct {
3994 try stack.append(RenderState { .Expression = switch_node.expr });4012 try stack.append(RenderState { .Expression = switch_node.expr });
3995 },4013 },
3996 ast.Node.Id.SwitchCase => {4014 ast.Node.Id.SwitchCase => {
3997 const switch_case = @fieldParentPtr(ast.NodeSwitchCase, "base", base);4015 const switch_case = @fieldParentPtr(ast.Node.SwitchCase, "base", base);
39984016
3999 try stack.append(RenderState { .Expression = switch_case.expr });4017 try stack.append(RenderState { .Expression = switch_case.expr });
4000 if (switch_case.payload) |payload| {4018 if (switch_case.payload) |payload| {
...@@ -4016,11 +4034,11 @@ pub const Parser = struct {...@@ -4016,11 +4034,11 @@ pub const Parser = struct {
4016 }4034 }
4017 },4035 },
4018 ast.Node.Id.SwitchElse => {4036 ast.Node.Id.SwitchElse => {
4019 const switch_else = @fieldParentPtr(ast.NodeSwitchElse, "base", base);4037 const switch_else = @fieldParentPtr(ast.Node.SwitchElse, "base", base);
4020 try stream.print("{}", self.tokenizer.getTokenSlice(switch_else.token));4038 try stream.print("{}", self.tokenizer.getTokenSlice(switch_else.token));
4021 },4039 },
4022 ast.Node.Id.Else => {4040 ast.Node.Id.Else => {
4023 const else_node = @fieldParentPtr(ast.NodeElse, "base", base);4041 const else_node = @fieldParentPtr(ast.Node.Else, "base", base);
4024 try stream.print("{}", self.tokenizer.getTokenSlice(else_node.else_token));4042 try stream.print("{}", self.tokenizer.getTokenSlice(else_node.else_token));
40254043
4026 switch (else_node.body.id) {4044 switch (else_node.body.id) {
...@@ -4045,7 +4063,7 @@ pub const Parser = struct {...@@ -4045,7 +4063,7 @@ pub const Parser = struct {
4045 }4063 }
4046 },4064 },
4047 ast.Node.Id.While => {4065 ast.Node.Id.While => {
4048 const while_node = @fieldParentPtr(ast.NodeWhile, "base", base);4066 const while_node = @fieldParentPtr(ast.Node.While, "base", base);
4049 if (while_node.label) |label| {4067 if (while_node.label) |label| {
4050 try stream.print("{}: ", self.tokenizer.getTokenSlice(label));4068 try stream.print("{}: ", self.tokenizer.getTokenSlice(label));
4051 }4069 }
...@@ -4095,7 +4113,7 @@ pub const Parser = struct {...@@ -4095,7 +4113,7 @@ pub const Parser = struct {
4095 try stack.append(RenderState { .Text = "(" });4113 try stack.append(RenderState { .Text = "(" });
4096 },4114 },
4097 ast.Node.Id.For => {4115 ast.Node.Id.For => {
4098 const for_node = @fieldParentPtr(ast.NodeFor, "base", base);4116 const for_node = @fieldParentPtr(ast.Node.For, "base", base);
4099 if (for_node.label) |label| {4117 if (for_node.label) |label| {
4100 try stream.print("{}: ", self.tokenizer.getTokenSlice(label));4118 try stream.print("{}: ", self.tokenizer.getTokenSlice(label));
4101 }4119 }
...@@ -4138,7 +4156,7 @@ pub const Parser = struct {...@@ -4138,7 +4156,7 @@ pub const Parser = struct {
4138 try stack.append(RenderState { .Text = "(" });4156 try stack.append(RenderState { .Text = "(" });
4139 },4157 },
4140 ast.Node.Id.If => {4158 ast.Node.Id.If => {
4141 const if_node = @fieldParentPtr(ast.NodeIf, "base", base);4159 const if_node = @fieldParentPtr(ast.Node.If, "base", base);
4142 try stream.print("{} ", self.tokenizer.getTokenSlice(if_node.if_token));4160 try stream.print("{} ", self.tokenizer.getTokenSlice(if_node.if_token));
41434161
4144 switch (if_node.body.id) {4162 switch (if_node.body.id) {
...@@ -4185,7 +4203,7 @@ pub const Parser = struct {...@@ -4185,7 +4203,7 @@ pub const Parser = struct {
4185 try stack.append(RenderState { .Text = "(" });4203 try stack.append(RenderState { .Text = "(" });
4186 },4204 },
4187 ast.Node.Id.Asm => {4205 ast.Node.Id.Asm => {
4188 const asm_node = @fieldParentPtr(ast.NodeAsm, "base", base);4206 const asm_node = @fieldParentPtr(ast.Node.Asm, "base", base);
4189 try stream.print("{} ", self.tokenizer.getTokenSlice(asm_node.asm_token));4207 try stream.print("{} ", self.tokenizer.getTokenSlice(asm_node.asm_token));
41904208
4191 if (asm_node.volatile_token) |volatile_token| {4209 if (asm_node.volatile_token) |volatile_token| {
...@@ -4272,7 +4290,7 @@ pub const Parser = struct {...@@ -4272,7 +4290,7 @@ pub const Parser = struct {
4272 try stack.append(RenderState { .Text = "(" });4290 try stack.append(RenderState { .Text = "(" });
4273 },4291 },
4274 ast.Node.Id.AsmInput => {4292 ast.Node.Id.AsmInput => {
4275 const asm_input = @fieldParentPtr(ast.NodeAsmInput, "base", base);4293 const asm_input = @fieldParentPtr(ast.Node.AsmInput, "base", base);
42764294
4277 try stack.append(RenderState { .Text = ")"});4295 try stack.append(RenderState { .Text = ")"});
4278 try stack.append(RenderState { .Expression = asm_input.expr});4296 try stack.append(RenderState { .Expression = asm_input.expr});
...@@ -4283,14 +4301,14 @@ pub const Parser = struct {...@@ -4283,14 +4301,14 @@ pub const Parser = struct {
4283 try stack.append(RenderState { .Text = "["});4301 try stack.append(RenderState { .Text = "["});
4284 },4302 },
4285 ast.Node.Id.AsmOutput => {4303 ast.Node.Id.AsmOutput => {
4286 const asm_output = @fieldParentPtr(ast.NodeAsmOutput, "base", base);4304 const asm_output = @fieldParentPtr(ast.Node.AsmOutput, "base", base);
42874305
4288 try stack.append(RenderState { .Text = ")"});4306 try stack.append(RenderState { .Text = ")"});
4289 switch (asm_output.kind) {4307 switch (asm_output.kind) {
4290 ast.NodeAsmOutput.Kind.Variable => |variable_name| {4308 ast.Node.AsmOutput.Kind.Variable => |variable_name| {
4291 try stack.append(RenderState { .Expression = &variable_name.base});4309 try stack.append(RenderState { .Expression = &variable_name.base});
4292 },4310 },
4293 ast.NodeAsmOutput.Kind.Return => |return_type| {4311 ast.Node.AsmOutput.Kind.Return => |return_type| {
4294 try stack.append(RenderState { .Expression = return_type});4312 try stack.append(RenderState { .Expression = return_type});
4295 try stack.append(RenderState { .Text = "-> "});4313 try stack.append(RenderState { .Text = "-> "});
4296 },4314 },
...@@ -4312,15 +4330,10 @@ pub const Parser = struct {...@@ -4312,15 +4330,10 @@ pub const Parser = struct {
4312 ast.Node.Id.ParamDecl => unreachable,4330 ast.Node.Id.ParamDecl => unreachable,
4313 },4331 },
4314 RenderState.Statement => |base| {4332 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 }
4321 switch (base.id) {4333 switch (base.id) {
4322 ast.Node.Id.VarDecl => {4334 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);
4324 try stack.append(RenderState { .VarDecl = var_decl});4337 try stack.append(RenderState { .VarDecl = var_decl});
4325 },4338 },
4326 else => {4339 else => {
...@@ -4337,6 +4350,14 @@ pub const Parser = struct {...@@ -4337,6 +4350,14 @@ pub const Parser = struct {
4337 }4350 }
4338 }4351 }
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
4340 fn initUtilityArrayList(self: &Parser, comptime T: type) ArrayList(T) {4361 fn initUtilityArrayList(self: &Parser, comptime T: type) ArrayList(T) {
4341 const new_byte_count = self.utility_bytes.len - self.utility_bytes.len % @sizeOf(T);4362 const new_byte_count = self.utility_bytes.len - self.utility_bytes.len % @sizeOf(T);
4342 self.utility_bytes = self.util_allocator.alignedShrink(u8, utility_bytes_align, self.utility_bytes, new_byte_count);4363 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 {...@@ -4411,6 +4432,14 @@ fn testCanonical(source: []const u8) !void {
4411 }4432 }
4412}4433}
44134434
4435test "zig fmt: preserve top level comments" {
4436 try testCanonical(
4437 \\// top level comment
4438 \\test "hi" {}
4439 \\
4440 );
4441}
4442
4414test "zig fmt: get stdout or fail" {4443test "zig fmt: get stdout or fail" {
4415 try testCanonical(4444 try testCanonical(
4416 \\const std = @import("std");4445 \\const std = @import("std");