authorgravatar for mail@isaacfreund.comIsaac Freund <mail@isaacfreund.com> 2021-03-28 22:42:17+02:00
committergravatar for mail@isaacfreund.comIsaac Freund <mail@isaacfreund.com> 2021-03-28 22:42:17+02:00
logf80f8a7a7835db5f8b13aab23b4ee79e88c25e63
tree8d059cd5e3163bbbf4f7b9cee93fe68f06ae8138
parentd5d88087dd6346af59540ec1b4f7afdd62d66666
signature Commit is signed but in an unrecognized format.

AstGen: pass *GenZir as the first arg, not *Module

This avoids the unnecessary scope.getGenZir() virtual call for both convenience and performance.

3 files changed, 426 insertions(+), 453 deletions(-)

BRANCH_TODO-2
......@@ -11,8 +11,6 @@ Merge TODO list:
1111 calls from other files.
1212
1313Performance optimizations to look into:
14 * astgen: pass *GenZir as the first arg, not *Module
15 - point here is to avoid the unnecessary virtual call scope.getGenZir()
1614 * don't store end index for blocks; rely on last instruction being noreturn
1715 * look into not storing the field name of field access as a string in zir
1816 instructions. or, look into introducing interning to string_bytes (local
src/AstGen.zig+418-443
......@@ -19,6 +19,7 @@ const zir = @import("zir.zig");
1919const Module = @import("Module.zig");
2020const trace = @import("tracy.zig").trace;
2121const Scope = Module.Scope;
22const GenZir = Scope.GenZir;
2223const InnerError = Module.InnerError;
2324const Decl = Module.Decl;
2425const BuiltinFn = @import("BuiltinFn.zig");
......@@ -138,7 +139,7 @@ pub const ResultLoc = union(enum) {
138139 /// There is a pointer for the expression to store its result into, however, its type
139140 /// is inferred based on peer type resolution for a `zir.Inst.Block`.
140141 /// The result instruction from the expression must be ignored.
141 block_ptr: *Scope.GenZir,
142 block_ptr: *GenZir,
142143
143144 pub const Strategy = struct {
144145 elide_store_to_block_ptr_instructions: bool,
......@@ -155,7 +156,7 @@ pub const ResultLoc = union(enum) {
155156 };
156157 };
157158
158 fn strategy(rl: ResultLoc, block_scope: *Scope.GenZir) Strategy {
159 fn strategy(rl: ResultLoc, block_scope: *GenZir) Strategy {
159160 var elide_store_to_block_ptr_instructions = false;
160161 switch (rl) {
161162 // In this branch there will not be any store_to_block_ptr instructions.
......@@ -191,11 +192,11 @@ pub const ResultLoc = union(enum) {
191192 }
192193};
193194
194pub fn typeExpr(mod: *Module, scope: *Scope, type_node: ast.Node.Index) InnerError!zir.Inst.Ref {
195 return expr(mod, scope, .{ .ty = .type_type }, type_node);
195pub fn typeExpr(gz: *GenZir, scope: *Scope, type_node: ast.Node.Index) InnerError!zir.Inst.Ref {
196 return expr(gz, scope, .{ .ty = .type_type }, type_node);
196197}
197198
198fn lvalExpr(mod: *Module, scope: *Scope, node: ast.Node.Index) InnerError!zir.Inst.Ref {
199fn lvalExpr(gz: *GenZir, scope: *Scope, node: ast.Node.Index) InnerError!zir.Inst.Ref {
199200 const tree = scope.tree();
200201 const node_tags = tree.nodes.items(.tag);
201202 const main_tokens = tree.nodes.items(.main_token);
......@@ -354,7 +355,7 @@ fn lvalExpr(mod: *Module, scope: *Scope, node: ast.Node.Index) InnerError!zir.In
354355 .@"comptime",
355356 .@"nosuspend",
356357 .error_value,
357 => return mod.failNode(scope, node, "invalid left-hand side to assignment", .{}),
358 => return gz.astgen.mod.failNode(scope, node, "invalid left-hand side to assignment", .{}),
358359
359360 .builtin_call,
360361 .builtin_call_comma,
......@@ -367,7 +368,7 @@ fn lvalExpr(mod: *Module, scope: *Scope, node: ast.Node.Index) InnerError!zir.In
367368 // let it pass, and the error will be "invalid builtin function" later.
368369 if (BuiltinFn.list.get(builtin_name)) |info| {
369370 if (!info.allows_lvalue) {
370 return mod.failNode(scope, node, "invalid left-hand side to assignment", .{});
371 return gz.astgen.mod.failNode(scope, node, "invalid left-hand side to assignment", .{});
371372 }
372373 }
373374 },
......@@ -382,22 +383,21 @@ fn lvalExpr(mod: *Module, scope: *Scope, node: ast.Node.Index) InnerError!zir.In
382383 .@"orelse",
383384 => {},
384385 }
385 return expr(mod, scope, .ref, node);
386 return expr(gz, scope, .ref, node);
386387}
387388
388389/// Turn Zig AST into untyped ZIR istructions.
389390/// When `rl` is discard, ptr, inferred_ptr, bitcasted_ptr, or inferred_ptr, the
390391/// result instruction can be used to inspect whether it is isNoReturn() but that is it,
391392/// it must otherwise not be used.
392pub fn expr(mod: *Module, scope: *Scope, rl: ResultLoc, node: ast.Node.Index) InnerError!zir.Inst.Ref {
393pub fn expr(gz: *GenZir, scope: *Scope, rl: ResultLoc, node: ast.Node.Index) InnerError!zir.Inst.Ref {
394 const mod = gz.astgen.mod;
393395 const tree = scope.tree();
394396 const main_tokens = tree.nodes.items(.main_token);
395397 const token_tags = tree.tokens.items(.tag);
396398 const node_datas = tree.nodes.items(.data);
397399 const node_tags = tree.nodes.items(.tag);
398400
399 const gz = scope.getGenZir();
400
401401 switch (node_tags[node]) {
402402 .root => unreachable, // Top-level declaration.
403403 .@"usingnamespace" => unreachable, // Top-level declaration.
......@@ -420,131 +420,131 @@ pub fn expr(mod: *Module, scope: *Scope, rl: ResultLoc, node: ast.Node.Index) In
420420 .asm_input => unreachable, // Handled in `asmExpr`.
421421
422422 .assign => {
423 try assign(mod, scope, node);
424 return rvalue(mod, scope, rl, .void_value, node);
423 try assign(gz, scope, node);
424 return rvalue(gz, scope, rl, .void_value, node);
425425 },
426426 .assign_bit_and => {
427 try assignOp(mod, scope, node, .bit_and);
428 return rvalue(mod, scope, rl, .void_value, node);
427 try assignOp(gz, scope, node, .bit_and);
428 return rvalue(gz, scope, rl, .void_value, node);
429429 },
430430 .assign_bit_or => {
431 try assignOp(mod, scope, node, .bit_or);
432 return rvalue(mod, scope, rl, .void_value, node);
431 try assignOp(gz, scope, node, .bit_or);
432 return rvalue(gz, scope, rl, .void_value, node);
433433 },
434434 .assign_bit_shift_left => {
435 try assignOp(mod, scope, node, .shl);
436 return rvalue(mod, scope, rl, .void_value, node);
435 try assignOp(gz, scope, node, .shl);
436 return rvalue(gz, scope, rl, .void_value, node);
437437 },
438438 .assign_bit_shift_right => {
439 try assignOp(mod, scope, node, .shr);
440 return rvalue(mod, scope, rl, .void_value, node);
439 try assignOp(gz, scope, node, .shr);
440 return rvalue(gz, scope, rl, .void_value, node);
441441 },
442442 .assign_bit_xor => {
443 try assignOp(mod, scope, node, .xor);
444 return rvalue(mod, scope, rl, .void_value, node);
443 try assignOp(gz, scope, node, .xor);
444 return rvalue(gz, scope, rl, .void_value, node);
445445 },
446446 .assign_div => {
447 try assignOp(mod, scope, node, .div);
448 return rvalue(mod, scope, rl, .void_value, node);
447 try assignOp(gz, scope, node, .div);
448 return rvalue(gz, scope, rl, .void_value, node);
449449 },
450450 .assign_sub => {
451 try assignOp(mod, scope, node, .sub);
452 return rvalue(mod, scope, rl, .void_value, node);
451 try assignOp(gz, scope, node, .sub);
452 return rvalue(gz, scope, rl, .void_value, node);
453453 },
454454 .assign_sub_wrap => {
455 try assignOp(mod, scope, node, .subwrap);
456 return rvalue(mod, scope, rl, .void_value, node);
455 try assignOp(gz, scope, node, .subwrap);
456 return rvalue(gz, scope, rl, .void_value, node);
457457 },
458458 .assign_mod => {
459 try assignOp(mod, scope, node, .mod_rem);
460 return rvalue(mod, scope, rl, .void_value, node);
459 try assignOp(gz, scope, node, .mod_rem);
460 return rvalue(gz, scope, rl, .void_value, node);
461461 },
462462 .assign_add => {
463 try assignOp(mod, scope, node, .add);
464 return rvalue(mod, scope, rl, .void_value, node);
463 try assignOp(gz, scope, node, .add);
464 return rvalue(gz, scope, rl, .void_value, node);
465465 },
466466 .assign_add_wrap => {
467 try assignOp(mod, scope, node, .addwrap);
468 return rvalue(mod, scope, rl, .void_value, node);
467 try assignOp(gz, scope, node, .addwrap);
468 return rvalue(gz, scope, rl, .void_value, node);
469469 },
470470 .assign_mul => {
471 try assignOp(mod, scope, node, .mul);
472 return rvalue(mod, scope, rl, .void_value, node);
471 try assignOp(gz, scope, node, .mul);
472 return rvalue(gz, scope, rl, .void_value, node);
473473 },
474474 .assign_mul_wrap => {
475 try assignOp(mod, scope, node, .mulwrap);
476 return rvalue(mod, scope, rl, .void_value, node);
475 try assignOp(gz, scope, node, .mulwrap);
476 return rvalue(gz, scope, rl, .void_value, node);
477477 },
478478
479 .add => return simpleBinOp(mod, scope, rl, node, .add),
480 .add_wrap => return simpleBinOp(mod, scope, rl, node, .addwrap),
481 .sub => return simpleBinOp(mod, scope, rl, node, .sub),
482 .sub_wrap => return simpleBinOp(mod, scope, rl, node, .subwrap),
483 .mul => return simpleBinOp(mod, scope, rl, node, .mul),
484 .mul_wrap => return simpleBinOp(mod, scope, rl, node, .mulwrap),
485 .div => return simpleBinOp(mod, scope, rl, node, .div),
486 .mod => return simpleBinOp(mod, scope, rl, node, .mod_rem),
487 .bit_and => return simpleBinOp(mod, scope, rl, node, .bit_and),
488 .bit_or => return simpleBinOp(mod, scope, rl, node, .bit_or),
489 .bit_shift_left => return simpleBinOp(mod, scope, rl, node, .shl),
490 .bit_shift_right => return simpleBinOp(mod, scope, rl, node, .shr),
491 .bit_xor => return simpleBinOp(mod, scope, rl, node, .xor),
479 .add => return simpleBinOp(gz, scope, rl, node, .add),
480 .add_wrap => return simpleBinOp(gz, scope, rl, node, .addwrap),
481 .sub => return simpleBinOp(gz, scope, rl, node, .sub),
482 .sub_wrap => return simpleBinOp(gz, scope, rl, node, .subwrap),
483 .mul => return simpleBinOp(gz, scope, rl, node, .mul),
484 .mul_wrap => return simpleBinOp(gz, scope, rl, node, .mulwrap),
485 .div => return simpleBinOp(gz, scope, rl, node, .div),
486 .mod => return simpleBinOp(gz, scope, rl, node, .mod_rem),
487 .bit_and => return simpleBinOp(gz, scope, rl, node, .bit_and),
488 .bit_or => return simpleBinOp(gz, scope, rl, node, .bit_or),
489 .bit_shift_left => return simpleBinOp(gz, scope, rl, node, .shl),
490 .bit_shift_right => return simpleBinOp(gz, scope, rl, node, .shr),
491 .bit_xor => return simpleBinOp(gz, scope, rl, node, .xor),
492492
493 .bang_equal => return simpleBinOp(mod, scope, rl, node, .cmp_neq),
494 .equal_equal => return simpleBinOp(mod, scope, rl, node, .cmp_eq),
495 .greater_than => return simpleBinOp(mod, scope, rl, node, .cmp_gt),
496 .greater_or_equal => return simpleBinOp(mod, scope, rl, node, .cmp_gte),
497 .less_than => return simpleBinOp(mod, scope, rl, node, .cmp_lt),
498 .less_or_equal => return simpleBinOp(mod, scope, rl, node, .cmp_lte),
493 .bang_equal => return simpleBinOp(gz, scope, rl, node, .cmp_neq),
494 .equal_equal => return simpleBinOp(gz, scope, rl, node, .cmp_eq),
495 .greater_than => return simpleBinOp(gz, scope, rl, node, .cmp_gt),
496 .greater_or_equal => return simpleBinOp(gz, scope, rl, node, .cmp_gte),
497 .less_than => return simpleBinOp(gz, scope, rl, node, .cmp_lt),
498 .less_or_equal => return simpleBinOp(gz, scope, rl, node, .cmp_lte),
499499
500 .array_cat => return simpleBinOp(mod, scope, rl, node, .array_cat),
501 .array_mult => return simpleBinOp(mod, scope, rl, node, .array_mul),
500 .array_cat => return simpleBinOp(gz, scope, rl, node, .array_cat),
501 .array_mult => return simpleBinOp(gz, scope, rl, node, .array_mul),
502502
503 .error_union => return simpleBinOp(mod, scope, rl, node, .error_union_type),
504 .merge_error_sets => return simpleBinOp(mod, scope, rl, node, .merge_error_sets),
503 .error_union => return simpleBinOp(gz, scope, rl, node, .error_union_type),
504 .merge_error_sets => return simpleBinOp(gz, scope, rl, node, .merge_error_sets),
505505
506 .bool_and => return boolBinOp(mod, scope, rl, node, .bool_br_and),
507 .bool_or => return boolBinOp(mod, scope, rl, node, .bool_br_or),
506 .bool_and => return boolBinOp(gz, scope, rl, node, .bool_br_and),
507 .bool_or => return boolBinOp(gz, scope, rl, node, .bool_br_or),
508508
509 .bool_not => return boolNot(mod, scope, rl, node),
510 .bit_not => return bitNot(mod, scope, rl, node),
509 .bool_not => return boolNot(gz, scope, rl, node),
510 .bit_not => return bitNot(gz, scope, rl, node),
511511
512 .negation => return negation(mod, scope, rl, node, .negate),
513 .negation_wrap => return negation(mod, scope, rl, node, .negate_wrap),
512 .negation => return negation(gz, scope, rl, node, .negate),
513 .negation_wrap => return negation(gz, scope, rl, node, .negate_wrap),
514514
515 .identifier => return identifier(mod, scope, rl, node),
515 .identifier => return identifier(gz, scope, rl, node),
516516
517 .asm_simple => return asmExpr(mod, scope, rl, node, tree.asmSimple(node)),
518 .@"asm" => return asmExpr(mod, scope, rl, node, tree.asmFull(node)),
517 .asm_simple => return asmExpr(gz, scope, rl, node, tree.asmSimple(node)),
518 .@"asm" => return asmExpr(gz, scope, rl, node, tree.asmFull(node)),
519519
520 .string_literal => return stringLiteral(mod, scope, rl, node),
521 .multiline_string_literal => return multilineStringLiteral(mod, scope, rl, node),
520 .string_literal => return stringLiteral(gz, scope, rl, node),
521 .multiline_string_literal => return multilineStringLiteral(gz, scope, rl, node),
522522
523 .integer_literal => return integerLiteral(mod, scope, rl, node),
523 .integer_literal => return integerLiteral(gz, scope, rl, node),
524524
525525 .builtin_call_two, .builtin_call_two_comma => {
526526 if (node_datas[node].lhs == 0) {
527527 const params = [_]ast.Node.Index{};
528 return builtinCall(mod, scope, rl, node, &params);
528 return builtinCall(gz, scope, rl, node, &params);
529529 } else if (node_datas[node].rhs == 0) {
530530 const params = [_]ast.Node.Index{node_datas[node].lhs};
531 return builtinCall(mod, scope, rl, node, &params);
531 return builtinCall(gz, scope, rl, node, &params);
532532 } else {
533533 const params = [_]ast.Node.Index{ node_datas[node].lhs, node_datas[node].rhs };
534 return builtinCall(mod, scope, rl, node, &params);
534 return builtinCall(gz, scope, rl, node, &params);
535535 }
536536 },
537537 .builtin_call, .builtin_call_comma => {
538538 const params = tree.extra_data[node_datas[node].lhs..node_datas[node].rhs];
539 return builtinCall(mod, scope, rl, node, params);
539 return builtinCall(gz, scope, rl, node, params);
540540 },
541541
542542 .call_one, .call_one_comma, .async_call_one, .async_call_one_comma => {
543543 var params: [1]ast.Node.Index = undefined;
544 return callExpr(mod, scope, rl, node, tree.callOne(&params, node));
544 return callExpr(gz, scope, rl, node, tree.callOne(&params, node));
545545 },
546546 .call, .call_comma, .async_call, .async_call_comma => {
547 return callExpr(mod, scope, rl, node, tree.callFull(node));
547 return callExpr(gz, scope, rl, node, tree.callFull(node));
548548 },
549549
550550 .unreachable_literal => {
......@@ -557,102 +557,102 @@ pub fn expr(mod: *Module, scope: *Scope, rl: ResultLoc, node: ast.Node.Index) In
557557 });
558558 return zir.Inst.Ref.unreachable_value;
559559 },
560 .@"return" => return ret(mod, scope, node),
561 .field_access => return fieldAccess(mod, scope, rl, node),
562 .float_literal => return floatLiteral(mod, scope, rl, node),
560 .@"return" => return ret(gz, scope, node),
561 .field_access => return fieldAccess(gz, scope, rl, node),
562 .float_literal => return floatLiteral(gz, scope, rl, node),
563563
564 .if_simple => return ifExpr(mod, scope, rl, node, tree.ifSimple(node)),
565 .@"if" => return ifExpr(mod, scope, rl, node, tree.ifFull(node)),
564 .if_simple => return ifExpr(gz, scope, rl, node, tree.ifSimple(node)),
565 .@"if" => return ifExpr(gz, scope, rl, node, tree.ifFull(node)),
566566
567 .while_simple => return whileExpr(mod, scope, rl, node, tree.whileSimple(node)),
568 .while_cont => return whileExpr(mod, scope, rl, node, tree.whileCont(node)),
569 .@"while" => return whileExpr(mod, scope, rl, node, tree.whileFull(node)),
567 .while_simple => return whileExpr(gz, scope, rl, node, tree.whileSimple(node)),
568 .while_cont => return whileExpr(gz, scope, rl, node, tree.whileCont(node)),
569 .@"while" => return whileExpr(gz, scope, rl, node, tree.whileFull(node)),
570570
571 .for_simple => return forExpr(mod, scope, rl, node, tree.forSimple(node)),
572 .@"for" => return forExpr(mod, scope, rl, node, tree.forFull(node)),
571 .for_simple => return forExpr(gz, scope, rl, node, tree.forSimple(node)),
572 .@"for" => return forExpr(gz, scope, rl, node, tree.forFull(node)),
573573
574574 .slice_open => {
575 const lhs = try expr(mod, scope, .ref, node_datas[node].lhs);
576 const start = try expr(mod, scope, .{ .ty = .usize_type }, node_datas[node].rhs);
575 const lhs = try expr(gz, scope, .ref, node_datas[node].lhs);
576 const start = try expr(gz, scope, .{ .ty = .usize_type }, node_datas[node].rhs);
577577 const result = try gz.addPlNode(.slice_start, node, zir.Inst.SliceStart{
578578 .lhs = lhs,
579579 .start = start,
580580 });
581 return rvalue(mod, scope, rl, result, node);
581 return rvalue(gz, scope, rl, result, node);
582582 },
583583 .slice => {
584 const lhs = try expr(mod, scope, .ref, node_datas[node].lhs);
584 const lhs = try expr(gz, scope, .ref, node_datas[node].lhs);
585585 const extra = tree.extraData(node_datas[node].rhs, ast.Node.Slice);
586 const start = try expr(mod, scope, .{ .ty = .usize_type }, extra.start);
587 const end = try expr(mod, scope, .{ .ty = .usize_type }, extra.end);
586 const start = try expr(gz, scope, .{ .ty = .usize_type }, extra.start);
587 const end = try expr(gz, scope, .{ .ty = .usize_type }, extra.end);
588588 const result = try gz.addPlNode(.slice_end, node, zir.Inst.SliceEnd{
589589 .lhs = lhs,
590590 .start = start,
591591 .end = end,
592592 });
593 return rvalue(mod, scope, rl, result, node);
593 return rvalue(gz, scope, rl, result, node);
594594 },
595595 .slice_sentinel => {
596 const lhs = try expr(mod, scope, .ref, node_datas[node].lhs);
596 const lhs = try expr(gz, scope, .ref, node_datas[node].lhs);
597597 const extra = tree.extraData(node_datas[node].rhs, ast.Node.SliceSentinel);
598 const start = try expr(mod, scope, .{ .ty = .usize_type }, extra.start);
599 const end = try expr(mod, scope, .{ .ty = .usize_type }, extra.end);
600 const sentinel = try expr(mod, scope, .{ .ty = .usize_type }, extra.sentinel);
598 const start = try expr(gz, scope, .{ .ty = .usize_type }, extra.start);
599 const end = try expr(gz, scope, .{ .ty = .usize_type }, extra.end);
600 const sentinel = try expr(gz, scope, .{ .ty = .usize_type }, extra.sentinel);
601601 const result = try gz.addPlNode(.slice_sentinel, node, zir.Inst.SliceSentinel{
602602 .lhs = lhs,
603603 .start = start,
604604 .end = end,
605605 .sentinel = sentinel,
606606 });
607 return rvalue(mod, scope, rl, result, node);
607 return rvalue(gz, scope, rl, result, node);
608608 },
609609
610610 .deref => {
611 const lhs = try expr(mod, scope, .none, node_datas[node].lhs);
611 const lhs = try expr(gz, scope, .none, node_datas[node].lhs);
612612 const result = try gz.addUnNode(.load, lhs, node);
613 return rvalue(mod, scope, rl, result, node);
613 return rvalue(gz, scope, rl, result, node);
614614 },
615615 .address_of => {
616 const result = try expr(mod, scope, .ref, node_datas[node].lhs);
617 return rvalue(mod, scope, rl, result, node);
616 const result = try expr(gz, scope, .ref, node_datas[node].lhs);
617 return rvalue(gz, scope, rl, result, node);
618618 },
619 .undefined_literal => return rvalue(mod, scope, rl, .undef, node),
620 .true_literal => return rvalue(mod, scope, rl, .bool_true, node),
621 .false_literal => return rvalue(mod, scope, rl, .bool_false, node),
622 .null_literal => return rvalue(mod, scope, rl, .null_value, node),
619 .undefined_literal => return rvalue(gz, scope, rl, .undef, node),
620 .true_literal => return rvalue(gz, scope, rl, .bool_true, node),
621 .false_literal => return rvalue(gz, scope, rl, .bool_false, node),
622 .null_literal => return rvalue(gz, scope, rl, .null_value, node),
623623 .optional_type => {
624 const operand = try typeExpr(mod, scope, node_datas[node].lhs);
624 const operand = try typeExpr(gz, scope, node_datas[node].lhs);
625625 const result = try gz.addUnNode(.optional_type, operand, node);
626 return rvalue(mod, scope, rl, result, node);
626 return rvalue(gz, scope, rl, result, node);
627627 },
628628 .unwrap_optional => switch (rl) {
629629 .ref => return gz.addUnNode(
630630 .optional_payload_safe_ptr,
631 try expr(mod, scope, .ref, node_datas[node].lhs),
631 try expr(gz, scope, .ref, node_datas[node].lhs),
632632 node,
633633 ),
634 else => return rvalue(mod, scope, rl, try gz.addUnNode(
634 else => return rvalue(gz, scope, rl, try gz.addUnNode(
635635 .optional_payload_safe,
636 try expr(mod, scope, .none, node_datas[node].lhs),
636 try expr(gz, scope, .none, node_datas[node].lhs),
637637 node,
638638 ), node),
639639 },
640640 .block_two, .block_two_semicolon => {
641641 const statements = [2]ast.Node.Index{ node_datas[node].lhs, node_datas[node].rhs };
642642 if (node_datas[node].lhs == 0) {
643 return blockExpr(mod, scope, rl, node, statements[0..0]);
643 return blockExpr(gz, scope, rl, node, statements[0..0]);
644644 } else if (node_datas[node].rhs == 0) {
645 return blockExpr(mod, scope, rl, node, statements[0..1]);
645 return blockExpr(gz, scope, rl, node, statements[0..1]);
646646 } else {
647 return blockExpr(mod, scope, rl, node, statements[0..2]);
647 return blockExpr(gz, scope, rl, node, statements[0..2]);
648648 }
649649 },
650650 .block, .block_semicolon => {
651651 const statements = tree.extra_data[node_datas[node].lhs..node_datas[node].rhs];
652 return blockExpr(mod, scope, rl, node, statements);
652 return blockExpr(gz, scope, rl, node, statements);
653653 },
654 .enum_literal => return simpleStrTok(mod, scope, rl, main_tokens[node], node, .enum_literal),
655 .error_value => return simpleStrTok(mod, scope, rl, node_datas[node].rhs, node, .error_value),
654 .enum_literal => return simpleStrTok(gz, scope, rl, main_tokens[node], node, .enum_literal),
655 .error_value => return simpleStrTok(gz, scope, rl, node_datas[node].rhs, node, .error_value),
656656 .anyframe_literal => return mod.failNode(scope, node, "async and related features are not yet supported", .{}),
657657 .anyframe_type => return mod.failNode(scope, node, "async and related features are not yet supported", .{}),
658658 .@"catch" => {
......@@ -663,7 +663,7 @@ pub fn expr(mod: *Module, scope: *Scope, rl: ResultLoc, node: ast.Node.Index) In
663663 null;
664664 switch (rl) {
665665 .ref => return orelseCatchExpr(
666 mod,
666 gz,
667667 scope,
668668 rl,
669669 node,
......@@ -675,7 +675,7 @@ pub fn expr(mod: *Module, scope: *Scope, rl: ResultLoc, node: ast.Node.Index) In
675675 payload_token,
676676 ),
677677 else => return orelseCatchExpr(
678 mod,
678 gz,
679679 scope,
680680 rl,
681681 node,
......@@ -690,7 +690,7 @@ pub fn expr(mod: *Module, scope: *Scope, rl: ResultLoc, node: ast.Node.Index) In
690690 },
691691 .@"orelse" => switch (rl) {
692692 .ref => return orelseCatchExpr(
693 mod,
693 gz,
694694 scope,
695695 rl,
696696 node,
......@@ -702,7 +702,7 @@ pub fn expr(mod: *Module, scope: *Scope, rl: ResultLoc, node: ast.Node.Index) In
702702 null,
703703 ),
704704 else => return orelseCatchExpr(
705 mod,
705 gz,
706706 scope,
707707 rl,
708708 node,
......@@ -715,43 +715,43 @@ pub fn expr(mod: *Module, scope: *Scope, rl: ResultLoc, node: ast.Node.Index) In
715715 ),
716716 },
717717
718 .ptr_type_aligned => return ptrType(mod, scope, rl, node, tree.ptrTypeAligned(node)),
719 .ptr_type_sentinel => return ptrType(mod, scope, rl, node, tree.ptrTypeSentinel(node)),
720 .ptr_type => return ptrType(mod, scope, rl, node, tree.ptrType(node)),
721 .ptr_type_bit_range => return ptrType(mod, scope, rl, node, tree.ptrTypeBitRange(node)),
718 .ptr_type_aligned => return ptrType(gz, scope, rl, node, tree.ptrTypeAligned(node)),
719 .ptr_type_sentinel => return ptrType(gz, scope, rl, node, tree.ptrTypeSentinel(node)),
720 .ptr_type => return ptrType(gz, scope, rl, node, tree.ptrType(node)),
721 .ptr_type_bit_range => return ptrType(gz, scope, rl, node, tree.ptrTypeBitRange(node)),
722722
723723 .container_decl,
724724 .container_decl_trailing,
725 => return containerDecl(mod, scope, rl, tree.containerDecl(node)),
725 => return containerDecl(gz, scope, rl, tree.containerDecl(node)),
726726 .container_decl_two, .container_decl_two_trailing => {
727727 var buffer: [2]ast.Node.Index = undefined;
728 return containerDecl(mod, scope, rl, tree.containerDeclTwo(&buffer, node));
728 return containerDecl(gz, scope, rl, tree.containerDeclTwo(&buffer, node));
729729 },
730730 .container_decl_arg,
731731 .container_decl_arg_trailing,
732 => return containerDecl(mod, scope, rl, tree.containerDeclArg(node)),
732 => return containerDecl(gz, scope, rl, tree.containerDeclArg(node)),
733733
734734 .tagged_union,
735735 .tagged_union_trailing,
736 => return containerDecl(mod, scope, rl, tree.taggedUnion(node)),
736 => return containerDecl(gz, scope, rl, tree.taggedUnion(node)),
737737 .tagged_union_two, .tagged_union_two_trailing => {
738738 var buffer: [2]ast.Node.Index = undefined;
739 return containerDecl(mod, scope, rl, tree.taggedUnionTwo(&buffer, node));
739 return containerDecl(gz, scope, rl, tree.taggedUnionTwo(&buffer, node));
740740 },
741741 .tagged_union_enum_tag,
742742 .tagged_union_enum_tag_trailing,
743 => return containerDecl(mod, scope, rl, tree.taggedUnionEnumTag(node)),
744
745 .@"break" => return breakExpr(mod, scope, node),
746 .@"continue" => return continueExpr(mod, scope, node),
747 .grouped_expression => return expr(mod, scope, rl, node_datas[node].lhs),
748 .array_type => return arrayType(mod, scope, rl, node),
749 .array_type_sentinel => return arrayTypeSentinel(mod, scope, rl, node),
750 .char_literal => return charLiteral(mod, scope, rl, node),
751 .error_set_decl => return errorSetDecl(mod, scope, rl, node),
752 .array_access => return arrayAccess(mod, scope, rl, node),
753 .@"comptime" => return comptimeExpr(mod, scope, rl, node_datas[node].lhs),
754 .@"switch", .switch_comma => return switchExpr(mod, scope, rl, node),
743 => return containerDecl(gz, scope, rl, tree.taggedUnionEnumTag(node)),
744
745 .@"break" => return breakExpr(gz, scope, node),
746 .@"continue" => return continueExpr(gz, scope, node),
747 .grouped_expression => return expr(gz, scope, rl, node_datas[node].lhs),
748 .array_type => return arrayType(gz, scope, rl, node),
749 .array_type_sentinel => return arrayTypeSentinel(gz, scope, rl, node),
750 .char_literal => return charLiteral(gz, scope, rl, node),
751 .error_set_decl => return errorSetDecl(gz, scope, rl, node),
752 .array_access => return arrayAccess(gz, scope, rl, node),
753 .@"comptime" => return comptimeExpr(gz, scope, rl, node_datas[node].lhs),
754 .@"switch", .switch_comma => return switchExpr(gz, scope, rl, node),
755755
756756 .@"nosuspend" => return mod.failNode(scope, node, "async and related features are not yet supported", .{}),
757757 .@"suspend" => return mod.failNode(scope, node, "async and related features are not yet supported", .{}),
......@@ -792,22 +792,20 @@ pub fn expr(mod: *Module, scope: *Scope, rl: ResultLoc, node: ast.Node.Index) In
792792}
793793
794794pub fn comptimeExpr(
795 mod: *Module,
796 parent_scope: *Scope,
795 gz: *GenZir,
796 scope: *Scope,
797797 rl: ResultLoc,
798798 node: ast.Node.Index,
799799) InnerError!zir.Inst.Ref {
800 const gz = parent_scope.getGenZir();
801
802800 const prev_force_comptime = gz.force_comptime;
803801 gz.force_comptime = true;
804 const result = try expr(mod, parent_scope, rl, node);
802 const result = try expr(gz, scope, rl, node);
805803 gz.force_comptime = prev_force_comptime;
806804 return result;
807805}
808806
809fn breakExpr(mod: *Module, parent_scope: *Scope, node: ast.Node.Index) InnerError!zir.Inst.Ref {
810 const parent_gz = parent_scope.getGenZir();
807fn breakExpr(parent_gz: *GenZir, parent_scope: *Scope, node: ast.Node.Index) InnerError!zir.Inst.Ref {
808 const mod = parent_gz.astgen.mod;
811809 const tree = parent_gz.tree();
812810 const node_datas = tree.nodes.items(.data);
813811 const break_label = node_datas[node].lhs;
......@@ -818,7 +816,7 @@ fn breakExpr(mod: *Module, parent_scope: *Scope, node: ast.Node.Index) InnerErro
818816 while (true) {
819817 switch (scope.tag) {
820818 .gen_zir => {
821 const block_gz = scope.cast(Scope.GenZir).?;
819 const block_gz = scope.cast(GenZir).?;
822820
823821 const block_inst = blk: {
824822 if (break_label != 0) {
......@@ -841,7 +839,7 @@ fn breakExpr(mod: *Module, parent_scope: *Scope, node: ast.Node.Index) InnerErro
841839 }
842840 block_gz.break_count += 1;
843841 const prev_rvalue_rl_count = block_gz.rvalue_rl_count;
844 const operand = try expr(mod, parent_scope, block_gz.break_result_loc, rhs);
842 const operand = try expr(parent_gz, parent_scope, block_gz.break_result_loc, rhs);
845843 const have_store_to_block = block_gz.rvalue_rl_count != prev_rvalue_rl_count;
846844
847845 const br = try parent_gz.addBreak(.@"break", block_inst, operand);
......@@ -872,8 +870,8 @@ fn breakExpr(mod: *Module, parent_scope: *Scope, node: ast.Node.Index) InnerErro
872870 }
873871}
874872
875fn continueExpr(mod: *Module, parent_scope: *Scope, node: ast.Node.Index) InnerError!zir.Inst.Ref {
876 const parent_gz = parent_scope.getGenZir();
873fn continueExpr(parent_gz: *GenZir, parent_scope: *Scope, node: ast.Node.Index) InnerError!zir.Inst.Ref {
874 const mod = parent_gz.astgen.mod;
877875 const tree = parent_gz.tree();
878876 const node_datas = tree.nodes.items(.data);
879877 const break_label = node_datas[node].lhs;
......@@ -883,7 +881,7 @@ fn continueExpr(mod: *Module, parent_scope: *Scope, node: ast.Node.Index) InnerE
883881 while (true) {
884882 switch (scope.tag) {
885883 .gen_zir => {
886 const gen_zir = scope.cast(Scope.GenZir).?;
884 const gen_zir = scope.cast(GenZir).?;
887885 const continue_block = gen_zir.continue_block;
888886 if (continue_block == 0) {
889887 scope = gen_zir.parent;
......@@ -918,7 +916,7 @@ fn continueExpr(mod: *Module, parent_scope: *Scope, node: ast.Node.Index) InnerE
918916}
919917
920918pub fn blockExpr(
921 mod: *Module,
919 gz: *GenZir,
922920 scope: *Scope,
923921 rl: ResultLoc,
924922 block_node: ast.Node.Index,
......@@ -935,11 +933,11 @@ pub fn blockExpr(
935933 if (token_tags[lbrace - 1] == .colon and
936934 token_tags[lbrace - 2] == .identifier)
937935 {
938 return labeledBlockExpr(mod, scope, rl, block_node, statements, .block);
936 return labeledBlockExpr(gz, scope, rl, block_node, statements, .block);
939937 }
940938
941 try blockExprStmts(mod, scope, block_node, statements);
942 return rvalue(mod, scope, rl, .void_value, block_node);
939 try blockExprStmts(gz, scope, block_node, statements);
940 return rvalue(gz, scope, rl, .void_value, block_node);
943941}
944942
945943fn checkLabelRedefinition(mod: *Module, parent_scope: *Scope, label: ast.TokenIndex) !void {
......@@ -948,7 +946,7 @@ fn checkLabelRedefinition(mod: *Module, parent_scope: *Scope, label: ast.TokenIn
948946 while (true) {
949947 switch (scope.tag) {
950948 .gen_zir => {
951 const gen_zir = scope.cast(Scope.GenZir).?;
949 const gen_zir = scope.cast(GenZir).?;
952950 if (gen_zir.label) |prev_label| {
953951 if (try tokenIdentEql(mod, parent_scope, label, prev_label.token)) {
954952 const tree = parent_scope.tree();
......@@ -985,7 +983,7 @@ fn checkLabelRedefinition(mod: *Module, parent_scope: *Scope, label: ast.TokenIn
985983}
986984
987985fn labeledBlockExpr(
988 mod: *Module,
986 gz: *GenZir,
989987 parent_scope: *Scope,
990988 rl: ResultLoc,
991989 block_node: ast.Node.Index,
......@@ -997,6 +995,7 @@ fn labeledBlockExpr(
997995
998996 assert(zir_tag == .block);
999997
998 const mod = gz.astgen.mod;
1000999 const tree = parent_scope.tree();
10011000 const main_tokens = tree.nodes.items(.main_token);
10021001 const token_tags = tree.tokens.items(.tag);
......@@ -1009,17 +1008,16 @@ fn labeledBlockExpr(
10091008
10101009 // Reserve the Block ZIR instruction index so that we can put it into the GenZir struct
10111010 // so that break statements can reference it.
1012 const gz = parent_scope.getGenZir();
10131011 const block_inst = try gz.addBlock(zir_tag, block_node);
10141012 try gz.instructions.append(mod.gpa, block_inst);
10151013
1016 var block_scope: Scope.GenZir = .{
1014 var block_scope: GenZir = .{
10171015 .parent = parent_scope,
10181016 .astgen = gz.astgen,
10191017 .force_comptime = gz.force_comptime,
10201018 .instructions = .{},
10211019 // TODO @as here is working around a stage1 miscompilation bug :(
1022 .label = @as(?Scope.GenZir.Label, Scope.GenZir.Label{
1020 .label = @as(?GenZir.Label, GenZir.Label{
10231021 .token = label_token,
10241022 .block_inst = block_inst,
10251023 }),
......@@ -1029,7 +1027,7 @@ fn labeledBlockExpr(
10291027 defer block_scope.labeled_breaks.deinit(mod.gpa);
10301028 defer block_scope.labeled_store_to_block_ptr_list.deinit(mod.gpa);
10311029
1032 try blockExprStmts(mod, &block_scope.base, block_node, statements);
1030 try blockExprStmts(&block_scope, &block_scope.base, block_node, statements);
10331031
10341032 if (!block_scope.label.?.used) {
10351033 return mod.failTok(parent_scope, label_token, "unused block label", .{});
......@@ -1064,14 +1062,14 @@ fn labeledBlockExpr(
10641062 const block_ref = gz.astgen.indexToRef(block_inst);
10651063 switch (rl) {
10661064 .ref => return block_ref,
1067 else => return rvalue(mod, parent_scope, rl, block_ref, block_node),
1065 else => return rvalue(gz, parent_scope, rl, block_ref, block_node),
10681066 }
10691067 },
10701068 }
10711069}
10721070
10731071fn blockExprStmts(
1074 mod: *Module,
1072 gz: *GenZir,
10751073 parent_scope: *Scope,
10761074 node: ast.Node.Index,
10771075 statements: []const ast.Node.Index,
......@@ -1080,41 +1078,39 @@ fn blockExprStmts(
10801078 const main_tokens = tree.nodes.items(.main_token);
10811079 const node_tags = tree.nodes.items(.tag);
10821080
1083 var block_arena = std.heap.ArenaAllocator.init(mod.gpa);
1081 var block_arena = std.heap.ArenaAllocator.init(gz.astgen.mod.gpa);
10841082 defer block_arena.deinit();
10851083
1086 const gz = parent_scope.getGenZir();
1087
10881084 var scope = parent_scope;
10891085 for (statements) |statement| {
10901086 if (!gz.force_comptime) {
10911087 _ = try gz.addNode(.dbg_stmt_node, statement);
10921088 }
10931089 switch (node_tags[statement]) {
1094 .global_var_decl => scope = try varDecl(mod, scope, statement, &block_arena.allocator, tree.globalVarDecl(statement)),
1095 .local_var_decl => scope = try varDecl(mod, scope, statement, &block_arena.allocator, tree.localVarDecl(statement)),
1096 .simple_var_decl => scope = try varDecl(mod, scope, statement, &block_arena.allocator, tree.simpleVarDecl(statement)),
1097 .aligned_var_decl => scope = try varDecl(mod, scope, statement, &block_arena.allocator, tree.alignedVarDecl(statement)),
1098
1099 .assign => try assign(mod, scope, statement),
1100 .assign_bit_and => try assignOp(mod, scope, statement, .bit_and),
1101 .assign_bit_or => try assignOp(mod, scope, statement, .bit_or),
1102 .assign_bit_shift_left => try assignOp(mod, scope, statement, .shl),
1103 .assign_bit_shift_right => try assignOp(mod, scope, statement, .shr),
1104 .assign_bit_xor => try assignOp(mod, scope, statement, .xor),
1105 .assign_div => try assignOp(mod, scope, statement, .div),
1106 .assign_sub => try assignOp(mod, scope, statement, .sub),
1107 .assign_sub_wrap => try assignOp(mod, scope, statement, .subwrap),
1108 .assign_mod => try assignOp(mod, scope, statement, .mod_rem),
1109 .assign_add => try assignOp(mod, scope, statement, .add),
1110 .assign_add_wrap => try assignOp(mod, scope, statement, .addwrap),
1111 .assign_mul => try assignOp(mod, scope, statement, .mul),
1112 .assign_mul_wrap => try assignOp(mod, scope, statement, .mulwrap),
1090 .global_var_decl => scope = try varDecl(gz, scope, statement, &block_arena.allocator, tree.globalVarDecl(statement)),
1091 .local_var_decl => scope = try varDecl(gz, scope, statement, &block_arena.allocator, tree.localVarDecl(statement)),
1092 .simple_var_decl => scope = try varDecl(gz, scope, statement, &block_arena.allocator, tree.simpleVarDecl(statement)),
1093 .aligned_var_decl => scope = try varDecl(gz, scope, statement, &block_arena.allocator, tree.alignedVarDecl(statement)),
1094
1095 .assign => try assign(gz, scope, statement),
1096 .assign_bit_and => try assignOp(gz, scope, statement, .bit_and),
1097 .assign_bit_or => try assignOp(gz, scope, statement, .bit_or),
1098 .assign_bit_shift_left => try assignOp(gz, scope, statement, .shl),
1099 .assign_bit_shift_right => try assignOp(gz, scope, statement, .shr),
1100 .assign_bit_xor => try assignOp(gz, scope, statement, .xor),
1101 .assign_div => try assignOp(gz, scope, statement, .div),
1102 .assign_sub => try assignOp(gz, scope, statement, .sub),
1103 .assign_sub_wrap => try assignOp(gz, scope, statement, .subwrap),
1104 .assign_mod => try assignOp(gz, scope, statement, .mod_rem),
1105 .assign_add => try assignOp(gz, scope, statement, .add),
1106 .assign_add_wrap => try assignOp(gz, scope, statement, .addwrap),
1107 .assign_mul => try assignOp(gz, scope, statement, .mul),
1108 .assign_mul_wrap => try assignOp(gz, scope, statement, .mulwrap),
11131109
11141110 else => {
11151111 // We need to emit an error if the result is not `noreturn` or `void`, but
11161112 // we want to avoid adding the ZIR instruction if possible for performance.
1117 const maybe_unused_result = try expr(mod, scope, .none, statement);
1113 const maybe_unused_result = try expr(gz, scope, .none, statement);
11181114 const elide_check = if (gz.astgen.refToIndex(maybe_unused_result)) |inst| b: {
11191115 // Note that this array becomes invalid after appending more items to it
11201116 // in the above while loop.
......@@ -1293,19 +1289,19 @@ fn blockExprStmts(
12931289}
12941290
12951291fn varDecl(
1296 mod: *Module,
1292 gz: *GenZir,
12971293 scope: *Scope,
12981294 node: ast.Node.Index,
12991295 block_arena: *Allocator,
13001296 var_decl: ast.full.VarDecl,
13011297) InnerError!*Scope {
1298 const mod = gz.astgen.mod;
13021299 if (var_decl.comptime_token) |comptime_token| {
13031300 return mod.failTok(scope, comptime_token, "TODO implement comptime locals", .{});
13041301 }
13051302 if (var_decl.ast.align_node != 0) {
13061303 return mod.failNode(scope, var_decl.ast.align_node, "TODO implement alignment on locals", .{});
13071304 }
1308 const gz = scope.getGenZir();
13091305 const astgen = gz.astgen;
13101306 const tree = scope.tree();
13111307 const token_tags = tree.tokens.items(.tag);
......@@ -1348,7 +1344,7 @@ fn varDecl(
13481344 }
13491345 s = local_ptr.parent;
13501346 },
1351 .gen_zir => s = s.cast(Scope.GenZir).?.parent,
1347 .gen_zir => s = s.cast(GenZir).?.parent,
13521348 else => break,
13531349 };
13541350 }
......@@ -1369,9 +1365,9 @@ fn varDecl(
13691365 // the variable, no memory location needed.
13701366 if (!nodeMayNeedMemoryLocation(scope, var_decl.ast.init_node)) {
13711367 const result_loc: ResultLoc = if (var_decl.ast.type_node != 0) .{
1372 .ty = try typeExpr(mod, scope, var_decl.ast.type_node),
1368 .ty = try typeExpr(gz, scope, var_decl.ast.type_node),
13731369 } else .none;
1374 const init_inst = try expr(mod, scope, result_loc, var_decl.ast.init_node);
1370 const init_inst = try expr(gz, scope, result_loc, var_decl.ast.init_node);
13751371 const sub_scope = try block_arena.create(Scope.LocalVal);
13761372 sub_scope.* = .{
13771373 .parent = scope,
......@@ -1385,7 +1381,7 @@ fn varDecl(
13851381
13861382 // Detect whether the initialization expression actually uses the
13871383 // result location pointer.
1388 var init_scope: Scope.GenZir = .{
1384 var init_scope: GenZir = .{
13891385 .parent = scope,
13901386 .force_comptime = gz.force_comptime,
13911387 .astgen = astgen,
......@@ -1395,7 +1391,7 @@ fn varDecl(
13951391 var resolve_inferred_alloc: zir.Inst.Ref = .none;
13961392 var opt_type_inst: zir.Inst.Ref = .none;
13971393 if (var_decl.ast.type_node != 0) {
1398 const type_inst = try typeExpr(mod, &init_scope.base, var_decl.ast.type_node);
1394 const type_inst = try typeExpr(gz, &init_scope.base, var_decl.ast.type_node);
13991395 opt_type_inst = type_inst;
14001396 init_scope.rl_ptr = try init_scope.addUnNode(.alloc, type_inst, node);
14011397 } else {
......@@ -1404,7 +1400,7 @@ fn varDecl(
14041400 init_scope.rl_ptr = alloc;
14051401 }
14061402 const init_result_loc: ResultLoc = .{ .block_ptr = &init_scope };
1407 const init_inst = try expr(mod, &init_scope.base, init_result_loc, var_decl.ast.init_node);
1403 const init_inst = try expr(&init_scope, &init_scope.base, init_result_loc, var_decl.ast.init_node);
14081404 const zir_tags = astgen.instructions.items(.tag);
14091405 const zir_datas = astgen.instructions.items(.data);
14101406
......@@ -1476,7 +1472,7 @@ fn varDecl(
14761472 result_loc: ResultLoc,
14771473 alloc: zir.Inst.Ref,
14781474 } = if (var_decl.ast.type_node != 0) a: {
1479 const type_inst = try typeExpr(mod, scope, var_decl.ast.type_node);
1475 const type_inst = try typeExpr(gz, scope, var_decl.ast.type_node);
14801476
14811477 const alloc = try gz.addUnNode(.alloc_mut, type_inst, node);
14821478 break :a .{ .alloc = alloc, .result_loc = .{ .ptr = alloc } };
......@@ -1485,7 +1481,7 @@ fn varDecl(
14851481 resolve_inferred_alloc = alloc;
14861482 break :a .{ .alloc = alloc, .result_loc = .{ .inferred_ptr = alloc } };
14871483 };
1488 const init_inst = try expr(mod, scope, var_data.result_loc, var_decl.ast.init_node);
1484 const init_inst = try expr(gz, scope, var_data.result_loc, var_decl.ast.init_node);
14891485 if (resolve_inferred_alloc != .none) {
14901486 _ = try gz.addUnNode(.resolve_inferred_alloc, resolve_inferred_alloc, node);
14911487 }
......@@ -1503,7 +1499,7 @@ fn varDecl(
15031499 }
15041500}
15051501
1506fn assign(mod: *Module, scope: *Scope, infix_node: ast.Node.Index) InnerError!void {
1502fn assign(gz: *GenZir, scope: *Scope, infix_node: ast.Node.Index) InnerError!void {
15071503 const tree = scope.tree();
15081504 const node_datas = tree.nodes.items(.data);
15091505 const main_tokens = tree.nodes.items(.main_token);
......@@ -1515,28 +1511,27 @@ fn assign(mod: *Module, scope: *Scope, infix_node: ast.Node.Index) InnerError!vo
15151511 // This intentionally does not support `@"_"` syntax.
15161512 const ident_name = tree.tokenSlice(main_tokens[lhs]);
15171513 if (mem.eql(u8, ident_name, "_")) {
1518 _ = try expr(mod, scope, .discard, rhs);
1514 _ = try expr(gz, scope, .discard, rhs);
15191515 return;
15201516 }
15211517 }
1522 const lvalue = try lvalExpr(mod, scope, lhs);
1523 _ = try expr(mod, scope, .{ .ptr = lvalue }, rhs);
1518 const lvalue = try lvalExpr(gz, scope, lhs);
1519 _ = try expr(gz, scope, .{ .ptr = lvalue }, rhs);
15241520}
15251521
15261522fn assignOp(
1527 mod: *Module,
1523 gz: *GenZir,
15281524 scope: *Scope,
15291525 infix_node: ast.Node.Index,
15301526 op_inst_tag: zir.Inst.Tag,
15311527) InnerError!void {
15321528 const tree = scope.tree();
15331529 const node_datas = tree.nodes.items(.data);
1534 const gz = scope.getGenZir();
15351530
1536 const lhs_ptr = try lvalExpr(mod, scope, node_datas[infix_node].lhs);
1531 const lhs_ptr = try lvalExpr(gz, scope, node_datas[infix_node].lhs);
15371532 const lhs = try gz.addUnNode(.load, lhs_ptr, infix_node);
15381533 const lhs_type = try gz.addUnTok(.typeof, lhs, infix_node);
1539 const rhs = try expr(mod, scope, .{ .ty = lhs_type }, node_datas[infix_node].rhs);
1534 const rhs = try expr(gz, scope, .{ .ty = lhs_type }, node_datas[infix_node].rhs);
15401535
15411536 const result = try gz.addPlNode(op_inst_tag, infix_node, zir.Inst.Bin{
15421537 .lhs = lhs,
......@@ -1545,28 +1540,26 @@ fn assignOp(
15451540 _ = try gz.addBin(.store, lhs_ptr, result);
15461541}
15471542
1548fn boolNot(mod: *Module, scope: *Scope, rl: ResultLoc, node: ast.Node.Index) InnerError!zir.Inst.Ref {
1543fn boolNot(gz: *GenZir, scope: *Scope, rl: ResultLoc, node: ast.Node.Index) InnerError!zir.Inst.Ref {
15491544 const tree = scope.tree();
15501545 const node_datas = tree.nodes.items(.data);
15511546
1552 const operand = try expr(mod, scope, .{ .ty = .bool_type }, node_datas[node].lhs);
1553 const gz = scope.getGenZir();
1547 const operand = try expr(gz, scope, .{ .ty = .bool_type }, node_datas[node].lhs);
15541548 const result = try gz.addUnNode(.bool_not, operand, node);
1555 return rvalue(mod, scope, rl, result, node);
1549 return rvalue(gz, scope, rl, result, node);
15561550}
15571551
1558fn bitNot(mod: *Module, scope: *Scope, rl: ResultLoc, node: ast.Node.Index) InnerError!zir.Inst.Ref {
1552fn bitNot(gz: *GenZir, scope: *Scope, rl: ResultLoc, node: ast.Node.Index) InnerError!zir.Inst.Ref {
15591553 const tree = scope.tree();
15601554 const node_datas = tree.nodes.items(.data);
15611555
1562 const gz = scope.getGenZir();
1563 const operand = try expr(mod, scope, .none, node_datas[node].lhs);
1556 const operand = try expr(gz, scope, .none, node_datas[node].lhs);
15641557 const result = try gz.addUnNode(.bit_not, operand, node);
1565 return rvalue(mod, scope, rl, result, node);
1558 return rvalue(gz, scope, rl, result, node);
15661559}
15671560
15681561fn negation(
1569 mod: *Module,
1562 gz: *GenZir,
15701563 scope: *Scope,
15711564 rl: ResultLoc,
15721565 node: ast.Node.Index,
......@@ -1575,23 +1568,21 @@ fn negation(
15751568 const tree = scope.tree();
15761569 const node_datas = tree.nodes.items(.data);
15771570
1578 const gz = scope.getGenZir();
1579 const operand = try expr(mod, scope, .none, node_datas[node].lhs);
1571 const operand = try expr(gz, scope, .none, node_datas[node].lhs);
15801572 const result = try gz.addUnNode(tag, operand, node);
1581 return rvalue(mod, scope, rl, result, node);
1573 return rvalue(gz, scope, rl, result, node);
15821574}
15831575
15841576fn ptrType(
1585 mod: *Module,
1577 gz: *GenZir,
15861578 scope: *Scope,
15871579 rl: ResultLoc,
15881580 node: ast.Node.Index,
15891581 ptr_info: ast.full.PtrType,
15901582) InnerError!zir.Inst.Ref {
15911583 const tree = scope.tree();
1592 const gz = scope.getGenZir();
15931584
1594 const elem_type = try typeExpr(mod, scope, ptr_info.ast.child_type);
1585 const elem_type = try typeExpr(gz, scope, ptr_info.ast.child_type);
15951586
15961587 const simple = ptr_info.ast.align_node == 0 and
15971588 ptr_info.ast.sentinel == 0 and
......@@ -1607,7 +1598,7 @@ fn ptrType(
16071598 .elem_type = elem_type,
16081599 },
16091600 } });
1610 return rvalue(mod, scope, rl, result, node);
1601 return rvalue(gz, scope, rl, result, node);
16111602 }
16121603
16131604 var sentinel_ref: zir.Inst.Ref = .none;
......@@ -1617,17 +1608,17 @@ fn ptrType(
16171608 var trailing_count: u32 = 0;
16181609
16191610 if (ptr_info.ast.sentinel != 0) {
1620 sentinel_ref = try expr(mod, scope, .{ .ty = elem_type }, ptr_info.ast.sentinel);
1611 sentinel_ref = try expr(gz, scope, .{ .ty = elem_type }, ptr_info.ast.sentinel);
16211612 trailing_count += 1;
16221613 }
16231614 if (ptr_info.ast.align_node != 0) {
1624 align_ref = try expr(mod, scope, .none, ptr_info.ast.align_node);
1615 align_ref = try expr(gz, scope, .none, ptr_info.ast.align_node);
16251616 trailing_count += 1;
16261617 }
16271618 if (ptr_info.ast.bit_range_start != 0) {
16281619 assert(ptr_info.ast.bit_range_end != 0);
1629 bit_start_ref = try expr(mod, scope, .none, ptr_info.ast.bit_range_start);
1630 bit_end_ref = try expr(mod, scope, .none, ptr_info.ast.bit_range_end);
1620 bit_start_ref = try expr(gz, scope, .none, ptr_info.ast.bit_range_start);
1621 bit_end_ref = try expr(gz, scope, .none, ptr_info.ast.bit_range_end);
16311622 trailing_count += 2;
16321623 }
16331624
......@@ -1667,54 +1658,51 @@ fn ptrType(
16671658 } });
16681659 gz.instructions.appendAssumeCapacity(new_index);
16691660
1670 return rvalue(mod, scope, rl, result, node);
1661 return rvalue(gz, scope, rl, result, node);
16711662}
16721663
1673fn arrayType(mod: *Module, scope: *Scope, rl: ResultLoc, node: ast.Node.Index) !zir.Inst.Ref {
1664fn arrayType(gz: *GenZir, scope: *Scope, rl: ResultLoc, node: ast.Node.Index) !zir.Inst.Ref {
16741665 const tree = scope.tree();
16751666 const node_datas = tree.nodes.items(.data);
1676 const gz = scope.getGenZir();
16771667
16781668 // TODO check for [_]T
1679 const len = try expr(mod, scope, .{ .ty = .usize_type }, node_datas[node].lhs);
1680 const elem_type = try typeExpr(mod, scope, node_datas[node].rhs);
1669 const len = try expr(gz, scope, .{ .ty = .usize_type }, node_datas[node].lhs);
1670 const elem_type = try typeExpr(gz, scope, node_datas[node].rhs);
16811671
16821672 const result = try gz.addBin(.array_type, len, elem_type);
1683 return rvalue(mod, scope, rl, result, node);
1673 return rvalue(gz, scope, rl, result, node);
16841674}
16851675
1686fn arrayTypeSentinel(mod: *Module, scope: *Scope, rl: ResultLoc, node: ast.Node.Index) !zir.Inst.Ref {
1676fn arrayTypeSentinel(gz: *GenZir, scope: *Scope, rl: ResultLoc, node: ast.Node.Index) !zir.Inst.Ref {
16871677 const tree = scope.tree();
16881678 const node_datas = tree.nodes.items(.data);
16891679 const extra = tree.extraData(node_datas[node].rhs, ast.Node.ArrayTypeSentinel);
1690 const gz = scope.getGenZir();
16911680
16921681 // TODO check for [_]T
1693 const len = try expr(mod, scope, .{ .ty = .usize_type }, node_datas[node].lhs);
1694 const elem_type = try typeExpr(mod, scope, extra.elem_type);
1695 const sentinel = try expr(mod, scope, .{ .ty = elem_type }, extra.sentinel);
1682 const len = try expr(gz, scope, .{ .ty = .usize_type }, node_datas[node].lhs);
1683 const elem_type = try typeExpr(gz, scope, extra.elem_type);
1684 const sentinel = try expr(gz, scope, .{ .ty = elem_type }, extra.sentinel);
16961685
16971686 const result = try gz.addArrayTypeSentinel(len, elem_type, sentinel);
1698 return rvalue(mod, scope, rl, result, node);
1687 return rvalue(gz, scope, rl, result, node);
16991688}
17001689
17011690fn containerDecl(
1702 mod: *Module,
1691 gz: *GenZir,
17031692 scope: *Scope,
17041693 rl: ResultLoc,
17051694 container_decl: ast.full.ContainerDecl,
17061695) InnerError!zir.Inst.Ref {
1707 return mod.failTok(scope, container_decl.ast.main_token, "TODO implement container decls", .{});
1696 return gz.astgen.mod.failTok(scope, container_decl.ast.main_token, "TODO implement container decls", .{});
17081697}
17091698
17101699fn errorSetDecl(
1711 mod: *Module,
1700 gz: *GenZir,
17121701 scope: *Scope,
17131702 rl: ResultLoc,
17141703 node: ast.Node.Index,
17151704) InnerError!zir.Inst.Ref {
17161705 if (true) @panic("TODO update for zir-memory-layout branch");
1717 const gz = scope.getGenZir();
17181706 const tree = gz.tree();
17191707 const main_tokens = tree.nodes.items(.main_token);
17201708 const token_tags = tree.tokens.items(.tag);
......@@ -1751,11 +1739,11 @@ fn errorSetDecl(
17511739 }
17521740 }
17531741 const result = try addZIRInst(mod, scope, src, zir.Inst.ErrorSet, .{ .fields = fields }, .{});
1754 return rvalue(mod, scope, rl, result);
1742 return rvalue(gz, scope, rl, result);
17551743}
17561744
17571745fn orelseCatchExpr(
1758 mod: *Module,
1746 parent_gz: *GenZir,
17591747 scope: *Scope,
17601748 rl: ResultLoc,
17611749 node: ast.Node.Index,
......@@ -1766,10 +1754,10 @@ fn orelseCatchExpr(
17661754 rhs: ast.Node.Index,
17671755 payload_token: ?ast.TokenIndex,
17681756) InnerError!zir.Inst.Ref {
1769 const parent_gz = scope.getGenZir();
1757 const mod = parent_gz.astgen.mod;
17701758 const tree = parent_gz.tree();
17711759
1772 var block_scope: Scope.GenZir = .{
1760 var block_scope: GenZir = .{
17731761 .parent = scope,
17741762 .astgen = parent_gz.astgen,
17751763 .force_comptime = parent_gz.force_comptime,
......@@ -1797,7 +1785,7 @@ fn orelseCatchExpr(
17971785 break :blk .{ .ty = wrapped_ty };
17981786 },
17991787 };
1800 const operand = try expr(mod, &block_scope.base, operand_rl, lhs);
1788 const operand = try expr(&block_scope, &block_scope.base, operand_rl, lhs);
18011789 const cond = try block_scope.addUnNode(cond_op, operand, node);
18021790 const condbr = try block_scope.addCondBr(.condbr, node);
18031791
......@@ -1805,7 +1793,7 @@ fn orelseCatchExpr(
18051793 try parent_gz.instructions.append(mod.gpa, block);
18061794 try block_scope.setBlockBody(block);
18071795
1808 var then_scope: Scope.GenZir = .{
1796 var then_scope: GenZir = .{
18091797 .parent = scope,
18101798 .astgen = parent_gz.astgen,
18111799 .force_comptime = block_scope.force_comptime,
......@@ -1831,12 +1819,12 @@ fn orelseCatchExpr(
18311819 };
18321820
18331821 block_scope.break_count += 1;
1834 const then_result = try expr(mod, then_sub_scope, block_scope.break_result_loc, rhs);
1822 const then_result = try expr(&then_scope, then_sub_scope, block_scope.break_result_loc, rhs);
18351823 // We hold off on the break instructions as well as copying the then/else
18361824 // instructions into place until we know whether to keep store_to_block_ptr
18371825 // instructions or not.
18381826
1839 var else_scope: Scope.GenZir = .{
1827 var else_scope: GenZir = .{
18401828 .parent = scope,
18411829 .astgen = parent_gz.astgen,
18421830 .force_comptime = block_scope.force_comptime,
......@@ -1848,11 +1836,11 @@ fn orelseCatchExpr(
18481836 const unwrapped_payload = try else_scope.addUnNode(unwrap_op, operand, node);
18491837 const else_result = switch (rl) {
18501838 .ref => unwrapped_payload,
1851 else => try rvalue(mod, &else_scope.base, block_scope.break_result_loc, unwrapped_payload, node),
1839 else => try rvalue(&else_scope, &else_scope.base, block_scope.break_result_loc, unwrapped_payload, node),
18521840 };
18531841
18541842 return finishThenElseBlock(
1855 mod,
1843 parent_gz,
18561844 scope,
18571845 rl,
18581846 node,
......@@ -1872,13 +1860,13 @@ fn orelseCatchExpr(
18721860}
18731861
18741862fn finishThenElseBlock(
1875 mod: *Module,
1863 parent_gz: *GenZir,
18761864 parent_scope: *Scope,
18771865 rl: ResultLoc,
18781866 node: ast.Node.Index,
1879 block_scope: *Scope.GenZir,
1880 then_scope: *Scope.GenZir,
1881 else_scope: *Scope.GenZir,
1867 block_scope: *GenZir,
1868 then_scope: *GenZir,
1869 else_scope: *GenZir,
18821870 condbr: zir.Inst.Index,
18831871 cond: zir.Inst.Ref,
18841872 then_src: ast.Node.Index,
......@@ -1925,7 +1913,7 @@ fn finishThenElseBlock(
19251913 const block_ref = astgen.indexToRef(main_block);
19261914 switch (rl) {
19271915 .ref => return block_ref,
1928 else => return rvalue(mod, parent_scope, rl, block_ref, node),
1916 else => return rvalue(parent_gz, parent_scope, rl, block_ref, node),
19291917 }
19301918 },
19311919 }
......@@ -1942,15 +1930,16 @@ fn tokenIdentEql(mod: *Module, scope: *Scope, token1: ast.TokenIndex, token2: as
19421930}
19431931
19441932pub fn fieldAccess(
1945 mod: *Module,
1933 gz: *GenZir,
19461934 scope: *Scope,
19471935 rl: ResultLoc,
19481936 node: ast.Node.Index,
19491937) InnerError!zir.Inst.Ref {
1950 const gz = scope.getGenZir();
1938 const mod = gz.astgen.mod;
19511939 const tree = gz.tree();
19521940 const main_tokens = tree.nodes.items(.main_token);
19531941 const node_datas = tree.nodes.items(.data);
1942
19541943 const object_node = node_datas[node].lhs;
19551944 const dot_token = main_tokens[node];
19561945 const field_ident = dot_token + 1;
......@@ -1960,111 +1949,109 @@ pub fn fieldAccess(
19601949 try string_bytes.append(mod.gpa, 0);
19611950 switch (rl) {
19621951 .ref => return gz.addPlNode(.field_ptr, node, zir.Inst.Field{
1963 .lhs = try expr(mod, scope, .ref, object_node),
1952 .lhs = try expr(gz, scope, .ref, object_node),
19641953 .field_name_start = str_index,
19651954 }),
1966 else => return rvalue(mod, scope, rl, try gz.addPlNode(.field_val, node, zir.Inst.Field{
1967 .lhs = try expr(mod, scope, .none, object_node),
1955 else => return rvalue(gz, scope, rl, try gz.addPlNode(.field_val, node, zir.Inst.Field{
1956 .lhs = try expr(gz, scope, .none, object_node),
19681957 .field_name_start = str_index,
19691958 }), node),
19701959 }
19711960}
19721961
19731962fn arrayAccess(
1974 mod: *Module,
1963 gz: *GenZir,
19751964 scope: *Scope,
19761965 rl: ResultLoc,
19771966 node: ast.Node.Index,
19781967) InnerError!zir.Inst.Ref {
1979 const gz = scope.getGenZir();
19801968 const tree = gz.tree();
19811969 const main_tokens = tree.nodes.items(.main_token);
19821970 const node_datas = tree.nodes.items(.data);
19831971 switch (rl) {
19841972 .ref => return gz.addBin(
19851973 .elem_ptr,
1986 try expr(mod, scope, .ref, node_datas[node].lhs),
1987 try expr(mod, scope, .{ .ty = .usize_type }, node_datas[node].rhs),
1974 try expr(gz, scope, .ref, node_datas[node].lhs),
1975 try expr(gz, scope, .{ .ty = .usize_type }, node_datas[node].rhs),
19881976 ),
1989 else => return rvalue(mod, scope, rl, try gz.addBin(
1977 else => return rvalue(gz, scope, rl, try gz.addBin(
19901978 .elem_val,
1991 try expr(mod, scope, .none, node_datas[node].lhs),
1992 try expr(mod, scope, .{ .ty = .usize_type }, node_datas[node].rhs),
1979 try expr(gz, scope, .none, node_datas[node].lhs),
1980 try expr(gz, scope, .{ .ty = .usize_type }, node_datas[node].rhs),
19931981 ), node),
19941982 }
19951983}
19961984
19971985fn simpleBinOp(
1998 mod: *Module,
1986 gz: *GenZir,
19991987 scope: *Scope,
20001988 rl: ResultLoc,
20011989 node: ast.Node.Index,
20021990 op_inst_tag: zir.Inst.Tag,
20031991) InnerError!zir.Inst.Ref {
2004 const gz = scope.getGenZir();
20051992 const tree = gz.tree();
20061993 const node_datas = tree.nodes.items(.data);
20071994
20081995 const result = try gz.addPlNode(op_inst_tag, node, zir.Inst.Bin{
2009 .lhs = try expr(mod, scope, .none, node_datas[node].lhs),
2010 .rhs = try expr(mod, scope, .none, node_datas[node].rhs),
1996 .lhs = try expr(gz, scope, .none, node_datas[node].lhs),
1997 .rhs = try expr(gz, scope, .none, node_datas[node].rhs),
20111998 });
2012 return rvalue(mod, scope, rl, result, node);
1999 return rvalue(gz, scope, rl, result, node);
20132000}
20142001
20152002fn simpleStrTok(
2016 mod: *Module,
2003 gz: *GenZir,
20172004 scope: *Scope,
20182005 rl: ResultLoc,
20192006 ident_token: ast.TokenIndex,
20202007 node: ast.Node.Index,
20212008 op_inst_tag: zir.Inst.Tag,
20222009) InnerError!zir.Inst.Ref {
2023 const gz = scope.getGenZir();
2010 const mod = gz.astgen.mod;
20242011 const string_bytes = &gz.astgen.string_bytes;
20252012 const str_index = @intCast(u32, string_bytes.items.len);
20262013 try mod.appendIdentStr(scope, ident_token, string_bytes);
20272014 try string_bytes.append(mod.gpa, 0);
20282015 const result = try gz.addStrTok(op_inst_tag, str_index, ident_token);
2029 return rvalue(mod, scope, rl, result, node);
2016 return rvalue(gz, scope, rl, result, node);
20302017}
20312018
20322019fn boolBinOp(
2033 mod: *Module,
2020 gz: *GenZir,
20342021 scope: *Scope,
20352022 rl: ResultLoc,
20362023 node: ast.Node.Index,
20372024 zir_tag: zir.Inst.Tag,
20382025) InnerError!zir.Inst.Ref {
2039 const gz = scope.getGenZir();
20402026 const node_datas = gz.tree().nodes.items(.data);
20412027
2042 const lhs = try expr(mod, scope, .{ .ty = .bool_type }, node_datas[node].lhs);
2028 const lhs = try expr(gz, scope, .{ .ty = .bool_type }, node_datas[node].lhs);
20432029 const bool_br = try gz.addBoolBr(zir_tag, lhs);
20442030
2045 var rhs_scope: Scope.GenZir = .{
2031 var rhs_scope: GenZir = .{
20462032 .parent = scope,
20472033 .astgen = gz.astgen,
20482034 .force_comptime = gz.force_comptime,
20492035 };
2050 defer rhs_scope.instructions.deinit(mod.gpa);
2051 const rhs = try expr(mod, &rhs_scope.base, .{ .ty = .bool_type }, node_datas[node].rhs);
2036 defer rhs_scope.instructions.deinit(gz.astgen.mod.gpa);
2037 const rhs = try expr(&rhs_scope, &rhs_scope.base, .{ .ty = .bool_type }, node_datas[node].rhs);
20522038 _ = try rhs_scope.addBreak(.break_inline, bool_br, rhs);
20532039 try rhs_scope.setBoolBrBody(bool_br);
20542040
20552041 const block_ref = gz.astgen.indexToRef(bool_br);
2056 return rvalue(mod, scope, rl, block_ref, node);
2042 return rvalue(gz, scope, rl, block_ref, node);
20572043}
20582044
20592045fn ifExpr(
2060 mod: *Module,
2046 parent_gz: *GenZir,
20612047 scope: *Scope,
20622048 rl: ResultLoc,
20632049 node: ast.Node.Index,
20642050 if_full: ast.full.If,
20652051) InnerError!zir.Inst.Ref {
2066 const parent_gz = scope.getGenZir();
2067 var block_scope: Scope.GenZir = .{
2052 const mod = parent_gz.astgen.mod;
2053
2054 var block_scope: GenZir = .{
20682055 .parent = scope,
20692056 .astgen = parent_gz.astgen,
20702057 .force_comptime = parent_gz.force_comptime,
......@@ -2080,7 +2067,7 @@ fn ifExpr(
20802067 } else if (if_full.payload_token) |payload_token| {
20812068 return mod.failTok(scope, payload_token, "TODO implement if optional", .{});
20822069 } else {
2083 break :c try expr(mod, &block_scope.base, .{ .ty = .bool_type }, if_full.ast.cond_expr);
2070 break :c try expr(&block_scope, &block_scope.base, .{ .ty = .bool_type }, if_full.ast.cond_expr);
20842071 }
20852072 };
20862073
......@@ -2090,7 +2077,7 @@ fn ifExpr(
20902077 try parent_gz.instructions.append(mod.gpa, block);
20912078 try block_scope.setBlockBody(block);
20922079
2093 var then_scope: Scope.GenZir = .{
2080 var then_scope: GenZir = .{
20942081 .parent = scope,
20952082 .astgen = parent_gz.astgen,
20962083 .force_comptime = block_scope.force_comptime,
......@@ -2102,12 +2089,12 @@ fn ifExpr(
21022089 const then_sub_scope = &then_scope.base;
21032090
21042091 block_scope.break_count += 1;
2105 const then_result = try expr(mod, then_sub_scope, block_scope.break_result_loc, if_full.ast.then_expr);
2092 const then_result = try expr(&then_scope, then_sub_scope, block_scope.break_result_loc, if_full.ast.then_expr);
21062093 // We hold off on the break instructions as well as copying the then/else
21072094 // instructions into place until we know whether to keep store_to_block_ptr
21082095 // instructions or not.
21092096
2110 var else_scope: Scope.GenZir = .{
2097 var else_scope: GenZir = .{
21112098 .parent = scope,
21122099 .astgen = parent_gz.astgen,
21132100 .force_comptime = block_scope.force_comptime,
......@@ -2124,7 +2111,7 @@ fn ifExpr(
21242111 const sub_scope = &else_scope.base;
21252112 break :blk .{
21262113 .src = else_node,
2127 .result = try expr(mod, sub_scope, block_scope.break_result_loc, else_node),
2114 .result = try expr(&else_scope, sub_scope, block_scope.break_result_loc, else_node),
21282115 };
21292116 } else .{
21302117 .src = if_full.ast.then_expr,
......@@ -2132,7 +2119,7 @@ fn ifExpr(
21322119 };
21332120
21342121 return finishThenElseBlock(
2135 mod,
2122 parent_gz,
21362123 scope,
21372124 rl,
21382125 node,
......@@ -2154,8 +2141,8 @@ fn ifExpr(
21542141fn setCondBrPayload(
21552142 condbr: zir.Inst.Index,
21562143 cond: zir.Inst.Ref,
2157 then_scope: *Scope.GenZir,
2158 else_scope: *Scope.GenZir,
2144 then_scope: *GenZir,
2145 else_scope: *GenZir,
21592146) !void {
21602147 const astgen = then_scope.astgen;
21612148
......@@ -2177,8 +2164,8 @@ fn setCondBrPayload(
21772164fn setCondBrPayloadElideBlockStorePtr(
21782165 condbr: zir.Inst.Index,
21792166 cond: zir.Inst.Ref,
2180 then_scope: *Scope.GenZir,
2181 else_scope: *Scope.GenZir,
2167 then_scope: *GenZir,
2168 else_scope: *GenZir,
21822169) !void {
21832170 const astgen = then_scope.astgen;
21842171
......@@ -2194,7 +2181,7 @@ fn setCondBrPayloadElideBlockStorePtr(
21942181 });
21952182
21962183 const zir_tags = astgen.instructions.items(.tag);
2197 for ([_]*Scope.GenZir{ then_scope, else_scope }) |scope| {
2184 for ([_]*GenZir{ then_scope, else_scope }) |scope| {
21982185 for (scope.instructions.items) |src_inst| {
21992186 if (zir_tags[src_inst] != .store_to_block_ptr) {
22002187 astgen.extra.appendAssumeCapacity(src_inst);
......@@ -2204,22 +2191,23 @@ fn setCondBrPayloadElideBlockStorePtr(
22042191}
22052192
22062193fn whileExpr(
2207 mod: *Module,
2194 parent_gz: *GenZir,
22082195 scope: *Scope,
22092196 rl: ResultLoc,
22102197 node: ast.Node.Index,
22112198 while_full: ast.full.While,
22122199) InnerError!zir.Inst.Ref {
2200 const mod = parent_gz.astgen.mod;
22132201 if (while_full.label_token) |label_token| {
22142202 try checkLabelRedefinition(mod, scope, label_token);
22152203 }
2216 const parent_gz = scope.getGenZir();
2204
22172205 const is_inline = parent_gz.force_comptime or while_full.inline_token != null;
22182206 const loop_tag: zir.Inst.Tag = if (is_inline) .block_inline else .loop;
22192207 const loop_block = try parent_gz.addBlock(loop_tag, node);
22202208 try parent_gz.instructions.append(mod.gpa, loop_block);
22212209
2222 var loop_scope: Scope.GenZir = .{
2210 var loop_scope: GenZir = .{
22232211 .parent = scope,
22242212 .astgen = parent_gz.astgen,
22252213 .force_comptime = parent_gz.force_comptime,
......@@ -2228,7 +2216,7 @@ fn whileExpr(
22282216 loop_scope.setBreakResultLoc(rl);
22292217 defer loop_scope.instructions.deinit(mod.gpa);
22302218
2231 var continue_scope: Scope.GenZir = .{
2219 var continue_scope: GenZir = .{
22322220 .parent = &loop_scope.base,
22332221 .astgen = parent_gz.astgen,
22342222 .force_comptime = loop_scope.force_comptime,
......@@ -2244,7 +2232,7 @@ fn whileExpr(
22442232 return mod.failTok(scope, payload_token, "TODO implement while optional", .{});
22452233 } else {
22462234 const bool_type_rl: ResultLoc = .{ .ty = .bool_type };
2247 break :c try expr(mod, &continue_scope.base, bool_type_rl, while_full.ast.cond_expr);
2235 break :c try expr(&continue_scope, &continue_scope.base, bool_type_rl, while_full.ast.cond_expr);
22482236 }
22492237 };
22502238
......@@ -2259,7 +2247,7 @@ fn whileExpr(
22592247 // are no jumps to it. This happens when the last statement of a while body is noreturn
22602248 // and there are no `continue` statements.
22612249 if (while_full.ast.cont_expr != 0) {
2262 _ = try expr(mod, &loop_scope.base, .{ .ty = .void_type }, while_full.ast.cont_expr);
2250 _ = try expr(&loop_scope, &loop_scope.base, .{ .ty = .void_type }, while_full.ast.cont_expr);
22632251 }
22642252 const repeat_tag: zir.Inst.Tag = if (is_inline) .repeat_inline else .repeat;
22652253 _ = try loop_scope.addNode(repeat_tag, node);
......@@ -2268,13 +2256,13 @@ fn whileExpr(
22682256 loop_scope.break_block = loop_block;
22692257 loop_scope.continue_block = cond_block;
22702258 if (while_full.label_token) |label_token| {
2271 loop_scope.label = @as(?Scope.GenZir.Label, Scope.GenZir.Label{
2259 loop_scope.label = @as(?GenZir.Label, GenZir.Label{
22722260 .token = label_token,
22732261 .block_inst = loop_block,
22742262 });
22752263 }
22762264
2277 var then_scope: Scope.GenZir = .{
2265 var then_scope: GenZir = .{
22782266 .parent = &continue_scope.base,
22792267 .astgen = parent_gz.astgen,
22802268 .force_comptime = continue_scope.force_comptime,
......@@ -2285,9 +2273,9 @@ fn whileExpr(
22852273 const then_sub_scope = &then_scope.base;
22862274
22872275 loop_scope.break_count += 1;
2288 const then_result = try expr(mod, then_sub_scope, loop_scope.break_result_loc, while_full.ast.then_expr);
2276 const then_result = try expr(&then_scope, then_sub_scope, loop_scope.break_result_loc, while_full.ast.then_expr);
22892277
2290 var else_scope: Scope.GenZir = .{
2278 var else_scope: GenZir = .{
22912279 .parent = &continue_scope.base,
22922280 .astgen = parent_gz.astgen,
22932281 .force_comptime = continue_scope.force_comptime,
......@@ -2304,7 +2292,7 @@ fn whileExpr(
23042292 const sub_scope = &else_scope.base;
23052293 break :blk .{
23062294 .src = else_node,
2307 .result = try expr(mod, sub_scope, loop_scope.break_result_loc, else_node),
2295 .result = try expr(&else_scope, sub_scope, loop_scope.break_result_loc, else_node),
23082296 };
23092297 } else .{
23102298 .src = while_full.ast.then_expr,
......@@ -2318,7 +2306,7 @@ fn whileExpr(
23182306 }
23192307 const break_tag: zir.Inst.Tag = if (is_inline) .break_inline else .@"break";
23202308 return finishThenElseBlock(
2321 mod,
2309 parent_gz,
23222310 scope,
23232311 rl,
23242312 node,
......@@ -2338,22 +2326,22 @@ fn whileExpr(
23382326}
23392327
23402328fn forExpr(
2341 mod: *Module,
2329 parent_gz: *GenZir,
23422330 scope: *Scope,
23432331 rl: ResultLoc,
23442332 node: ast.Node.Index,
23452333 for_full: ast.full.While,
23462334) InnerError!zir.Inst.Ref {
2335 const mod = parent_gz.astgen.mod;
23472336 if (for_full.label_token) |label_token| {
23482337 try checkLabelRedefinition(mod, scope, label_token);
23492338 }
23502339 // Set up variables and constants.
2351 const parent_gz = scope.getGenZir();
23522340 const is_inline = parent_gz.force_comptime or for_full.inline_token != null;
23532341 const tree = parent_gz.tree();
23542342 const token_tags = tree.tokens.items(.tag);
23552343
2356 const array_ptr = try expr(mod, scope, .ref, for_full.ast.cond_expr);
2344 const array_ptr = try expr(parent_gz, scope, .ref, for_full.ast.cond_expr);
23572345 const len = try parent_gz.addUnNode(.indexable_ptr_len, array_ptr, for_full.ast.cond_expr);
23582346
23592347 const index_ptr = blk: {
......@@ -2367,7 +2355,7 @@ fn forExpr(
23672355 const loop_block = try parent_gz.addBlock(loop_tag, node);
23682356 try parent_gz.instructions.append(mod.gpa, loop_block);
23692357
2370 var loop_scope: Scope.GenZir = .{
2358 var loop_scope: GenZir = .{
23712359 .parent = scope,
23722360 .astgen = parent_gz.astgen,
23732361 .force_comptime = parent_gz.force_comptime,
......@@ -2376,7 +2364,7 @@ fn forExpr(
23762364 loop_scope.setBreakResultLoc(rl);
23772365 defer loop_scope.instructions.deinit(mod.gpa);
23782366
2379 var cond_scope: Scope.GenZir = .{
2367 var cond_scope: GenZir = .{
23802368 .parent = &loop_scope.base,
23812369 .astgen = parent_gz.astgen,
23822370 .force_comptime = loop_scope.force_comptime,
......@@ -2412,13 +2400,13 @@ fn forExpr(
24122400 loop_scope.break_block = loop_block;
24132401 loop_scope.continue_block = cond_block;
24142402 if (for_full.label_token) |label_token| {
2415 loop_scope.label = @as(?Scope.GenZir.Label, Scope.GenZir.Label{
2403 loop_scope.label = @as(?GenZir.Label, GenZir.Label{
24162404 .token = label_token,
24172405 .block_inst = loop_block,
24182406 });
24192407 }
24202408
2421 var then_scope: Scope.GenZir = .{
2409 var then_scope: GenZir = .{
24222410 .parent = &cond_scope.base,
24232411 .astgen = parent_gz.astgen,
24242412 .force_comptime = cond_scope.force_comptime,
......@@ -2460,9 +2448,9 @@ fn forExpr(
24602448 };
24612449
24622450 loop_scope.break_count += 1;
2463 const then_result = try expr(mod, then_sub_scope, loop_scope.break_result_loc, for_full.ast.then_expr);
2451 const then_result = try expr(&then_scope, then_sub_scope, loop_scope.break_result_loc, for_full.ast.then_expr);
24642452
2465 var else_scope: Scope.GenZir = .{
2453 var else_scope: GenZir = .{
24662454 .parent = &cond_scope.base,
24672455 .astgen = parent_gz.astgen,
24682456 .force_comptime = cond_scope.force_comptime,
......@@ -2479,7 +2467,7 @@ fn forExpr(
24792467 const sub_scope = &else_scope.base;
24802468 break :blk .{
24812469 .src = else_node,
2482 .result = try expr(mod, sub_scope, loop_scope.break_result_loc, else_node),
2470 .result = try expr(&else_scope, sub_scope, loop_scope.break_result_loc, else_node),
24832471 };
24842472 } else .{
24852473 .src = for_full.ast.then_expr,
......@@ -2493,7 +2481,7 @@ fn forExpr(
24932481 }
24942482 const break_tag: zir.Inst.Tag = if (is_inline) .break_inline else .@"break";
24952483 return finishThenElseBlock(
2496 mod,
2484 parent_gz,
24972485 scope,
24982486 rl,
24992487 node,
......@@ -2528,7 +2516,7 @@ fn getRangeNode(
25282516}
25292517
25302518fn switchExpr(
2531 mod: *Module,
2519 gz: *GenZir,
25322520 scope: *Scope,
25332521 rl: ResultLoc,
25342522 switch_node: ast.Node.Index,
......@@ -2548,7 +2536,7 @@ fn switchExpr(
25482536
25492537 const switch_src = token_starts[switch_token];
25502538
2551 var block_scope: Scope.GenZir = .{
2539 var block_scope: GenZir = .{
25522540 .parent = scope,
25532541 .decl = scope.ownerDecl().?,
25542542 .arena = scope.arena(),
......@@ -2647,13 +2635,13 @@ fn switchExpr(
26472635 // Generate all the switch items as comptime expressions.
26482636 for (case.ast.values) |item| {
26492637 if (getRangeNode(node_tags, node_datas, item)) |range| {
2650 const start = try comptimeExpr(mod, &block_scope.base, .none, node_datas[range].lhs);
2651 const end = try comptimeExpr(mod, &block_scope.base, .none, node_datas[range].rhs);
2638 const start = try comptimeExpr(&block_scope, &block_scope.base, .none, node_datas[range].lhs);
2639 const end = try comptimeExpr(&block_scope, &block_scope.base, .none, node_datas[range].rhs);
26522640 const range_src = token_starts[main_tokens[range]];
26532641 const range_inst = try addZIRBinOp(mod, &block_scope.base, range_src, .switch_range, start, end);
26542642 try items.append(range_inst);
26552643 } else {
2656 const item_inst = try comptimeExpr(mod, &block_scope.base, .none, item);
2644 const item_inst = try comptimeExpr(&block_scope, &block_scope.base, .none, item);
26572645 try items.append(item_inst);
26582646 }
26592647 }
......@@ -2671,7 +2659,7 @@ fn switchExpr(
26712659 .rl = .none,
26722660 .tag = .switchbr,
26732661 };
2674 const target = try expr(mod, &block_scope.base, rl_and_tag.rl, target_node);
2662 const target = try expr(&block_scope, &block_scope.base, rl_and_tag.rl, target_node);
26752663 const switch_inst = try addZirInstT(mod, &block_scope.base, switch_src, zir.Inst.SwitchBr, rl_and_tag.tag, .{
26762664 .target = target,
26772665 .cases = cases,
......@@ -2684,7 +2672,7 @@ fn switchExpr(
26842672 .instructions = try block_scope.arena.dupe(zir.Inst.Ref, block_scope.instructions.items),
26852673 });
26862674
2687 var case_scope: Scope.GenZir = .{
2675 var case_scope: GenZir = .{
26882676 .parent = scope,
26892677 .decl = block_scope.decl,
26902678 .arena = block_scope.arena,
......@@ -2693,7 +2681,7 @@ fn switchExpr(
26932681 };
26942682 defer case_scope.instructions.deinit(mod.gpa);
26952683
2696 var else_scope: Scope.GenZir = .{
2684 var else_scope: GenZir = .{
26972685 .parent = scope,
26982686 .decl = case_scope.decl,
26992687 .arena = case_scope.arena,
......@@ -2819,7 +2807,7 @@ fn switchExpr(
28192807}
28202808
28212809fn switchCaseExpr(
2822 mod: *Module,
2810 gz: *GenZir,
28232811 scope: *Scope,
28242812 rl: ResultLoc,
28252813 block: *zir.Inst.Block,
......@@ -2849,7 +2837,7 @@ fn switchCaseExpr(
28492837 return mod.failTok(scope, ident, "TODO implement switch value payload", .{});
28502838 };
28512839
2852 const case_body = try expr(mod, sub_scope, rl, case.ast.target_expr);
2840 const case_body = try expr(gz, sub_scope, rl, case.ast.target_expr);
28532841 if (!case_body.tag.isNoReturn()) {
28542842 _ = try addZIRInst(mod, sub_scope, case_src, zir.Inst.Break, .{
28552843 .block = block,
......@@ -2858,27 +2846,26 @@ fn switchCaseExpr(
28582846 }
28592847}
28602848
2861fn ret(mod: *Module, scope: *Scope, node: ast.Node.Index) InnerError!zir.Inst.Ref {
2849fn ret(gz: *GenZir, scope: *Scope, node: ast.Node.Index) InnerError!zir.Inst.Ref {
28622850 const tree = scope.tree();
28632851 const node_datas = tree.nodes.items(.data);
28642852 const main_tokens = tree.nodes.items(.main_token);
28652853
28662854 const operand_node = node_datas[node].lhs;
2867 const gz = scope.getGenZir();
28682855 const operand: zir.Inst.Ref = if (operand_node != 0) operand: {
28692856 const rl: ResultLoc = if (nodeMayNeedMemoryLocation(scope, operand_node)) .{
28702857 .ptr = try gz.addNode(.ret_ptr, node),
28712858 } else .{
28722859 .ty = try gz.addNode(.ret_type, node),
28732860 };
2874 break :operand try expr(mod, scope, rl, operand_node);
2861 break :operand try expr(gz, scope, rl, operand_node);
28752862 } else .void_value;
28762863 _ = try gz.addUnNode(.ret_node, operand, node);
28772864 return zir.Inst.Ref.unreachable_value;
28782865}
28792866
28802867fn identifier(
2881 mod: *Module,
2868 gz: *GenZir,
28822869 scope: *Scope,
28832870 rl: ResultLoc,
28842871 ident: ast.Node.Index,
......@@ -2886,11 +2873,10 @@ fn identifier(
28862873 const tracy = trace(@src());
28872874 defer tracy.end();
28882875
2876 const mod = gz.astgen.mod;
28892877 const tree = scope.tree();
28902878 const main_tokens = tree.nodes.items(.main_token);
28912879
2892 const gz = scope.getGenZir();
2893
28942880 const ident_token = main_tokens[ident];
28952881 const ident_name = try mod.identifierTokenString(scope, ident_token);
28962882 if (mem.eql(u8, ident_name, "_")) {
......@@ -2898,7 +2884,7 @@ fn identifier(
28982884 }
28992885
29002886 if (simple_types.get(ident_name)) |zir_const_ref| {
2901 return rvalue(mod, scope, rl, zir_const_ref, ident);
2887 return rvalue(gz, scope, rl, zir_const_ref, ident);
29022888 }
29032889
29042890 if (ident_name.len >= 2) integer: {
......@@ -2925,7 +2911,7 @@ fn identifier(
29252911 .bit_count = bit_count,
29262912 } },
29272913 });
2928 return rvalue(mod, scope, rl, result, ident);
2914 return rvalue(gz, scope, rl, result, ident);
29292915 }
29302916 }
29312917
......@@ -2936,7 +2922,7 @@ fn identifier(
29362922 .local_val => {
29372923 const local_val = s.cast(Scope.LocalVal).?;
29382924 if (mem.eql(u8, local_val.name, ident_name)) {
2939 return rvalue(mod, scope, rl, local_val.inst, ident);
2925 return rvalue(gz, scope, rl, local_val.inst, ident);
29402926 }
29412927 s = local_val.parent;
29422928 },
......@@ -2945,11 +2931,11 @@ fn identifier(
29452931 if (mem.eql(u8, local_ptr.name, ident_name)) {
29462932 if (rl == .ref) return local_ptr.ptr;
29472933 const loaded = try gz.addUnNode(.load, local_ptr.ptr, ident);
2948 return rvalue(mod, scope, rl, loaded, ident);
2934 return rvalue(gz, scope, rl, loaded, ident);
29492935 }
29502936 s = local_ptr.parent;
29512937 },
2952 .gen_zir => s = s.cast(Scope.GenZir).?.parent,
2938 .gen_zir => s = s.cast(GenZir).?.parent,
29532939 else => break,
29542940 };
29552941 }
......@@ -2963,24 +2949,23 @@ fn identifier(
29632949 const decl_index = @intCast(u32, gop.index);
29642950 switch (rl) {
29652951 .ref => return gz.addDecl(.decl_ref, decl_index, ident),
2966 else => return rvalue(mod, scope, rl, try gz.addDecl(.decl_val, decl_index, ident), ident),
2952 else => return rvalue(gz, scope, rl, try gz.addDecl(.decl_val, decl_index, ident), ident),
29672953 }
29682954}
29692955
29702956fn stringLiteral(
2971 mod: *Module,
2957 gz: *GenZir,
29722958 scope: *Scope,
29732959 rl: ResultLoc,
29742960 node: ast.Node.Index,
29752961) InnerError!zir.Inst.Ref {
29762962 const tree = scope.tree();
29772963 const main_tokens = tree.nodes.items(.main_token);
2978 const gz = scope.getGenZir();
29792964 const string_bytes = &gz.astgen.string_bytes;
29802965 const str_index = string_bytes.items.len;
29812966 const str_lit_token = main_tokens[node];
29822967 const token_bytes = tree.tokenSlice(str_lit_token);
2983 try mod.parseStrLit(scope, str_lit_token, string_bytes, token_bytes, 0);
2968 try gz.astgen.mod.parseStrLit(scope, str_lit_token, string_bytes, token_bytes, 0);
29842969 const str_len = string_bytes.items.len - str_index;
29852970 const result = try gz.add(.{
29862971 .tag = .str,
......@@ -2989,22 +2974,23 @@ fn stringLiteral(
29892974 .len = @intCast(u32, str_len),
29902975 } },
29912976 });
2992 return rvalue(mod, scope, rl, result, node);
2977 return rvalue(gz, scope, rl, result, node);
29932978}
29942979
29952980fn multilineStringLiteral(
2996 mod: *Module,
2981 gz: *GenZir,
29972982 scope: *Scope,
29982983 rl: ResultLoc,
29992984 node: ast.Node.Index,
30002985) InnerError!zir.Inst.Ref {
3001 const gz = scope.getGenZir();
30022986 const tree = gz.tree();
30032987 const node_datas = tree.nodes.items(.data);
30042988 const main_tokens = tree.nodes.items(.main_token);
30052989
30062990 const start = node_datas[node].lhs;
30072991 const end = node_datas[node].rhs;
2992
2993 const gpa = gz.astgen.mod.gpa;
30082994 const string_bytes = &gz.astgen.string_bytes;
30092995 const str_index = string_bytes.items.len;
30102996
......@@ -3013,14 +2999,14 @@ fn multilineStringLiteral(
30132999 {
30143000 const slice = tree.tokenSlice(tok_i);
30153001 const line_bytes = slice[2 .. slice.len - 1];
3016 try string_bytes.appendSlice(mod.gpa, line_bytes);
3002 try string_bytes.appendSlice(gpa, line_bytes);
30173003 tok_i += 1;
30183004 }
30193005 // Following lines: each line prepends a newline.
30203006 while (tok_i <= end) : (tok_i += 1) {
30213007 const slice = tree.tokenSlice(tok_i);
30223008 const line_bytes = slice[2 .. slice.len - 1];
3023 try string_bytes.ensureCapacity(mod.gpa, string_bytes.items.len + line_bytes.len + 1);
3009 try string_bytes.ensureCapacity(gpa, string_bytes.items.len + line_bytes.len + 1);
30243010 string_bytes.appendAssumeCapacity('\n');
30253011 string_bytes.appendSliceAssumeCapacity(line_bytes);
30263012 }
......@@ -3031,11 +3017,11 @@ fn multilineStringLiteral(
30313017 .len = @intCast(u32, string_bytes.items.len - str_index),
30323018 } },
30333019 });
3034 return rvalue(mod, scope, rl, result, node);
3020 return rvalue(gz, scope, rl, result, node);
30353021}
30363022
3037fn charLiteral(mod: *Module, scope: *Scope, rl: ResultLoc, node: ast.Node.Index) !zir.Inst.Ref {
3038 const gz = scope.getGenZir();
3023fn charLiteral(gz: *GenZir, scope: *Scope, rl: ResultLoc, node: ast.Node.Index) !zir.Inst.Ref {
3024 const mod = gz.astgen.mod;
30393025 const tree = gz.tree();
30403026 const main_tokens = tree.nodes.items(.main_token);
30413027 const main_token = main_tokens[node];
......@@ -3051,11 +3037,11 @@ fn charLiteral(mod: *Module, scope: *Scope, rl: ResultLoc, node: ast.Node.Index)
30513037 },
30523038 };
30533039 const result = try gz.addInt(value);
3054 return rvalue(mod, scope, rl, result, node);
3040 return rvalue(gz, scope, rl, result, node);
30553041}
30563042
30573043fn integerLiteral(
3058 mod: *Module,
3044 gz: *GenZir,
30593045 scope: *Scope,
30603046 rl: ResultLoc,
30613047 node: ast.Node.Index,
......@@ -3064,21 +3050,20 @@ fn integerLiteral(
30643050 const main_tokens = tree.nodes.items(.main_token);
30653051 const int_token = main_tokens[node];
30663052 const prefixed_bytes = tree.tokenSlice(int_token);
3067 const gz = scope.getGenZir();
30683053 if (std.fmt.parseInt(u64, prefixed_bytes, 0)) |small_int| {
30693054 const result: zir.Inst.Ref = switch (small_int) {
30703055 0 => .zero,
30713056 1 => .one,
30723057 else => try gz.addInt(small_int),
30733058 };
3074 return rvalue(mod, scope, rl, result, node);
3059 return rvalue(gz, scope, rl, result, node);
30753060 } else |err| {
3076 return mod.failNode(scope, node, "TODO implement int literals that don't fit in a u64", .{});
3061 return gz.astgen.mod.failNode(scope, node, "TODO implement int literals that don't fit in a u64", .{});
30773062 }
30783063}
30793064
30803065fn floatLiteral(
3081 mod: *Module,
3066 gz: *GenZir,
30823067 scope: *Scope,
30833068 rl: ResultLoc,
30843069 node: ast.Node.Index,
......@@ -3086,13 +3071,12 @@ fn floatLiteral(
30863071 const arena = scope.arena();
30873072 const tree = scope.tree();
30883073 const main_tokens = tree.nodes.items(.main_token);
3089 const gz = scope.getGenZir();
30903074
30913075 const main_token = main_tokens[node];
30923076 const bytes = tree.tokenSlice(main_token);
30933077 if (bytes.len > 2 and bytes[1] == 'x') {
30943078 assert(bytes[0] == '0'); // validated by tokenizer
3095 return mod.failTok(scope, main_token, "TODO implement hex floats", .{});
3079 return gz.astgen.mod.failTok(scope, main_token, "TODO implement hex floats", .{});
30963080 }
30973081 const float_number = std.fmt.parseFloat(f128, bytes) catch |e| switch (e) {
30983082 error.InvalidCharacter => unreachable, // validated by tokenizer
......@@ -3106,23 +3090,23 @@ fn floatLiteral(
31063090 .tag = .@"const",
31073091 .data = .{ .@"const" = typed_value },
31083092 });
3109 return rvalue(mod, scope, rl, result, node);
3093 return rvalue(gz, scope, rl, result, node);
31103094}
31113095
31123096fn asmExpr(
3113 mod: *Module,
3097 gz: *GenZir,
31143098 scope: *Scope,
31153099 rl: ResultLoc,
31163100 node: ast.Node.Index,
31173101 full: ast.full.Asm,
31183102) InnerError!zir.Inst.Ref {
3103 const mod = gz.astgen.mod;
31193104 const arena = scope.arena();
31203105 const tree = scope.tree();
31213106 const main_tokens = tree.nodes.items(.main_token);
31223107 const node_datas = tree.nodes.items(.data);
3123 const gz = scope.getGenZir();
31243108
3125 const asm_source = try expr(mod, scope, .{ .ty = .const_slice_u8_type }, full.ast.template);
3109 const asm_source = try expr(gz, scope, .{ .ty = .const_slice_u8_type }, full.ast.template);
31263110
31273111 if (full.outputs.len != 0) {
31283112 return mod.failTok(scope, full.ast.asm_token, "TODO implement asm with an output", .{});
......@@ -3139,7 +3123,7 @@ fn asmExpr(
31393123 try mod.parseStrLit(scope, constraint_token, string_bytes, token_bytes, 0);
31403124 try string_bytes.append(mod.gpa, 0);
31413125
3142 args[i] = try expr(mod, scope, .{ .ty = .usize_type }, node_datas[input].lhs);
3126 args[i] = try expr(gz, scope, .{ .ty = .usize_type }, node_datas[input].lhs);
31433127 }
31443128
31453129 const tag: zir.Inst.Tag = if (full.volatile_token != null) .asm_volatile else .@"asm";
......@@ -3156,11 +3140,11 @@ fn asmExpr(
31563140 gz.astgen.appendRefsAssumeCapacity(args);
31573141 gz.astgen.extra.appendSliceAssumeCapacity(constraints);
31583142
3159 return rvalue(mod, scope, rl, result, node);
3143 return rvalue(gz, scope, rl, result, node);
31603144}
31613145
31623146fn as(
3163 mod: *Module,
3147 gz: *GenZir,
31643148 scope: *Scope,
31653149 rl: ResultLoc,
31663150 builtin_token: ast.TokenIndex,
......@@ -3168,33 +3152,33 @@ fn as(
31683152 lhs: ast.Node.Index,
31693153 rhs: ast.Node.Index,
31703154) InnerError!zir.Inst.Ref {
3171 const dest_type = try typeExpr(mod, scope, lhs);
3155 const dest_type = try typeExpr(gz, scope, lhs);
31723156 switch (rl) {
31733157 .none, .discard, .ref, .ty => {
3174 const result = try expr(mod, scope, .{ .ty = dest_type }, rhs);
3175 return rvalue(mod, scope, rl, result, node);
3158 const result = try expr(gz, scope, .{ .ty = dest_type }, rhs);
3159 return rvalue(gz, scope, rl, result, node);
31763160 },
31773161
31783162 .ptr => |result_ptr| {
3179 return asRlPtr(mod, scope, rl, result_ptr, rhs, dest_type);
3163 return asRlPtr(gz, scope, rl, result_ptr, rhs, dest_type);
31803164 },
31813165 .block_ptr => |block_scope| {
3182 return asRlPtr(mod, scope, rl, block_scope.rl_ptr, rhs, dest_type);
3166 return asRlPtr(gz, scope, rl, block_scope.rl_ptr, rhs, dest_type);
31833167 },
31843168
31853169 .bitcasted_ptr => |bitcasted_ptr| {
31863170 // TODO here we should be able to resolve the inference; we now have a type for the result.
3187 return mod.failTok(scope, builtin_token, "TODO implement @as with result location @bitCast", .{});
3171 return gz.astgen.mod.failTok(scope, builtin_token, "TODO implement @as with result location @bitCast", .{});
31883172 },
31893173 .inferred_ptr => |result_alloc| {
31903174 // TODO here we should be able to resolve the inference; we now have a type for the result.
3191 return mod.failTok(scope, builtin_token, "TODO implement @as with inferred-type result location pointer", .{});
3175 return gz.astgen.mod.failTok(scope, builtin_token, "TODO implement @as with inferred-type result location pointer", .{});
31923176 },
31933177 }
31943178}
31953179
31963180fn asRlPtr(
3197 mod: *Module,
3181 parent_gz: *GenZir,
31983182 scope: *Scope,
31993183 rl: ResultLoc,
32003184 result_ptr: zir.Inst.Ref,
......@@ -3204,26 +3188,25 @@ fn asRlPtr(
32043188 // Detect whether this expr() call goes into rvalue() to store the result into the
32053189 // result location. If it does, elide the coerce_result_ptr instruction
32063190 // as well as the store instruction, instead passing the result as an rvalue.
3207 const parent_gz = scope.getGenZir();
32083191 const astgen = parent_gz.astgen;
32093192
3210 var as_scope: Scope.GenZir = .{
3193 var as_scope: GenZir = .{
32113194 .parent = scope,
32123195 .astgen = astgen,
32133196 .force_comptime = parent_gz.force_comptime,
32143197 .instructions = .{},
32153198 };
3216 defer as_scope.instructions.deinit(mod.gpa);
3199 defer as_scope.instructions.deinit(astgen.mod.gpa);
32173200
32183201 as_scope.rl_ptr = try as_scope.addBin(.coerce_result_ptr, dest_type, result_ptr);
3219 const result = try expr(mod, &as_scope.base, .{ .block_ptr = &as_scope }, operand_node);
3202 const result = try expr(&as_scope, &as_scope.base, .{ .block_ptr = &as_scope }, operand_node);
32203203 const parent_zir = &parent_gz.instructions;
32213204 if (as_scope.rvalue_rl_count == 1) {
32223205 // Busted! This expression didn't actually need a pointer.
32233206 const zir_tags = astgen.instructions.items(.tag);
32243207 const zir_datas = astgen.instructions.items(.data);
32253208 const expected_len = parent_zir.items.len + as_scope.instructions.items.len - 2;
3226 try parent_zir.ensureCapacity(mod.gpa, expected_len);
3209 try parent_zir.ensureCapacity(astgen.mod.gpa, expected_len);
32273210 for (as_scope.instructions.items) |src_inst| {
32283211 if (astgen.indexToRef(src_inst) == as_scope.rl_ptr) continue;
32293212 if (zir_tags[src_inst] == .store_to_block_ptr) {
......@@ -3233,15 +3216,15 @@ fn asRlPtr(
32333216 }
32343217 assert(parent_zir.items.len == expected_len);
32353218 const casted_result = try parent_gz.addBin(.as, dest_type, result);
3236 return rvalue(mod, scope, rl, casted_result, operand_node);
3219 return rvalue(parent_gz, scope, rl, casted_result, operand_node);
32373220 } else {
3238 try parent_zir.appendSlice(mod.gpa, as_scope.instructions.items);
3221 try parent_zir.appendSlice(astgen.mod.gpa, as_scope.instructions.items);
32393222 return result;
32403223 }
32413224}
32423225
32433226fn bitCast(
3244 mod: *Module,
3227 gz: *GenZir,
32453228 scope: *Scope,
32463229 rl: ResultLoc,
32473230 builtin_token: ast.TokenIndex,
......@@ -3250,31 +3233,31 @@ fn bitCast(
32503233 rhs: ast.Node.Index,
32513234) InnerError!zir.Inst.Ref {
32523235 if (true) @panic("TODO update for zir-memory-layout");
3253 const dest_type = try typeExpr(mod, scope, lhs);
3236 const dest_type = try typeExpr(gz, scope, lhs);
32543237 switch (rl) {
32553238 .none => {
3256 const operand = try expr(mod, scope, .none, rhs);
3239 const operand = try expr(gz, scope, .none, rhs);
32573240 return addZIRBinOp(mod, scope, src, .bitcast, dest_type, operand);
32583241 },
32593242 .discard => {
3260 const operand = try expr(mod, scope, .none, rhs);
3243 const operand = try expr(gz, scope, .none, rhs);
32613244 const result = try addZIRBinOp(mod, scope, src, .bitcast, dest_type, operand);
32623245 _ = try addZIRUnOp(mod, scope, result.src, .ensure_result_non_error, result);
32633246 return result;
32643247 },
32653248 .ref => {
3266 const operand = try expr(mod, scope, .ref, rhs);
3249 const operand = try expr(gz, scope, .ref, rhs);
32673250 const result = try addZIRBinOp(mod, scope, src, .bitcast_ref, dest_type, operand);
32683251 return result;
32693252 },
32703253 .ty => |result_ty| {
3271 const result = try expr(mod, scope, .none, rhs);
3254 const result = try expr(gz, scope, .none, rhs);
32723255 const bitcasted = try addZIRBinOp(mod, scope, src, .bitcast, dest_type, result);
32733256 return addZIRBinOp(mod, scope, src, .as, result_ty, bitcasted);
32743257 },
32753258 .ptr => |result_ptr| {
32763259 const casted_result_ptr = try addZIRUnOp(mod, scope, src, .bitcast_result_ptr, result_ptr);
3277 return expr(mod, scope, .{ .bitcasted_ptr = casted_result_ptr.castTag(.bitcast_result_ptr).? }, rhs);
3260 return expr(gz, scope, .{ .bitcasted_ptr = casted_result_ptr.castTag(.bitcast_result_ptr).? }, rhs);
32783261 },
32793262 .bitcasted_ptr => |bitcasted_ptr| {
32803263 return mod.failTok(scope, builtin_token, "TODO implement @bitCast with result location another @bitCast", .{});
......@@ -3290,7 +3273,7 @@ fn bitCast(
32903273}
32913274
32923275fn typeOf(
3293 mod: *Module,
3276 gz: *GenZir,
32943277 scope: *Scope,
32953278 rl: ResultLoc,
32963279 builtin_token: ast.TokenIndex,
......@@ -3298,22 +3281,16 @@ fn typeOf(
32983281 params: []const ast.Node.Index,
32993282) InnerError!zir.Inst.Ref {
33003283 if (params.len < 1) {
3301 return mod.failTok(scope, builtin_token, "expected at least 1 argument, found 0", .{});
3284 return gz.astgen.mod.failTok(scope, builtin_token, "expected at least 1 argument, found 0", .{});
33023285 }
3303 const gz = scope.getGenZir();
33043286 if (params.len == 1) {
3305 return rvalue(
3306 mod,
3307 scope,
3308 rl,
3309 try gz.addUnTok(.typeof, try expr(mod, scope, .none, params[0]), node),
3310 node,
3311 );
3287 const result = try gz.addUnTok(.typeof, try expr(gz, scope, .none, params[0]), node);
3288 return rvalue(gz, scope, rl, result, node);
33123289 }
33133290 const arena = scope.arena();
33143291 var items = try arena.alloc(zir.Inst.Ref, params.len);
33153292 for (params) |param, param_i| {
3316 items[param_i] = try expr(mod, scope, .none, param);
3293 items[param_i] = try expr(gz, scope, .none, param);
33173294 }
33183295
33193296 const result = try gz.addPlNode(.typeof_peer, node, zir.Inst.MultiOp{
......@@ -3321,16 +3298,17 @@ fn typeOf(
33213298 });
33223299 try gz.astgen.appendRefs(items);
33233300
3324 return rvalue(mod, scope, rl, result, node);
3301 return rvalue(gz, scope, rl, result, node);
33253302}
33263303
33273304fn builtinCall(
3328 mod: *Module,
3305 gz: *GenZir,
33293306 scope: *Scope,
33303307 rl: ResultLoc,
33313308 node: ast.Node.Index,
33323309 params: []const ast.Node.Index,
33333310) InnerError!zir.Inst.Ref {
3311 const mod = gz.astgen.mod;
33343312 const tree = scope.tree();
33353313 const main_tokens = tree.nodes.items(.main_token);
33363314
......@@ -3356,83 +3334,81 @@ fn builtinCall(
33563334 }
33573335 }
33583336
3359 const gz = scope.getGenZir();
3360
33613337 switch (info.tag) {
33623338 .ptr_to_int => {
3363 const operand = try expr(mod, scope, .none, params[0]);
3339 const operand = try expr(gz, scope, .none, params[0]);
33643340 const result = try gz.addUnNode(.ptrtoint, operand, node);
3365 return rvalue(mod, scope, rl, result, node);
3341 return rvalue(gz, scope, rl, result, node);
33663342 },
33673343 .float_cast => {
3368 const dest_type = try typeExpr(mod, scope, params[0]);
3369 const rhs = try expr(mod, scope, .none, params[1]);
3344 const dest_type = try typeExpr(gz, scope, params[0]);
3345 const rhs = try expr(gz, scope, .none, params[1]);
33703346 const result = try gz.addPlNode(.floatcast, node, zir.Inst.Bin{
33713347 .lhs = dest_type,
33723348 .rhs = rhs,
33733349 });
3374 return rvalue(mod, scope, rl, result, node);
3350 return rvalue(gz, scope, rl, result, node);
33753351 },
33763352 .int_cast => {
3377 const dest_type = try typeExpr(mod, scope, params[0]);
3378 const rhs = try expr(mod, scope, .none, params[1]);
3353 const dest_type = try typeExpr(gz, scope, params[0]);
3354 const rhs = try expr(gz, scope, .none, params[1]);
33793355 const result = try gz.addPlNode(.intcast, node, zir.Inst.Bin{
33803356 .lhs = dest_type,
33813357 .rhs = rhs,
33823358 });
3383 return rvalue(mod, scope, rl, result, node);
3359 return rvalue(gz, scope, rl, result, node);
33843360 },
33853361 .breakpoint => {
33863362 const result = try gz.add(.{
33873363 .tag = .breakpoint,
33883364 .data = .{ .node = gz.astgen.decl.nodeIndexToRelative(node) },
33893365 });
3390 return rvalue(mod, scope, rl, result, node);
3366 return rvalue(gz, scope, rl, result, node);
33913367 },
33923368 .import => {
3393 const target = try expr(mod, scope, .none, params[0]);
3369 const target = try expr(gz, scope, .none, params[0]);
33943370 const result = try gz.addUnNode(.import, target, node);
3395 return rvalue(mod, scope, rl, result, node);
3371 return rvalue(gz, scope, rl, result, node);
33963372 },
33973373 .compile_error => {
3398 const target = try expr(mod, scope, .none, params[0]);
3374 const target = try expr(gz, scope, .none, params[0]);
33993375 const result = try gz.addUnNode(.compile_error, target, node);
3400 return rvalue(mod, scope, rl, result, node);
3376 return rvalue(gz, scope, rl, result, node);
34013377 },
34023378 .set_eval_branch_quota => {
3403 const quota = try expr(mod, scope, .{ .ty = .u32_type }, params[0]);
3379 const quota = try expr(gz, scope, .{ .ty = .u32_type }, params[0]);
34043380 const result = try gz.addUnNode(.set_eval_branch_quota, quota, node);
3405 return rvalue(mod, scope, rl, result, node);
3381 return rvalue(gz, scope, rl, result, node);
34063382 },
34073383 .compile_log => {
34083384 const arg_refs = try mod.gpa.alloc(zir.Inst.Ref, params.len);
34093385 defer mod.gpa.free(arg_refs);
34103386
3411 for (params) |param, i| arg_refs[i] = try expr(mod, scope, .none, param);
3387 for (params) |param, i| arg_refs[i] = try expr(gz, scope, .none, param);
34123388
34133389 const result = try gz.addPlNode(.compile_log, node, zir.Inst.MultiOp{
34143390 .operands_len = @intCast(u32, params.len),
34153391 });
34163392 try gz.astgen.appendRefs(arg_refs);
3417 return rvalue(mod, scope, rl, result, node);
3393 return rvalue(gz, scope, rl, result, node);
34183394 },
34193395 .field => {
3420 const field_name = try comptimeExpr(mod, scope, .{ .ty = .const_slice_u8_type }, params[1]);
3396 const field_name = try comptimeExpr(gz, scope, .{ .ty = .const_slice_u8_type }, params[1]);
34213397 if (rl == .ref) {
34223398 return try gz.addPlNode(.field_ptr_named, node, zir.Inst.FieldNamed{
3423 .lhs = try expr(mod, scope, .ref, params[0]),
3399 .lhs = try expr(gz, scope, .ref, params[0]),
34243400 .field_name = field_name,
34253401 });
34263402 }
34273403 const result = try gz.addPlNode(.field_val_named, node, zir.Inst.FieldNamed{
3428 .lhs = try expr(mod, scope, .none, params[0]),
3404 .lhs = try expr(gz, scope, .none, params[0]),
34293405 .field_name = field_name,
34303406 });
3431 return rvalue(mod, scope, rl, result, node);
3407 return rvalue(gz, scope, rl, result, node);
34323408 },
3433 .as => return as(mod, scope, rl, builtin_token, node, params[0], params[1]),
3434 .bit_cast => return bitCast(mod, scope, rl, builtin_token, node, params[0], params[1]),
3435 .TypeOf => return typeOf(mod, scope, rl, builtin_token, node, params),
3409 .as => return as(gz, scope, rl, builtin_token, node, params[0], params[1]),
3410 .bit_cast => return bitCast(gz, scope, rl, builtin_token, node, params[0], params[1]),
3411 .TypeOf => return typeOf(gz, scope, rl, builtin_token, node, params),
34363412
34373413 .add_with_overflow,
34383414 .align_cast,
......@@ -3533,21 +3509,21 @@ fn builtinCall(
35333509}
35343510
35353511fn callExpr(
3536 mod: *Module,
3512 gz: *GenZir,
35373513 scope: *Scope,
35383514 rl: ResultLoc,
35393515 node: ast.Node.Index,
35403516 call: ast.full.Call,
35413517) InnerError!zir.Inst.Ref {
3518 const mod = gz.astgen.mod;
35423519 if (call.async_token) |async_token| {
35433520 return mod.failTok(scope, async_token, "async and related features are not yet supported", .{});
35443521 }
3545 const lhs = try expr(mod, scope, .none, call.ast.fn_expr);
3522 const lhs = try expr(gz, scope, .none, call.ast.fn_expr);
35463523
35473524 const args = try mod.gpa.alloc(zir.Inst.Ref, call.ast.params.len);
35483525 defer mod.gpa.free(args);
35493526
3550 const gz = scope.getGenZir();
35513527 for (call.ast.params) |param_node, i| {
35523528 const param_type = try gz.add(.{
35533529 .tag = .param_type,
......@@ -3556,7 +3532,7 @@ fn callExpr(
35563532 .param_index = @intCast(u32, i),
35573533 } },
35583534 });
3559 args[i] = try expr(mod, scope, .{ .ty = param_type }, param_node);
3535 args[i] = try expr(gz, scope, .{ .ty = param_type }, param_node);
35603536 }
35613537
35623538 const modifier: std.builtin.CallOptions.Modifier = switch (call.async_token != null) {
......@@ -3579,7 +3555,7 @@ fn callExpr(
35793555 };
35803556 break :res try gz.addCall(tag, lhs, args, node);
35813557 };
3582 return rvalue(mod, scope, rl, result, node); // TODO function call with result location
3558 return rvalue(gz, scope, rl, result, node); // TODO function call with result location
35833559}
35843560
35853561pub const simple_types = std.ComptimeStringMap(zir.Inst.Ref, .{
......@@ -3841,13 +3817,12 @@ fn nodeMayNeedMemoryLocation(scope: *Scope, start_node: ast.Node.Index) bool {
38413817/// As an example, if the `ResultLoc` is `ptr`, it will write the result to the pointer.
38423818/// If the `ResultLoc` is `ty`, it will coerce the result to the type.
38433819fn rvalue(
3844 mod: *Module,
3820 gz: *GenZir,
38453821 scope: *Scope,
38463822 rl: ResultLoc,
38473823 result: zir.Inst.Ref,
38483824 src_node: ast.Node.Index,
38493825) InnerError!zir.Inst.Ref {
3850 const gz = scope.getGenZir();
38513826 switch (rl) {
38523827 .none => return result,
38533828 .discard => {
......@@ -3933,7 +3908,7 @@ fn rvalue(
39333908 return result;
39343909 },
39353910 .bitcasted_ptr => |bitcasted_ptr| {
3936 return mod.failNode(scope, src_node, "TODO implement rvalue .bitcasted_ptr", .{});
3911 return gz.astgen.mod.failNode(scope, src_node, "TODO implement rvalue .bitcasted_ptr", .{});
39373912 },
39383913 .inferred_ptr => |alloc| {
39393914 _ = try gz.addBin(.store_to_inferred_ptr, alloc, result);
src/Module.zig+8-8
......@@ -2054,7 +2054,7 @@ fn astgenAndSemaDecl(mod: *Module, decl: *Decl) !bool {
20542054 defer gen_scope.instructions.deinit(mod.gpa);
20552055
20562056 const block_expr = node_datas[decl_node].lhs;
2057 _ = try AstGen.comptimeExpr(mod, &gen_scope.base, .none, block_expr);
2057 _ = try AstGen.comptimeExpr(&gen_scope, &gen_scope.base, .none, block_expr);
20582058
20592059 const code = try gen_scope.finish();
20602060 if (std.builtin.mode == .Debug and mod.comp.verbose_ir) {
......@@ -2164,7 +2164,7 @@ fn astgenAndSemaFn(
21642164 const param_type_node = param.type_expr;
21652165 assert(param_type_node != 0);
21662166 param_types[param_type_i] =
2167 try AstGen.expr(mod, &fn_type_scope.base, .{ .ty = .type_type }, param_type_node);
2167 try AstGen.expr(&fn_type_scope, &fn_type_scope.base, .{ .ty = .type_type }, param_type_node);
21682168 }
21692169 assert(param_type_i == param_count);
21702170 }
......@@ -2234,7 +2234,7 @@ fn astgenAndSemaFn(
22342234 return mod.failTok(&fn_type_scope.base, maybe_bang, "TODO implement inferred error sets", .{});
22352235 }
22362236 const return_type_inst = try AstGen.expr(
2237 mod,
2237 &fn_type_scope,
22382238 &fn_type_scope.base,
22392239 .{ .ty = .type_type },
22402240 fn_proto.ast.return_type,
......@@ -2250,7 +2250,7 @@ fn astgenAndSemaFn(
22502250 // std.builtin.CallingConvention enum. We need to implement importing other files
22512251 // and enums in order to fix this.
22522252 try AstGen.comptimeExpr(
2253 mod,
2253 &fn_type_scope,
22542254 &fn_type_scope.base,
22552255 .{ .ty = .enum_literal_type },
22562256 fn_proto.ast.callconv_expr,
......@@ -2392,7 +2392,7 @@ fn astgenAndSemaFn(
23922392 astgen.string_bytes.appendAssumeCapacity(0);
23932393 }
23942394
2395 _ = try AstGen.expr(mod, params_scope, .none, body_node);
2395 _ = try AstGen.expr(&gen_scope, params_scope, .none, body_node);
23962396
23972397 if (gen_scope.instructions.items.len == 0 or
23982398 !astgen.instructions.items(.tag)[gen_scope.instructions.items.len - 1]
......@@ -2567,11 +2567,11 @@ fn astgenAndSemaVarDecl(
25672567 defer gen_scope.instructions.deinit(mod.gpa);
25682568
25692569 const init_result_loc: AstGen.ResultLoc = if (var_decl.ast.type_node != 0) .{
2570 .ty = try AstGen.expr(mod, &gen_scope.base, .{ .ty = .type_type }, var_decl.ast.type_node),
2570 .ty = try AstGen.expr(&gen_scope, &gen_scope.base, .{ .ty = .type_type }, var_decl.ast.type_node),
25712571 } else .none;
25722572
25732573 const init_inst = try AstGen.comptimeExpr(
2574 mod,
2574 &gen_scope,
25752575 &gen_scope.base,
25762576 init_result_loc,
25772577 var_decl.ast.init_node,
......@@ -2635,7 +2635,7 @@ fn astgenAndSemaVarDecl(
26352635 };
26362636 defer type_scope.instructions.deinit(mod.gpa);
26372637
2638 const var_type = try AstGen.typeExpr(mod, &type_scope.base, var_decl.ast.type_node);
2638 const var_type = try AstGen.typeExpr(&type_scope, &type_scope.base, var_decl.ast.type_node);
26392639 _ = try type_scope.addBreak(.break_inline, 0, var_type);
26402640
26412641 var code = try type_scope.finish();