authorgravatar for topolarity@tapscott.meCody Tapscott <topolarity@tapscott.me> 2022-09-14 17:38:08-07:00
committergravatar for topolarity@tapscott.meCody Tapscott <topolarity@tapscott.me> 2022-10-21 11:22:46-07:00
log77720e30aaead1c814f2714bd5a7ad7ad0fbc23e
tree70ab61b6e3a86770290565d4efe132d6ec31b67f
parent724d75363855176aa5e6b3d9bcd1656e2cc1f6a6

Re-factor: Change AstGen.ResultLoc to be a struct

This re-factor is intended to make it easier to track what kind of operator/expression consumes a result location, without overloading the ResultLoc union for this purpose. This is used in the following commit to keep track of initializer expressions of `const` variables to avoid popping error traces pre-maturely. Hopefully this will also be useful for implementing RLS temporaries in the future.

2 files changed, 866 insertions(+), 856 deletions(-)

src/AstGen.zig+865-856
......@@ -213,127 +213,145 @@ pub fn deinit(astgen: *AstGen, gpa: Allocator) void {
213213 astgen.ref_table.deinit(gpa);
214214}
215215
216pub const ResultLoc = union(enum) {
217 /// The expression is the right-hand side of assignment to `_`. Only the side-effects of the
218 /// expression should be generated. The result instruction from the expression must
219 /// be ignored.
220 discard,
221 /// The expression has an inferred type, and it will be evaluated as an rvalue.
222 none,
223 /// The expression must generate a pointer rather than a value. For example, the left hand side
224 /// of an assignment uses this kind of result location.
225 ref,
226 /// Exactly like `none`, except also indicates this is an error-handling expr (try/catch/return etc.)
227 catch_none,
228 /// Exactly like `ref`, except also indicates this is an error-handling expr (try/catch/return etc.)
229 catch_ref,
230 /// The expression will be coerced into this type, but it will be evaluated as an rvalue.
231 ty: Zir.Inst.Ref,
232 /// Same as `ty` but for shift operands.
233 ty_shift_operand: Zir.Inst.Ref,
234 /// Same as `ty` but it is guaranteed that Sema will additionally perform the coercion,
235 /// so no `as` instruction needs to be emitted.
236 coerced_ty: Zir.Inst.Ref,
237 /// The expression must store its result into this typed pointer. The result instruction
238 /// from the expression must be ignored.
239 ptr: PtrResultLoc,
240 /// The expression must store its result into this allocation, which has an inferred type.
241 /// The result instruction from the expression must be ignored.
242 /// Always an instruction with tag `alloc_inferred`.
243 inferred_ptr: Zir.Inst.Ref,
244 /// There is a pointer for the expression to store its result into, however, its type
245 /// is inferred based on peer type resolution for a `Zir.Inst.Block`.
246 /// The result instruction from the expression must be ignored.
247 block_ptr: *GenZir,
248
249 const PtrResultLoc = struct {
250 inst: Zir.Inst.Ref,
251 src_node: ?Ast.Node.Index = null,
252 };
216pub const ResultInfo = struct {
217 /// The semantics requested for the result location
218 rl: Loc,
253219
254 pub const Strategy = struct {
255 elide_store_to_block_ptr_instructions: bool,
256 tag: Tag,
257
258 pub const Tag = enum {
259 /// Both branches will use break_void; result location is used to communicate the
260 /// result instruction.
261 break_void,
262 /// Use break statements to pass the block result value, and call rvalue() at
263 /// the end depending on rl. Also elide the store_to_block_ptr instructions
264 /// depending on rl.
265 break_operand,
266 };
267 };
220 /// The "operator" consuming the result location
221 ctx: Context = .none,
268222
269 fn strategy(rl: ResultLoc, block_scope: *GenZir) Strategy {
270 switch (rl) {
271 // In this branch there will not be any store_to_block_ptr instructions.
272 .none, .catch_none, .ty, .ty_shift_operand, .coerced_ty, .ref, .catch_ref => return .{
273 .tag = .break_operand,
274 .elide_store_to_block_ptr_instructions = false,
275 },
276 .discard => return .{
277 .tag = .break_void,
278 .elide_store_to_block_ptr_instructions = false,
279 },
280 // The pointer got passed through to the sub-expressions, so we will use
281 // break_void here.
282 // In this branch there will not be any store_to_block_ptr instructions.
283 .ptr => return .{
284 .tag = .break_void,
285 .elide_store_to_block_ptr_instructions = false,
223 /// Turns a `coerced_ty` back into a `ty`. Should be called at branch points
224 /// such as if and switch expressions.
225 fn br(ri: ResultInfo) ResultInfo {
226 return switch (ri.rl) {
227 .coerced_ty => |ty| .{
228 .rl = .{ .ty = ty },
229 .ctx = ri.ctx,
286230 },
287 .inferred_ptr, .block_ptr => {
288 if (block_scope.rvalue_rl_count == block_scope.break_count) {
289 // Neither prong of the if consumed the result location, so we can
290 // use break instructions to create an rvalue.
291 return .{
292 .tag = .break_operand,
293 .elide_store_to_block_ptr_instructions = true,
294 };
295 } else {
296 // Allow the store_to_block_ptr instructions to remain so that
297 // semantic analysis can turn them into bitcasts.
298 return .{
299 .tag = .break_void,
300 .elide_store_to_block_ptr_instructions = false,
301 };
302 }
231 else => ri,
232 };
233 }
234
235 fn zirTag(ri: ResultInfo) Zir.Inst.Tag {
236 switch (ri.rl) {
237 .ty => return switch (ri.ctx) {
238 .shift_op => .as_shift_operand,
239 else => .as_node,
303240 },
241 else => unreachable,
304242 }
305243 }
306244
307 /// Turns a `coerced_ty` back into a `ty`. Should be called at branch points
308 /// such as if and switch expressions.
309 fn br(rl: ResultLoc) ResultLoc {
310 return switch (rl) {
311 .coerced_ty => |ty| .{ .ty = ty },
312 else => rl,
245 pub const Loc = union(enum) {
246 /// The expression is the right-hand side of assignment to `_`. Only the side-effects of the
247 /// expression should be generated. The result instruction from the expression must
248 /// be ignored.
249 discard,
250 /// The expression has an inferred type, and it will be evaluated as an rvalue.
251 none,
252 /// The expression must generate a pointer rather than a value. For example, the left hand side
253 /// of an assignment uses this kind of result location.
254 ref,
255 /// The expression will be coerced into this type, but it will be evaluated as an rvalue.
256 ty: Zir.Inst.Ref,
257 /// Same as `ty` but it is guaranteed that Sema will additionally perform the coercion,
258 /// so no `as` instruction needs to be emitted.
259 coerced_ty: Zir.Inst.Ref,
260 /// The expression must store its result into this typed pointer. The result instruction
261 /// from the expression must be ignored.
262 ptr: PtrResultLoc,
263 /// The expression must store its result into this allocation, which has an inferred type.
264 /// The result instruction from the expression must be ignored.
265 /// Always an instruction with tag `alloc_inferred`.
266 inferred_ptr: Zir.Inst.Ref,
267 /// There is a pointer for the expression to store its result into, however, its type
268 /// is inferred based on peer type resolution for a `Zir.Inst.Block`.
269 /// The result instruction from the expression must be ignored.
270 block_ptr: *GenZir,
271
272 const PtrResultLoc = struct {
273 inst: Zir.Inst.Ref,
274 src_node: ?Ast.Node.Index = null,
313275 };
314 }
315276
316 fn zirTag(rl: ResultLoc) Zir.Inst.Tag {
317 return switch (rl) {
318 .ty => .as_node,
319 .ty_shift_operand => .as_shift_operand,
320 else => unreachable,
277 pub const Strategy = struct {
278 elide_store_to_block_ptr_instructions: bool,
279 tag: Tag,
280
281 pub const Tag = enum {
282 /// Both branches will use break_void; result location is used to communicate the
283 /// result instruction.
284 break_void,
285 /// Use break statements to pass the block result value, and call rvalue() at
286 /// the end depending on rl. Also elide the store_to_block_ptr instructions
287 /// depending on rl.
288 break_operand,
289 };
321290 };
322 }
291
292 fn strategy(rl: Loc, block_scope: *GenZir) Strategy {
293 switch (rl) {
294 // In this branch there will not be any store_to_block_ptr instructions.
295 .none, .ty, .coerced_ty, .ref => return .{
296 .tag = .break_operand,
297 .elide_store_to_block_ptr_instructions = false,
298 },
299 .discard => return .{
300 .tag = .break_void,
301 .elide_store_to_block_ptr_instructions = false,
302 },
303 // The pointer got passed through to the sub-expressions, so we will use
304 // break_void here.
305 // In this branch there will not be any store_to_block_ptr instructions.
306 .ptr => return .{
307 .tag = .break_void,
308 .elide_store_to_block_ptr_instructions = false,
309 },
310 .inferred_ptr, .block_ptr => {
311 if (block_scope.rvalue_rl_count == block_scope.break_count) {
312 // Neither prong of the if consumed the result location, so we can
313 // use break instructions to create an rvalue.
314 return .{
315 .tag = .break_operand,
316 .elide_store_to_block_ptr_instructions = true,
317 };
318 } else {
319 // Allow the store_to_block_ptr instructions to remain so that
320 // semantic analysis can turn them into bitcasts.
321 return .{
322 .tag = .break_void,
323 .elide_store_to_block_ptr_instructions = false,
324 };
325 }
326 },
327 }
328 }
329 };
330
331 pub const Context = enum {
332 /// The expression is the operand to a return expression.
333 @"return",
334 /// The expression is the input to an error-handling operator (if-else, try, or catch).
335 error_handling_expr,
336 /// The expression is the right-hand side of a shift operation.
337 shift_op,
338 /// No specific operator in particular.
339 none,
340 };
323341};
324342
325pub const align_rl: ResultLoc = .{ .ty = .u29_type };
326pub const coerced_align_rl: ResultLoc = .{ .coerced_ty = .u29_type };
327pub const bool_rl: ResultLoc = .{ .ty = .bool_type };
328pub const type_rl: ResultLoc = .{ .ty = .type_type };
329pub const coerced_type_rl: ResultLoc = .{ .coerced_ty = .type_type };
343pub const align_ri: ResultInfo = .{ .rl = .{ .ty = .u29_type } };
344pub const coerced_align_ri: ResultInfo = .{ .rl = .{ .coerced_ty = .u29_type } };
345pub const bool_ri: ResultInfo = .{ .rl = .{ .ty = .bool_type } };
346pub const type_ri: ResultInfo = .{ .rl = .{ .ty = .type_type } };
347pub const coerced_type_ri: ResultInfo = .{ .rl = .{ .coerced_ty = .type_type } };
330348
331349fn typeExpr(gz: *GenZir, scope: *Scope, type_node: Ast.Node.Index) InnerError!Zir.Inst.Ref {
332350 const prev_force_comptime = gz.force_comptime;
333351 gz.force_comptime = true;
334352 defer gz.force_comptime = prev_force_comptime;
335353
336 return expr(gz, scope, coerced_type_rl, type_node);
354 return expr(gz, scope, coerced_type_ri, type_node);
337355}
338356
339357fn reachableTypeExpr(
......@@ -346,24 +364,24 @@ fn reachableTypeExpr(
346364 gz.force_comptime = true;
347365 defer gz.force_comptime = prev_force_comptime;
348366
349 return reachableExpr(gz, scope, coerced_type_rl, type_node, reachable_node);
367 return reachableExpr(gz, scope, coerced_type_ri, type_node, reachable_node);
350368}
351369
352370/// Same as `expr` but fails with a compile error if the result type is `noreturn`.
353371fn reachableExpr(
354372 gz: *GenZir,
355373 scope: *Scope,
356 rl: ResultLoc,
374 ri: ResultInfo,
357375 node: Ast.Node.Index,
358376 reachable_node: Ast.Node.Index,
359377) InnerError!Zir.Inst.Ref {
360 return reachableExprComptime(gz, scope, rl, node, reachable_node, false);
378 return reachableExprComptime(gz, scope, ri, node, reachable_node, false);
361379}
362380
363381fn reachableExprComptime(
364382 gz: *GenZir,
365383 scope: *Scope,
366 rl: ResultLoc,
384 ri: ResultInfo,
367385 node: Ast.Node.Index,
368386 reachable_node: Ast.Node.Index,
369387 force_comptime: bool,
......@@ -372,7 +390,7 @@ fn reachableExprComptime(
372390 gz.force_comptime = prev_force_comptime or force_comptime;
373391 defer gz.force_comptime = prev_force_comptime;
374392
375 const result_inst = try expr(gz, scope, rl, node);
393 const result_inst = try expr(gz, scope, ri, node);
376394 if (gz.refIsNoReturn(result_inst)) {
377395 try gz.astgen.appendErrorNodeNotes(reachable_node, "unreachable code", .{}, &[_]u32{
378396 try gz.astgen.errNoteNode(node, "control flow is diverted here", .{}),
......@@ -573,14 +591,14 @@ fn lvalExpr(gz: *GenZir, scope: *Scope, node: Ast.Node.Index) InnerError!Zir.Ins
573591 .@"orelse",
574592 => {},
575593 }
576 return expr(gz, scope, .ref, node);
594 return expr(gz, scope, .{ .rl = .ref }, node);
577595}
578596
579597/// Turn Zig AST into untyped ZIR instructions.
580598/// When `rl` is discard, ptr, inferred_ptr, or inferred_ptr, the
581599/// result instruction can be used to inspect whether it is isNoReturn() but that is it,
582600/// it must otherwise not be used.
583fn expr(gz: *GenZir, scope: *Scope, rl: ResultLoc, node: Ast.Node.Index) InnerError!Zir.Inst.Ref {
601fn expr(gz: *GenZir, scope: *Scope, ri: ResultInfo, node: Ast.Node.Index) InnerError!Zir.Inst.Ref {
584602 const astgen = gz.astgen;
585603 const tree = astgen.tree;
586604 const main_tokens = tree.nodes.items(.main_token);
......@@ -621,161 +639,161 @@ fn expr(gz: *GenZir, scope: *Scope, rl: ResultLoc, node: Ast.Node.Index) InnerEr
621639
622640 .assign => {
623641 try assign(gz, scope, node);
624 return rvalue(gz, rl, .void_value, node);
642 return rvalue(gz, ri, .void_value, node);
625643 },
626644
627645 .assign_shl => {
628646 try assignShift(gz, scope, node, .shl);
629 return rvalue(gz, rl, .void_value, node);
647 return rvalue(gz, ri, .void_value, node);
630648 },
631649 .assign_shl_sat => {
632650 try assignShiftSat(gz, scope, node);
633 return rvalue(gz, rl, .void_value, node);
651 return rvalue(gz, ri, .void_value, node);
634652 },
635653 .assign_shr => {
636654 try assignShift(gz, scope, node, .shr);
637 return rvalue(gz, rl, .void_value, node);
655 return rvalue(gz, ri, .void_value, node);
638656 },
639657
640658 .assign_bit_and => {
641659 try assignOp(gz, scope, node, .bit_and);
642 return rvalue(gz, rl, .void_value, node);
660 return rvalue(gz, ri, .void_value, node);
643661 },
644662 .assign_bit_or => {
645663 try assignOp(gz, scope, node, .bit_or);
646 return rvalue(gz, rl, .void_value, node);
664 return rvalue(gz, ri, .void_value, node);
647665 },
648666 .assign_bit_xor => {
649667 try assignOp(gz, scope, node, .xor);
650 return rvalue(gz, rl, .void_value, node);
668 return rvalue(gz, ri, .void_value, node);
651669 },
652670 .assign_div => {
653671 try assignOp(gz, scope, node, .div);
654 return rvalue(gz, rl, .void_value, node);
672 return rvalue(gz, ri, .void_value, node);
655673 },
656674 .assign_sub => {
657675 try assignOp(gz, scope, node, .sub);
658 return rvalue(gz, rl, .void_value, node);
676 return rvalue(gz, ri, .void_value, node);
659677 },
660678 .assign_sub_wrap => {
661679 try assignOp(gz, scope, node, .subwrap);
662 return rvalue(gz, rl, .void_value, node);
680 return rvalue(gz, ri, .void_value, node);
663681 },
664682 .assign_sub_sat => {
665683 try assignOp(gz, scope, node, .sub_sat);
666 return rvalue(gz, rl, .void_value, node);
684 return rvalue(gz, ri, .void_value, node);
667685 },
668686 .assign_mod => {
669687 try assignOp(gz, scope, node, .mod_rem);
670 return rvalue(gz, rl, .void_value, node);
688 return rvalue(gz, ri, .void_value, node);
671689 },
672690 .assign_add => {
673691 try assignOp(gz, scope, node, .add);
674 return rvalue(gz, rl, .void_value, node);
692 return rvalue(gz, ri, .void_value, node);
675693 },
676694 .assign_add_wrap => {
677695 try assignOp(gz, scope, node, .addwrap);
678 return rvalue(gz, rl, .void_value, node);
696 return rvalue(gz, ri, .void_value, node);
679697 },
680698 .assign_add_sat => {
681699 try assignOp(gz, scope, node, .add_sat);
682 return rvalue(gz, rl, .void_value, node);
700 return rvalue(gz, ri, .void_value, node);
683701 },
684702 .assign_mul => {
685703 try assignOp(gz, scope, node, .mul);
686 return rvalue(gz, rl, .void_value, node);
704 return rvalue(gz, ri, .void_value, node);
687705 },
688706 .assign_mul_wrap => {
689707 try assignOp(gz, scope, node, .mulwrap);
690 return rvalue(gz, rl, .void_value, node);
708 return rvalue(gz, ri, .void_value, node);
691709 },
692710 .assign_mul_sat => {
693711 try assignOp(gz, scope, node, .mul_sat);
694 return rvalue(gz, rl, .void_value, node);
712 return rvalue(gz, ri, .void_value, node);
695713 },
696714
697715 // zig fmt: off
698 .shl => return shiftOp(gz, scope, rl, node, node_datas[node].lhs, node_datas[node].rhs, .shl),
699 .shr => return shiftOp(gz, scope, rl, node, node_datas[node].lhs, node_datas[node].rhs, .shr),
700
701 .add => return simpleBinOp(gz, scope, rl, node, .add),
702 .add_wrap => return simpleBinOp(gz, scope, rl, node, .addwrap),
703 .add_sat => return simpleBinOp(gz, scope, rl, node, .add_sat),
704 .sub => return simpleBinOp(gz, scope, rl, node, .sub),
705 .sub_wrap => return simpleBinOp(gz, scope, rl, node, .subwrap),
706 .sub_sat => return simpleBinOp(gz, scope, rl, node, .sub_sat),
707 .mul => return simpleBinOp(gz, scope, rl, node, .mul),
708 .mul_wrap => return simpleBinOp(gz, scope, rl, node, .mulwrap),
709 .mul_sat => return simpleBinOp(gz, scope, rl, node, .mul_sat),
710 .div => return simpleBinOp(gz, scope, rl, node, .div),
711 .mod => return simpleBinOp(gz, scope, rl, node, .mod_rem),
712 .shl_sat => return simpleBinOp(gz, scope, rl, node, .shl_sat),
713
714 .bit_and => return simpleBinOp(gz, scope, rl, node, .bit_and),
715 .bit_or => return simpleBinOp(gz, scope, rl, node, .bit_or),
716 .bit_xor => return simpleBinOp(gz, scope, rl, node, .xor),
717 .bang_equal => return simpleBinOp(gz, scope, rl, node, .cmp_neq),
718 .equal_equal => return simpleBinOp(gz, scope, rl, node, .cmp_eq),
719 .greater_than => return simpleBinOp(gz, scope, rl, node, .cmp_gt),
720 .greater_or_equal => return simpleBinOp(gz, scope, rl, node, .cmp_gte),
721 .less_than => return simpleBinOp(gz, scope, rl, node, .cmp_lt),
722 .less_or_equal => return simpleBinOp(gz, scope, rl, node, .cmp_lte),
723 .array_cat => return simpleBinOp(gz, scope, rl, node, .array_cat),
716 .shl => return shiftOp(gz, scope, ri, node, node_datas[node].lhs, node_datas[node].rhs, .shl),
717 .shr => return shiftOp(gz, scope, ri, node, node_datas[node].lhs, node_datas[node].rhs, .shr),
718
719 .add => return simpleBinOp(gz, scope, ri, node, .add),
720 .add_wrap => return simpleBinOp(gz, scope, ri, node, .addwrap),
721 .add_sat => return simpleBinOp(gz, scope, ri, node, .add_sat),
722 .sub => return simpleBinOp(gz, scope, ri, node, .sub),
723 .sub_wrap => return simpleBinOp(gz, scope, ri, node, .subwrap),
724 .sub_sat => return simpleBinOp(gz, scope, ri, node, .sub_sat),
725 .mul => return simpleBinOp(gz, scope, ri, node, .mul),
726 .mul_wrap => return simpleBinOp(gz, scope, ri, node, .mulwrap),
727 .mul_sat => return simpleBinOp(gz, scope, ri, node, .mul_sat),
728 .div => return simpleBinOp(gz, scope, ri, node, .div),
729 .mod => return simpleBinOp(gz, scope, ri, node, .mod_rem),
730 .shl_sat => return simpleBinOp(gz, scope, ri, node, .shl_sat),
731
732 .bit_and => return simpleBinOp(gz, scope, ri, node, .bit_and),
733 .bit_or => return simpleBinOp(gz, scope, ri, node, .bit_or),
734 .bit_xor => return simpleBinOp(gz, scope, ri, node, .xor),
735 .bang_equal => return simpleBinOp(gz, scope, ri, node, .cmp_neq),
736 .equal_equal => return simpleBinOp(gz, scope, ri, node, .cmp_eq),
737 .greater_than => return simpleBinOp(gz, scope, ri, node, .cmp_gt),
738 .greater_or_equal => return simpleBinOp(gz, scope, ri, node, .cmp_gte),
739 .less_than => return simpleBinOp(gz, scope, ri, node, .cmp_lt),
740 .less_or_equal => return simpleBinOp(gz, scope, ri, node, .cmp_lte),
741 .array_cat => return simpleBinOp(gz, scope, ri, node, .array_cat),
724742
725743 .array_mult => {
726744 const result = try gz.addPlNode(.array_mul, node, Zir.Inst.Bin{
727 .lhs = try expr(gz, scope, .none, node_datas[node].lhs),
728 .rhs = try comptimeExpr(gz, scope, .{ .coerced_ty = .usize_type }, node_datas[node].rhs),
745 .lhs = try expr(gz, scope, .{ .rl = .none }, node_datas[node].lhs),
746 .rhs = try comptimeExpr(gz, scope, .{ .rl = .{ .coerced_ty = .usize_type } }, node_datas[node].rhs),
729747 });
730 return rvalue(gz, rl, result, node);
748 return rvalue(gz, ri, result, node);
731749 },
732750
733 .error_union => return simpleBinOp(gz, scope, rl, node, .error_union_type),
734 .merge_error_sets => return simpleBinOp(gz, scope, rl, node, .merge_error_sets),
751 .error_union => return simpleBinOp(gz, scope, ri, node, .error_union_type),
752 .merge_error_sets => return simpleBinOp(gz, scope, ri, node, .merge_error_sets),
735753
736 .bool_and => return boolBinOp(gz, scope, rl, node, .bool_br_and),
737 .bool_or => return boolBinOp(gz, scope, rl, node, .bool_br_or),
754 .bool_and => return boolBinOp(gz, scope, ri, node, .bool_br_and),
755 .bool_or => return boolBinOp(gz, scope, ri, node, .bool_br_or),
738756
739 .bool_not => return simpleUnOp(gz, scope, rl, node, bool_rl, node_datas[node].lhs, .bool_not),
740 .bit_not => return simpleUnOp(gz, scope, rl, node, .none, node_datas[node].lhs, .bit_not),
757 .bool_not => return simpleUnOp(gz, scope, ri, node, bool_ri, node_datas[node].lhs, .bool_not),
758 .bit_not => return simpleUnOp(gz, scope, ri, node, .{ .rl = .none }, node_datas[node].lhs, .bit_not),
741759
742 .negation => return negation(gz, scope, rl, node),
743 .negation_wrap => return simpleUnOp(gz, scope, rl, node, .none, node_datas[node].lhs, .negate_wrap),
760 .negation => return negation(gz, scope, ri, node),
761 .negation_wrap => return simpleUnOp(gz, scope, ri, node, .{ .rl = .none }, node_datas[node].lhs, .negate_wrap),
744762
745 .identifier => return identifier(gz, scope, rl, node),
763 .identifier => return identifier(gz, scope, ri, node),
746764
747 .asm_simple => return asmExpr(gz, scope, rl, node, tree.asmSimple(node)),
748 .@"asm" => return asmExpr(gz, scope, rl, node, tree.asmFull(node)),
765 .asm_simple => return asmExpr(gz, scope, ri, node, tree.asmSimple(node)),
766 .@"asm" => return asmExpr(gz, scope, ri, node, tree.asmFull(node)),
749767
750 .string_literal => return stringLiteral(gz, rl, node),
751 .multiline_string_literal => return multilineStringLiteral(gz, rl, node),
768 .string_literal => return stringLiteral(gz, ri, node),
769 .multiline_string_literal => return multilineStringLiteral(gz, ri, node),
752770
753 .number_literal => return numberLiteral(gz, rl, node, node, .positive),
771 .number_literal => return numberLiteral(gz, ri, node, node, .positive),
754772 // zig fmt: on
755773
756774 .builtin_call_two, .builtin_call_two_comma => {
757775 if (node_datas[node].lhs == 0) {
758776 const params = [_]Ast.Node.Index{};
759 return builtinCall(gz, scope, rl, node, &params);
777 return builtinCall(gz, scope, ri, node, &params);
760778 } else if (node_datas[node].rhs == 0) {
761779 const params = [_]Ast.Node.Index{node_datas[node].lhs};
762 return builtinCall(gz, scope, rl, node, &params);
780 return builtinCall(gz, scope, ri, node, &params);
763781 } else {
764782 const params = [_]Ast.Node.Index{ node_datas[node].lhs, node_datas[node].rhs };
765 return builtinCall(gz, scope, rl, node, &params);
783 return builtinCall(gz, scope, ri, node, &params);
766784 }
767785 },
768786 .builtin_call, .builtin_call_comma => {
769787 const params = tree.extra_data[node_datas[node].lhs..node_datas[node].rhs];
770 return builtinCall(gz, scope, rl, node, params);
788 return builtinCall(gz, scope, ri, node, params);
771789 },
772790
773791 .call_one, .call_one_comma, .async_call_one, .async_call_one_comma => {
774792 var params: [1]Ast.Node.Index = undefined;
775 return callExpr(gz, scope, rl, node, tree.callOne(&params, node));
793 return callExpr(gz, scope, ri, node, tree.callOne(&params, node));
776794 },
777795 .call, .call_comma, .async_call, .async_call_comma => {
778 return callExpr(gz, scope, rl, node, tree.callFull(node));
796 return callExpr(gz, scope, ri, node, tree.callFull(node));
779797 },
780798
781799 .unreachable_literal => {
......@@ -790,112 +808,112 @@ fn expr(gz: *GenZir, scope: *Scope, rl: ResultLoc, node: Ast.Node.Index) InnerEr
790808 return Zir.Inst.Ref.unreachable_value;
791809 },
792810 .@"return" => return ret(gz, scope, node),
793 .field_access => return fieldAccess(gz, scope, rl, node),
811 .field_access => return fieldAccess(gz, scope, ri, node),
794812
795 .if_simple => return ifExpr(gz, scope, rl.br(), node, tree.ifSimple(node)),
796 .@"if" => return ifExpr(gz, scope, rl.br(), node, tree.ifFull(node)),
813 .if_simple => return ifExpr(gz, scope, ri.br(), node, tree.ifSimple(node)),
814 .@"if" => return ifExpr(gz, scope, ri.br(), node, tree.ifFull(node)),
797815
798 .while_simple => return whileExpr(gz, scope, rl.br(), node, tree.whileSimple(node), false),
799 .while_cont => return whileExpr(gz, scope, rl.br(), node, tree.whileCont(node), false),
800 .@"while" => return whileExpr(gz, scope, rl.br(), node, tree.whileFull(node), false),
816 .while_simple => return whileExpr(gz, scope, ri.br(), node, tree.whileSimple(node), false),
817 .while_cont => return whileExpr(gz, scope, ri.br(), node, tree.whileCont(node), false),
818 .@"while" => return whileExpr(gz, scope, ri.br(), node, tree.whileFull(node), false),
801819
802 .for_simple => return forExpr(gz, scope, rl.br(), node, tree.forSimple(node), false),
803 .@"for" => return forExpr(gz, scope, rl.br(), node, tree.forFull(node), false),
820 .for_simple => return forExpr(gz, scope, ri.br(), node, tree.forSimple(node), false),
821 .@"for" => return forExpr(gz, scope, ri.br(), node, tree.forFull(node), false),
804822
805823 .slice_open => {
806 const lhs = try expr(gz, scope, .ref, node_datas[node].lhs);
807 const start = try expr(gz, scope, .{ .coerced_ty = .usize_type }, node_datas[node].rhs);
824 const lhs = try expr(gz, scope, .{ .rl = .ref }, node_datas[node].lhs);
825 const start = try expr(gz, scope, .{ .rl = .{ .coerced_ty = .usize_type } }, node_datas[node].rhs);
808826 const result = try gz.addPlNode(.slice_start, node, Zir.Inst.SliceStart{
809827 .lhs = lhs,
810828 .start = start,
811829 });
812 return rvalue(gz, rl, result, node);
830 return rvalue(gz, ri, result, node);
813831 },
814832 .slice => {
815 const lhs = try expr(gz, scope, .ref, node_datas[node].lhs);
833 const lhs = try expr(gz, scope, .{ .rl = .ref }, node_datas[node].lhs);
816834 const extra = tree.extraData(node_datas[node].rhs, Ast.Node.Slice);
817 const start = try expr(gz, scope, .{ .coerced_ty = .usize_type }, extra.start);
818 const end = try expr(gz, scope, .{ .coerced_ty = .usize_type }, extra.end);
835 const start = try expr(gz, scope, .{ .rl = .{ .coerced_ty = .usize_type } }, extra.start);
836 const end = try expr(gz, scope, .{ .rl = .{ .coerced_ty = .usize_type } }, extra.end);
819837 const result = try gz.addPlNode(.slice_end, node, Zir.Inst.SliceEnd{
820838 .lhs = lhs,
821839 .start = start,
822840 .end = end,
823841 });
824 return rvalue(gz, rl, result, node);
842 return rvalue(gz, ri, result, node);
825843 },
826844 .slice_sentinel => {
827 const lhs = try expr(gz, scope, .ref, node_datas[node].lhs);
845 const lhs = try expr(gz, scope, .{ .rl = .ref }, node_datas[node].lhs);
828846 const extra = tree.extraData(node_datas[node].rhs, Ast.Node.SliceSentinel);
829 const start = try expr(gz, scope, .{ .coerced_ty = .usize_type }, extra.start);
830 const end = if (extra.end != 0) try expr(gz, scope, .{ .coerced_ty = .usize_type }, extra.end) else .none;
831 const sentinel = try expr(gz, scope, .none, extra.sentinel);
847 const start = try expr(gz, scope, .{ .rl = .{ .coerced_ty = .usize_type } }, extra.start);
848 const end = if (extra.end != 0) try expr(gz, scope, .{ .rl = .{ .coerced_ty = .usize_type } }, extra.end) else .none;
849 const sentinel = try expr(gz, scope, .{ .rl = .none }, extra.sentinel);
832850 const result = try gz.addPlNode(.slice_sentinel, node, Zir.Inst.SliceSentinel{
833851 .lhs = lhs,
834852 .start = start,
835853 .end = end,
836854 .sentinel = sentinel,
837855 });
838 return rvalue(gz, rl, result, node);
856 return rvalue(gz, ri, result, node);
839857 },
840858
841859 .deref => {
842 const lhs = try expr(gz, scope, .none, node_datas[node].lhs);
860 const lhs = try expr(gz, scope, .{ .rl = .none }, node_datas[node].lhs);
843861 _ = try gz.addUnNode(.validate_deref, lhs, node);
844 switch (rl) {
845 .ref, .catch_ref => return lhs,
862 switch (ri.rl) {
863 .ref => return lhs,
846864 else => {
847865 const result = try gz.addUnNode(.load, lhs, node);
848 return rvalue(gz, rl, result, node);
866 return rvalue(gz, ri, result, node);
849867 },
850868 }
851869 },
852870 .address_of => {
853 const result = try expr(gz, scope, .ref, node_datas[node].lhs);
854 return rvalue(gz, rl, result, node);
871 const result = try expr(gz, scope, .{ .rl = .ref }, node_datas[node].lhs);
872 return rvalue(gz, ri, result, node);
855873 },
856874 .optional_type => {
857875 const operand = try typeExpr(gz, scope, node_datas[node].lhs);
858876 const result = try gz.addUnNode(.optional_type, operand, node);
859 return rvalue(gz, rl, result, node);
877 return rvalue(gz, ri, result, node);
860878 },
861 .unwrap_optional => switch (rl) {
862 .ref, .catch_ref => return gz.addUnNode(
879 .unwrap_optional => switch (ri.rl) {
880 .ref => return gz.addUnNode(
863881 .optional_payload_safe_ptr,
864 try expr(gz, scope, .ref, node_datas[node].lhs),
882 try expr(gz, scope, .{ .rl = .ref }, node_datas[node].lhs),
865883 node,
866884 ),
867 else => return rvalue(gz, rl, try gz.addUnNode(
885 else => return rvalue(gz, ri, try gz.addUnNode(
868886 .optional_payload_safe,
869 try expr(gz, scope, .none, node_datas[node].lhs),
887 try expr(gz, scope, .{ .rl = .none }, node_datas[node].lhs),
870888 node,
871889 ), node),
872890 },
873891 .block_two, .block_two_semicolon => {
874892 const statements = [2]Ast.Node.Index{ node_datas[node].lhs, node_datas[node].rhs };
875893 if (node_datas[node].lhs == 0) {
876 return blockExpr(gz, scope, rl, node, statements[0..0]);
894 return blockExpr(gz, scope, ri, node, statements[0..0]);
877895 } else if (node_datas[node].rhs == 0) {
878 return blockExpr(gz, scope, rl, node, statements[0..1]);
896 return blockExpr(gz, scope, ri, node, statements[0..1]);
879897 } else {
880 return blockExpr(gz, scope, rl, node, statements[0..2]);
898 return blockExpr(gz, scope, ri, node, statements[0..2]);
881899 }
882900 },
883901 .block, .block_semicolon => {
884902 const statements = tree.extra_data[node_datas[node].lhs..node_datas[node].rhs];
885 return blockExpr(gz, scope, rl, node, statements);
903 return blockExpr(gz, scope, ri, node, statements);
886904 },
887 .enum_literal => return simpleStrTok(gz, rl, main_tokens[node], node, .enum_literal),
888 .error_value => return simpleStrTok(gz, rl, node_datas[node].rhs, node, .error_value),
905 .enum_literal => return simpleStrTok(gz, ri, main_tokens[node], node, .enum_literal),
906 .error_value => return simpleStrTok(gz, ri, node_datas[node].rhs, node, .error_value),
889907 // TODO restore this when implementing https://github.com/ziglang/zig/issues/6025
890 // .anyframe_literal => return rvalue(gz, rl, .anyframe_type, node),
908 // .anyframe_literal => return rvalue(gz, ri, .anyframe_type, node),
891909 .anyframe_literal => {
892910 const result = try gz.addUnNode(.anyframe_type, .void_type, node);
893 return rvalue(gz, rl, result, node);
911 return rvalue(gz, ri, result, node);
894912 },
895913 .anyframe_type => {
896914 const return_type = try typeExpr(gz, scope, node_datas[node].rhs);
897915 const result = try gz.addUnNode(.anyframe_type, return_type, node);
898 return rvalue(gz, rl, result, node);
916 return rvalue(gz, ri, result, node);
899917 },
900918 .@"catch" => {
901919 const catch_token = main_tokens[node];
......@@ -903,11 +921,11 @@ fn expr(gz: *GenZir, scope: *Scope, rl: ResultLoc, node: Ast.Node.Index) InnerEr
903921 catch_token + 2
904922 else
905923 null;
906 switch (rl) {
907 .ref, .catch_ref => return orelseCatchExpr(
924 switch (ri.rl) {
925 .ref => return orelseCatchExpr(
908926 gz,
909927 scope,
910 rl,
928 ri,
911929 node,
912930 node_datas[node].lhs,
913931 .is_non_err_ptr,
......@@ -919,7 +937,7 @@ fn expr(gz: *GenZir, scope: *Scope, rl: ResultLoc, node: Ast.Node.Index) InnerEr
919937 else => return orelseCatchExpr(
920938 gz,
921939 scope,
922 rl,
940 ri,
923941 node,
924942 node_datas[node].lhs,
925943 .is_non_err,
......@@ -930,11 +948,11 @@ fn expr(gz: *GenZir, scope: *Scope, rl: ResultLoc, node: Ast.Node.Index) InnerEr
930948 ),
931949 }
932950 },
933 .@"orelse" => switch (rl) {
934 .ref, .catch_ref => return orelseCatchExpr(
951 .@"orelse" => switch (ri.rl) {
952 .ref => return orelseCatchExpr(
935953 gz,
936954 scope,
937 rl,
955 ri,
938956 node,
939957 node_datas[node].lhs,
940958 .is_non_null_ptr,
......@@ -946,7 +964,7 @@ fn expr(gz: *GenZir, scope: *Scope, rl: ResultLoc, node: Ast.Node.Index) InnerEr
946964 else => return orelseCatchExpr(
947965 gz,
948966 scope,
949 rl,
967 ri,
950968 node,
951969 node_datas[node].lhs,
952970 .is_non_null,
......@@ -957,94 +975,94 @@ fn expr(gz: *GenZir, scope: *Scope, rl: ResultLoc, node: Ast.Node.Index) InnerEr
957975 ),
958976 },
959977
960 .ptr_type_aligned => return ptrType(gz, scope, rl, node, tree.ptrTypeAligned(node)),
961 .ptr_type_sentinel => return ptrType(gz, scope, rl, node, tree.ptrTypeSentinel(node)),
962 .ptr_type => return ptrType(gz, scope, rl, node, tree.ptrType(node)),
963 .ptr_type_bit_range => return ptrType(gz, scope, rl, node, tree.ptrTypeBitRange(node)),
978 .ptr_type_aligned => return ptrType(gz, scope, ri, node, tree.ptrTypeAligned(node)),
979 .ptr_type_sentinel => return ptrType(gz, scope, ri, node, tree.ptrTypeSentinel(node)),
980 .ptr_type => return ptrType(gz, scope, ri, node, tree.ptrType(node)),
981 .ptr_type_bit_range => return ptrType(gz, scope, ri, node, tree.ptrTypeBitRange(node)),
964982
965983 .container_decl,
966984 .container_decl_trailing,
967 => return containerDecl(gz, scope, rl, node, tree.containerDecl(node)),
985 => return containerDecl(gz, scope, ri, node, tree.containerDecl(node)),
968986 .container_decl_two, .container_decl_two_trailing => {
969987 var buffer: [2]Ast.Node.Index = undefined;
970 return containerDecl(gz, scope, rl, node, tree.containerDeclTwo(&buffer, node));
988 return containerDecl(gz, scope, ri, node, tree.containerDeclTwo(&buffer, node));
971989 },
972990 .container_decl_arg,
973991 .container_decl_arg_trailing,
974 => return containerDecl(gz, scope, rl, node, tree.containerDeclArg(node)),
992 => return containerDecl(gz, scope, ri, node, tree.containerDeclArg(node)),
975993
976994 .tagged_union,
977995 .tagged_union_trailing,
978 => return containerDecl(gz, scope, rl, node, tree.taggedUnion(node)),
996 => return containerDecl(gz, scope, ri, node, tree.taggedUnion(node)),
979997 .tagged_union_two, .tagged_union_two_trailing => {
980998 var buffer: [2]Ast.Node.Index = undefined;
981 return containerDecl(gz, scope, rl, node, tree.taggedUnionTwo(&buffer, node));
999 return containerDecl(gz, scope, ri, node, tree.taggedUnionTwo(&buffer, node));
9821000 },
9831001 .tagged_union_enum_tag,
9841002 .tagged_union_enum_tag_trailing,
985 => return containerDecl(gz, scope, rl, node, tree.taggedUnionEnumTag(node)),
1003 => return containerDecl(gz, scope, ri, node, tree.taggedUnionEnumTag(node)),
9861004
9871005 .@"break" => return breakExpr(gz, scope, node),
9881006 .@"continue" => return continueExpr(gz, scope, node),
989 .grouped_expression => return expr(gz, scope, rl, node_datas[node].lhs),
990 .array_type => return arrayType(gz, scope, rl, node),
991 .array_type_sentinel => return arrayTypeSentinel(gz, scope, rl, node),
992 .char_literal => return charLiteral(gz, rl, node),
993 .error_set_decl => return errorSetDecl(gz, rl, node),
994 .array_access => return arrayAccess(gz, scope, rl, node),
995 .@"comptime" => return comptimeExprAst(gz, scope, rl, node),
996 .@"switch", .switch_comma => return switchExpr(gz, scope, rl.br(), node),
997
998 .@"nosuspend" => return nosuspendExpr(gz, scope, rl, node),
1007 .grouped_expression => return expr(gz, scope, ri, node_datas[node].lhs),
1008 .array_type => return arrayType(gz, scope, ri, node),
1009 .array_type_sentinel => return arrayTypeSentinel(gz, scope, ri, node),
1010 .char_literal => return charLiteral(gz, ri, node),
1011 .error_set_decl => return errorSetDecl(gz, ri, node),
1012 .array_access => return arrayAccess(gz, scope, ri, node),
1013 .@"comptime" => return comptimeExprAst(gz, scope, ri, node),
1014 .@"switch", .switch_comma => return switchExpr(gz, scope, ri.br(), node),
1015
1016 .@"nosuspend" => return nosuspendExpr(gz, scope, ri, node),
9991017 .@"suspend" => return suspendExpr(gz, scope, node),
1000 .@"await" => return awaitExpr(gz, scope, rl, node),
1001 .@"resume" => return resumeExpr(gz, scope, rl, node),
1018 .@"await" => return awaitExpr(gz, scope, ri, node),
1019 .@"resume" => return resumeExpr(gz, scope, ri, node),
10021020
1003 .@"try" => return tryExpr(gz, scope, rl, node, node_datas[node].lhs),
1021 .@"try" => return tryExpr(gz, scope, ri, node, node_datas[node].lhs),
10041022
10051023 .array_init_one, .array_init_one_comma => {
10061024 var elements: [1]Ast.Node.Index = undefined;
1007 return arrayInitExpr(gz, scope, rl, node, tree.arrayInitOne(&elements, node));
1025 return arrayInitExpr(gz, scope, ri, node, tree.arrayInitOne(&elements, node));
10081026 },
10091027 .array_init_dot_two, .array_init_dot_two_comma => {
10101028 var elements: [2]Ast.Node.Index = undefined;
1011 return arrayInitExpr(gz, scope, rl, node, tree.arrayInitDotTwo(&elements, node));
1029 return arrayInitExpr(gz, scope, ri, node, tree.arrayInitDotTwo(&elements, node));
10121030 },
10131031 .array_init_dot,
10141032 .array_init_dot_comma,
1015 => return arrayInitExpr(gz, scope, rl, node, tree.arrayInitDot(node)),
1033 => return arrayInitExpr(gz, scope, ri, node, tree.arrayInitDot(node)),
10161034 .array_init,
10171035 .array_init_comma,
1018 => return arrayInitExpr(gz, scope, rl, node, tree.arrayInit(node)),
1036 => return arrayInitExpr(gz, scope, ri, node, tree.arrayInit(node)),
10191037
10201038 .struct_init_one, .struct_init_one_comma => {
10211039 var fields: [1]Ast.Node.Index = undefined;
1022 return structInitExpr(gz, scope, rl, node, tree.structInitOne(&fields, node));
1040 return structInitExpr(gz, scope, ri, node, tree.structInitOne(&fields, node));
10231041 },
10241042 .struct_init_dot_two, .struct_init_dot_two_comma => {
10251043 var fields: [2]Ast.Node.Index = undefined;
1026 return structInitExpr(gz, scope, rl, node, tree.structInitDotTwo(&fields, node));
1044 return structInitExpr(gz, scope, ri, node, tree.structInitDotTwo(&fields, node));
10271045 },
10281046 .struct_init_dot,
10291047 .struct_init_dot_comma,
1030 => return structInitExpr(gz, scope, rl, node, tree.structInitDot(node)),
1048 => return structInitExpr(gz, scope, ri, node, tree.structInitDot(node)),
10311049 .struct_init,
10321050 .struct_init_comma,
1033 => return structInitExpr(gz, scope, rl, node, tree.structInit(node)),
1051 => return structInitExpr(gz, scope, ri, node, tree.structInit(node)),
10341052
10351053 .fn_proto_simple => {
10361054 var params: [1]Ast.Node.Index = undefined;
1037 return fnProtoExpr(gz, scope, rl, node, tree.fnProtoSimple(&params, node));
1055 return fnProtoExpr(gz, scope, ri, node, tree.fnProtoSimple(&params, node));
10381056 },
10391057 .fn_proto_multi => {
1040 return fnProtoExpr(gz, scope, rl, node, tree.fnProtoMulti(node));
1058 return fnProtoExpr(gz, scope, ri, node, tree.fnProtoMulti(node));
10411059 },
10421060 .fn_proto_one => {
10431061 var params: [1]Ast.Node.Index = undefined;
1044 return fnProtoExpr(gz, scope, rl, node, tree.fnProtoOne(&params, node));
1062 return fnProtoExpr(gz, scope, ri, node, tree.fnProtoOne(&params, node));
10451063 },
10461064 .fn_proto => {
1047 return fnProtoExpr(gz, scope, rl, node, tree.fnProto(node));
1065 return fnProtoExpr(gz, scope, ri, node, tree.fnProto(node));
10481066 },
10491067 }
10501068}
......@@ -1052,7 +1070,7 @@ fn expr(gz: *GenZir, scope: *Scope, rl: ResultLoc, node: Ast.Node.Index) InnerEr
10521070fn nosuspendExpr(
10531071 gz: *GenZir,
10541072 scope: *Scope,
1055 rl: ResultLoc,
1073 ri: ResultInfo,
10561074 node: Ast.Node.Index,
10571075) InnerError!Zir.Inst.Ref {
10581076 const astgen = gz.astgen;
......@@ -1067,7 +1085,7 @@ fn nosuspendExpr(
10671085 }
10681086 gz.nosuspend_node = node;
10691087 defer gz.nosuspend_node = 0;
1070 return expr(gz, scope, rl, body_node);
1088 return expr(gz, scope, ri, body_node);
10711089}
10721090
10731091fn suspendExpr(
......@@ -1100,7 +1118,7 @@ fn suspendExpr(
11001118 suspend_scope.suspend_node = node;
11011119 defer suspend_scope.unstack();
11021120
1103 const body_result = try expr(&suspend_scope, &suspend_scope.base, .none, body_node);
1121 const body_result = try expr(&suspend_scope, &suspend_scope.base, .{ .rl = .none }, body_node);
11041122 if (!gz.refIsNoReturn(body_result)) {
11051123 _ = try suspend_scope.addBreak(.break_inline, suspend_inst, .void_value);
11061124 }
......@@ -1112,7 +1130,7 @@ fn suspendExpr(
11121130fn awaitExpr(
11131131 gz: *GenZir,
11141132 scope: *Scope,
1115 rl: ResultLoc,
1133 ri: ResultInfo,
11161134 node: Ast.Node.Index,
11171135) InnerError!Zir.Inst.Ref {
11181136 const astgen = gz.astgen;
......@@ -1125,7 +1143,7 @@ fn awaitExpr(
11251143 try astgen.errNoteNode(gz.suspend_node, "suspend block here", .{}),
11261144 });
11271145 }
1128 const operand = try expr(gz, scope, .none, rhs_node);
1146 const operand = try expr(gz, scope, .{ .rl = .none }, rhs_node);
11291147 const result = if (gz.nosuspend_node != 0)
11301148 try gz.addExtendedPayload(.await_nosuspend, Zir.Inst.UnNode{
11311149 .node = gz.nodeIndexToRelative(node),
......@@ -1134,28 +1152,28 @@ fn awaitExpr(
11341152 else
11351153 try gz.addUnNode(.@"await", operand, node);
11361154
1137 return rvalue(gz, rl, result, node);
1155 return rvalue(gz, ri, result, node);
11381156}
11391157
11401158fn resumeExpr(
11411159 gz: *GenZir,
11421160 scope: *Scope,
1143 rl: ResultLoc,
1161 ri: ResultInfo,
11441162 node: Ast.Node.Index,
11451163) InnerError!Zir.Inst.Ref {
11461164 const astgen = gz.astgen;
11471165 const tree = astgen.tree;
11481166 const node_datas = tree.nodes.items(.data);
11491167 const rhs_node = node_datas[node].lhs;
1150 const operand = try expr(gz, scope, .none, rhs_node);
1168 const operand = try expr(gz, scope, .{ .rl = .none }, rhs_node);
11511169 const result = try gz.addUnNode(.@"resume", operand, node);
1152 return rvalue(gz, rl, result, node);
1170 return rvalue(gz, ri, result, node);
11531171}
11541172
11551173fn fnProtoExpr(
11561174 gz: *GenZir,
11571175 scope: *Scope,
1158 rl: ResultLoc,
1176 ri: ResultInfo,
11591177 node: Ast.Node.Index,
11601178 fn_proto: Ast.full.FnProto,
11611179) InnerError!Zir.Inst.Ref {
......@@ -1221,7 +1239,7 @@ fn fnProtoExpr(
12211239 assert(param_type_node != 0);
12221240 var param_gz = block_scope.makeSubBlock(scope);
12231241 defer param_gz.unstack();
1224 const param_type = try expr(&param_gz, scope, coerced_type_rl, param_type_node);
1242 const param_type = try expr(&param_gz, scope, coerced_type_ri, param_type_node);
12251243 const param_inst_expected = @intCast(u32, astgen.instructions.len + 1);
12261244 _ = try param_gz.addBreak(.break_inline, param_inst_expected, param_type);
12271245 const main_tokens = tree.nodes.items(.main_token);
......@@ -1235,7 +1253,7 @@ fn fnProtoExpr(
12351253 };
12361254
12371255 const align_ref: Zir.Inst.Ref = if (fn_proto.ast.align_expr == 0) .none else inst: {
1238 break :inst try expr(&block_scope, scope, align_rl, fn_proto.ast.align_expr);
1256 break :inst try expr(&block_scope, scope, align_ri, fn_proto.ast.align_expr);
12391257 };
12401258
12411259 if (fn_proto.ast.addrspace_expr != 0) {
......@@ -1250,7 +1268,7 @@ fn fnProtoExpr(
12501268 try expr(
12511269 &block_scope,
12521270 scope,
1253 .{ .ty = .calling_convention_type },
1271 .{ .rl = .{ .ty = .calling_convention_type } },
12541272 fn_proto.ast.callconv_expr,
12551273 )
12561274 else
......@@ -1261,7 +1279,7 @@ fn fnProtoExpr(
12611279 if (is_inferred_error) {
12621280 return astgen.failTok(maybe_bang, "function prototype may not have inferred error set", .{});
12631281 }
1264 const ret_ty = try expr(&block_scope, scope, coerced_type_rl, fn_proto.ast.return_type);
1282 const ret_ty = try expr(&block_scope, scope, coerced_type_ri, fn_proto.ast.return_type);
12651283
12661284 const result = try block_scope.addFunc(.{
12671285 .src_node = fn_proto.ast.proto_node,
......@@ -1292,13 +1310,13 @@ fn fnProtoExpr(
12921310 try block_scope.setBlockBody(block_inst);
12931311 try gz.instructions.append(astgen.gpa, block_inst);
12941312
1295 return rvalue(gz, rl, indexToRef(block_inst), fn_proto.ast.proto_node);
1313 return rvalue(gz, ri, indexToRef(block_inst), fn_proto.ast.proto_node);
12961314}
12971315
12981316fn arrayInitExpr(
12991317 gz: *GenZir,
13001318 scope: *Scope,
1301 rl: ResultLoc,
1319 ri: ResultInfo,
13021320 node: Ast.Node.Index,
13031321 array_init: Ast.full.ArrayInit,
13041322) InnerError!Zir.Inst.Ref {
......@@ -1340,7 +1358,7 @@ fn arrayInitExpr(
13401358 .elem = elem_type,
13411359 };
13421360 } else {
1343 const sentinel = try comptimeExpr(gz, scope, .{ .ty = elem_type }, array_type.ast.sentinel);
1361 const sentinel = try comptimeExpr(gz, scope, .{ .rl = .{ .ty = elem_type } }, array_type.ast.sentinel);
13441362 const array_type_inst = try gz.addPlNode(
13451363 .array_type_sentinel,
13461364 array_init.ast.type_expr,
......@@ -1368,29 +1386,29 @@ fn arrayInitExpr(
13681386 };
13691387 };
13701388
1371 switch (rl) {
1389 switch (ri.rl) {
13721390 .discard => {
13731391 // TODO elements should still be coerced if type is provided
13741392 for (array_init.ast.elements) |elem_init| {
1375 _ = try expr(gz, scope, .discard, elem_init);
1393 _ = try expr(gz, scope, .{ .rl = .discard }, elem_init);
13761394 }
13771395 return Zir.Inst.Ref.void_value;
13781396 },
1379 .ref, .catch_ref => {
1397 .ref => {
13801398 const tag: Zir.Inst.Tag = if (types.array != .none) .array_init_ref else .array_init_anon_ref;
13811399 return arrayInitExprInner(gz, scope, node, array_init.ast.elements, types.array, types.elem, tag);
13821400 },
1383 .none, .catch_none => {
1401 .none => {
13841402 const tag: Zir.Inst.Tag = if (types.array != .none) .array_init else .array_init_anon;
13851403 return arrayInitExprInner(gz, scope, node, array_init.ast.elements, types.array, types.elem, tag);
13861404 },
1387 .ty, .ty_shift_operand, .coerced_ty => {
1405 .ty, .coerced_ty => {
13881406 const tag: Zir.Inst.Tag = if (types.array != .none) .array_init else .array_init_anon;
13891407 const result = try arrayInitExprInner(gz, scope, node, array_init.ast.elements, types.array, types.elem, tag);
1390 return rvalue(gz, rl, result, node);
1408 return rvalue(gz, ri, result, node);
13911409 },
13921410 .ptr => |ptr_res| {
1393 return arrayInitExprRlPtr(gz, scope, rl, node, ptr_res.inst, array_init.ast.elements, types.array);
1411 return arrayInitExprRlPtr(gz, scope, ri, node, ptr_res.inst, array_init.ast.elements, types.array);
13941412 },
13951413 .inferred_ptr => |ptr_inst| {
13961414 if (types.array == .none) {
......@@ -1398,9 +1416,9 @@ fn arrayInitExpr(
13981416 // analyzing array_base_ptr against an alloc_inferred_mut.
13991417 // See corresponding logic in structInitExpr.
14001418 const result = try arrayInitExprRlNone(gz, scope, node, array_init.ast.elements, .array_init_anon);
1401 return rvalue(gz, rl, result, node);
1419 return rvalue(gz, ri, result, node);
14021420 } else {
1403 return arrayInitExprRlPtr(gz, scope, rl, node, ptr_inst, array_init.ast.elements, types.array);
1421 return arrayInitExprRlPtr(gz, scope, ri, node, ptr_inst, array_init.ast.elements, types.array);
14041422 }
14051423 },
14061424 .block_ptr => |block_gz| {
......@@ -1408,9 +1426,9 @@ fn arrayInitExpr(
14081426 // See corresponding logic in structInitExpr.
14091427 if (types.array == .none and astgen.isInferred(block_gz.rl_ptr)) {
14101428 const result = try arrayInitExprRlNone(gz, scope, node, array_init.ast.elements, .array_init_anon);
1411 return rvalue(gz, rl, result, node);
1429 return rvalue(gz, ri, result, node);
14121430 }
1413 return arrayInitExprRlPtr(gz, scope, rl, node, block_gz.rl_ptr, array_init.ast.elements, types.array);
1431 return arrayInitExprRlPtr(gz, scope, ri, node, block_gz.rl_ptr, array_init.ast.elements, types.array);
14141432 },
14151433 }
14161434}
......@@ -1430,7 +1448,7 @@ fn arrayInitExprRlNone(
14301448 var extra_index = try reserveExtra(astgen, elements.len);
14311449
14321450 for (elements) |elem_init| {
1433 const elem_ref = try expr(gz, scope, .none, elem_init);
1451 const elem_ref = try expr(gz, scope, .{ .rl = .none }, elem_init);
14341452 astgen.extra.items[extra_index] = @enumToInt(elem_ref);
14351453 extra_index += 1;
14361454 }
......@@ -1459,9 +1477,9 @@ fn arrayInitExprInner(
14591477 }
14601478
14611479 for (elements) |elem_init, i| {
1462 const rl = if (elem_ty != .none)
1463 ResultLoc{ .coerced_ty = elem_ty }
1464 else if (array_ty_inst != .none and nodeMayNeedMemoryLocation(astgen.tree, elem_init, true)) rl: {
1480 const ri = if (elem_ty != .none)
1481 ResultInfo{ .rl = .{ .coerced_ty = elem_ty } }
1482 else if (array_ty_inst != .none and nodeMayNeedMemoryLocation(astgen.tree, elem_init, true)) ri: {
14651483 const ty_expr = try gz.add(.{
14661484 .tag = .elem_type_index,
14671485 .data = .{ .bin = .{
......@@ -1469,10 +1487,10 @@ fn arrayInitExprInner(
14691487 .rhs = @intToEnum(Zir.Inst.Ref, i),
14701488 } },
14711489 });
1472 break :rl ResultLoc{ .coerced_ty = ty_expr };
1473 } else ResultLoc{ .none = {} };
1490 break :ri ResultInfo{ .rl = .{ .coerced_ty = ty_expr } };
1491 } else ResultInfo{ .rl = .{ .none = {} } };
14741492
1475 const elem_ref = try expr(gz, scope, rl, elem_init);
1493 const elem_ref = try expr(gz, scope, ri, elem_init);
14761494 astgen.extra.items[extra_index] = @enumToInt(elem_ref);
14771495 extra_index += 1;
14781496 }
......@@ -1483,7 +1501,7 @@ fn arrayInitExprInner(
14831501fn arrayInitExprRlPtr(
14841502 gz: *GenZir,
14851503 scope: *Scope,
1486 rl: ResultLoc,
1504 ri: ResultInfo,
14871505 node: Ast.Node.Index,
14881506 result_ptr: Zir.Inst.Ref,
14891507 elements: []const Ast.Node.Index,
......@@ -1498,7 +1516,7 @@ fn arrayInitExprRlPtr(
14981516 defer as_scope.unstack();
14991517
15001518 const result = try arrayInitExprRlPtrInner(&as_scope, scope, node, as_scope.rl_ptr, elements);
1501 return as_scope.finishCoercion(gz, rl, node, result, array_ty);
1519 return as_scope.finishCoercion(gz, ri, node, result, array_ty);
15021520}
15031521
15041522fn arrayInitExprRlPtrInner(
......@@ -1522,7 +1540,7 @@ fn arrayInitExprRlPtrInner(
15221540 });
15231541 astgen.extra.items[extra_index] = refToIndex(elem_ptr).?;
15241542 extra_index += 1;
1525 _ = try expr(gz, scope, .{ .ptr = .{ .inst = elem_ptr } }, elem_init);
1543 _ = try expr(gz, scope, .{ .rl = .{ .ptr = .{ .inst = elem_ptr } } }, elem_init);
15261544 }
15271545
15281546 const tag: Zir.Inst.Tag = if (gz.force_comptime)
......@@ -1537,7 +1555,7 @@ fn arrayInitExprRlPtrInner(
15371555fn structInitExpr(
15381556 gz: *GenZir,
15391557 scope: *Scope,
1540 rl: ResultLoc,
1558 ri: ResultInfo,
15411559 node: Ast.Node.Index,
15421560 struct_init: Ast.full.StructInit,
15431561) InnerError!Zir.Inst.Ref {
......@@ -1546,7 +1564,7 @@ fn structInitExpr(
15461564
15471565 if (struct_init.ast.type_expr == 0) {
15481566 if (struct_init.ast.fields.len == 0) {
1549 return rvalue(gz, rl, .empty_struct, node);
1567 return rvalue(gz, ri, .empty_struct, node);
15501568 }
15511569 } else array: {
15521570 const node_tags = tree.nodes.items(.tag);
......@@ -1558,7 +1576,7 @@ fn structInitExpr(
15581576 if (struct_init.ast.fields.len == 0) {
15591577 const ty_inst = try typeExpr(gz, scope, struct_init.ast.type_expr);
15601578 const result = try gz.addUnNode(.struct_init_empty, ty_inst, node);
1561 return rvalue(gz, rl, result, node);
1579 return rvalue(gz, ri, result, node);
15621580 }
15631581 break :array;
15641582 },
......@@ -1575,7 +1593,7 @@ fn structInitExpr(
15751593 .rhs = elem_type,
15761594 });
15771595 } else blk: {
1578 const sentinel = try comptimeExpr(gz, scope, .{ .ty = elem_type }, array_type.ast.sentinel);
1596 const sentinel = try comptimeExpr(gz, scope, .{ .rl = .{ .ty = elem_type } }, array_type.ast.sentinel);
15791597 break :blk try gz.addPlNode(
15801598 .array_type_sentinel,
15811599 struct_init.ast.type_expr,
......@@ -1587,11 +1605,11 @@ fn structInitExpr(
15871605 );
15881606 };
15891607 const result = try gz.addUnNode(.struct_init_empty, array_type_inst, node);
1590 return rvalue(gz, rl, result, node);
1608 return rvalue(gz, ri, result, node);
15911609 }
15921610 const ty_inst = try typeExpr(gz, scope, struct_init.ast.type_expr);
15931611 const result = try gz.addUnNode(.struct_init_empty, ty_inst, node);
1594 return rvalue(gz, rl, result, node);
1612 return rvalue(gz, ri, result, node);
15951613 } else {
15961614 return astgen.failNode(
15971615 struct_init.ast.type_expr,
......@@ -1601,7 +1619,7 @@ fn structInitExpr(
16011619 }
16021620 }
16031621
1604 switch (rl) {
1622 switch (ri.rl) {
16051623 .discard => {
16061624 if (struct_init.ast.type_expr != 0) {
16071625 const ty_inst = try typeExpr(gz, scope, struct_init.ast.type_expr);
......@@ -1612,7 +1630,7 @@ fn structInitExpr(
16121630 }
16131631 return Zir.Inst.Ref.void_value;
16141632 },
1615 .ref, .catch_ref => {
1633 .ref => {
16161634 if (struct_init.ast.type_expr != 0) {
16171635 const ty_inst = try typeExpr(gz, scope, struct_init.ast.type_expr);
16181636 _ = try gz.addUnNode(.validate_struct_init_ty, ty_inst, node);
......@@ -1621,7 +1639,7 @@ fn structInitExpr(
16211639 return structInitExprRlNone(gz, scope, node, struct_init, .none, .struct_init_anon_ref);
16221640 }
16231641 },
1624 .none, .catch_none => {
1642 .none => {
16251643 if (struct_init.ast.type_expr != 0) {
16261644 const ty_inst = try typeExpr(gz, scope, struct_init.ast.type_expr);
16271645 _ = try gz.addUnNode(.validate_struct_init_ty, ty_inst, node);
......@@ -1630,26 +1648,26 @@ fn structInitExpr(
16301648 return structInitExprRlNone(gz, scope, node, struct_init, .none, .struct_init_anon);
16311649 }
16321650 },
1633 .ty, .ty_shift_operand, .coerced_ty => |ty_inst| {
1651 .ty, .coerced_ty => |ty_inst| {
16341652 if (struct_init.ast.type_expr == 0) {
16351653 const result = try structInitExprRlNone(gz, scope, node, struct_init, ty_inst, .struct_init_anon);
1636 return rvalue(gz, rl, result, node);
1654 return rvalue(gz, ri, result, node);
16371655 }
16381656 const inner_ty_inst = try typeExpr(gz, scope, struct_init.ast.type_expr);
16391657 _ = try gz.addUnNode(.validate_struct_init_ty, inner_ty_inst, node);
16401658 const result = try structInitExprRlTy(gz, scope, node, struct_init, inner_ty_inst, .struct_init);
1641 return rvalue(gz, rl, result, node);
1659 return rvalue(gz, ri, result, node);
16421660 },
1643 .ptr => |ptr_res| return structInitExprRlPtr(gz, scope, rl, node, struct_init, ptr_res.inst),
1661 .ptr => |ptr_res| return structInitExprRlPtr(gz, scope, ri, node, struct_init, ptr_res.inst),
16441662 .inferred_ptr => |ptr_inst| {
16451663 if (struct_init.ast.type_expr == 0) {
16461664 // We treat this case differently so that we don't get a crash when
16471665 // analyzing field_base_ptr against an alloc_inferred_mut.
16481666 // See corresponding logic in arrayInitExpr.
16491667 const result = try structInitExprRlNone(gz, scope, node, struct_init, .none, .struct_init_anon);
1650 return rvalue(gz, rl, result, node);
1668 return rvalue(gz, ri, result, node);
16511669 } else {
1652 return structInitExprRlPtr(gz, scope, rl, node, struct_init, ptr_inst);
1670 return structInitExprRlPtr(gz, scope, ri, node, struct_init, ptr_inst);
16531671 }
16541672 },
16551673 .block_ptr => |block_gz| {
......@@ -1657,10 +1675,10 @@ fn structInitExpr(
16571675 // See corresponding logic in arrayInitExpr.
16581676 if (struct_init.ast.type_expr == 0 and astgen.isInferred(block_gz.rl_ptr)) {
16591677 const result = try structInitExprRlNone(gz, scope, node, struct_init, .none, .struct_init_anon);
1660 return rvalue(gz, rl, result, node);
1678 return rvalue(gz, ri, result, node);
16611679 }
16621680
1663 return structInitExprRlPtr(gz, scope, rl, node, struct_init, block_gz.rl_ptr);
1681 return structInitExprRlPtr(gz, scope, ri, node, struct_init, block_gz.rl_ptr);
16641682 },
16651683 }
16661684}
......@@ -1685,16 +1703,15 @@ fn structInitExprRlNone(
16851703 for (struct_init.ast.fields) |field_init| {
16861704 const name_token = tree.firstToken(field_init) - 2;
16871705 const str_index = try astgen.identAsString(name_token);
1688 const sub_rl: ResultLoc = if (ty_inst != .none)
1689 ResultLoc{ .ty = try gz.addPlNode(.field_type, field_init, Zir.Inst.FieldType{
1706 const sub_ri: ResultInfo = if (ty_inst != .none)
1707 ResultInfo{ .rl = .{ .ty = try gz.addPlNode(.field_type, field_init, Zir.Inst.FieldType{
16901708 .container_type = ty_inst,
16911709 .name_start = str_index,
1692 }) }
1693 else
1694 .none;
1710 }) } }
1711 else .{ .rl = .none };
16951712 setExtra(astgen, extra_index, Zir.Inst.StructInitAnon.Item{
16961713 .field_name = str_index,
1697 .init = try expr(gz, scope, sub_rl, field_init),
1714 .init = try expr(gz, scope, sub_ri, field_init),
16981715 });
16991716 extra_index += field_size;
17001717 }
......@@ -1705,7 +1722,7 @@ fn structInitExprRlNone(
17051722fn structInitExprRlPtr(
17061723 gz: *GenZir,
17071724 scope: *Scope,
1708 rl: ResultLoc,
1725 ri: ResultInfo,
17091726 node: Ast.Node.Index,
17101727 struct_init: Ast.full.StructInit,
17111728 result_ptr: Zir.Inst.Ref,
......@@ -1721,7 +1738,7 @@ fn structInitExprRlPtr(
17211738 defer as_scope.unstack();
17221739
17231740 const result = try structInitExprRlPtrInner(&as_scope, scope, node, struct_init, as_scope.rl_ptr);
1724 return as_scope.finishCoercion(gz, rl, node, result, ty_inst);
1741 return as_scope.finishCoercion(gz, ri, node, result, ty_inst);
17251742}
17261743
17271744fn structInitExprRlPtrInner(
......@@ -1748,7 +1765,7 @@ fn structInitExprRlPtrInner(
17481765 });
17491766 astgen.extra.items[extra_index] = refToIndex(field_ptr).?;
17501767 extra_index += 1;
1751 _ = try expr(gz, scope, .{ .ptr = .{ .inst = field_ptr } }, field_init);
1768 _ = try expr(gz, scope, .{ .rl = .{ .ptr = .{ .inst = field_ptr } } }, field_init);
17521769 }
17531770
17541771 const tag: Zir.Inst.Tag = if (gz.force_comptime)
......@@ -1786,7 +1803,7 @@ fn structInitExprRlTy(
17861803 });
17871804 setExtra(astgen, extra_index, Zir.Inst.StructInit.Item{
17881805 .field_type = refToIndex(field_ty_inst).?,
1789 .init = try expr(gz, scope, .{ .ty = field_ty_inst }, field_init),
1806 .init = try expr(gz, scope, .{ .rl = .{ .ty = field_ty_inst } }, field_init),
17901807 });
17911808 extra_index += field_size;
17921809 }
......@@ -1799,14 +1816,14 @@ fn structInitExprRlTy(
17991816fn comptimeExpr(
18001817 gz: *GenZir,
18011818 scope: *Scope,
1802 rl: ResultLoc,
1819 ri: ResultInfo,
18031820 node: Ast.Node.Index,
18041821) InnerError!Zir.Inst.Ref {
18051822 const prev_force_comptime = gz.force_comptime;
18061823 gz.force_comptime = true;
18071824 defer gz.force_comptime = prev_force_comptime;
18081825
1809 return expr(gz, scope, rl, node);
1826 return expr(gz, scope, ri, node);
18101827}
18111828
18121829/// This one is for an actual `comptime` syntax, and will emit a compile error if
......@@ -1815,7 +1832,7 @@ fn comptimeExpr(
18151832fn comptimeExprAst(
18161833 gz: *GenZir,
18171834 scope: *Scope,
1818 rl: ResultLoc,
1835 ri: ResultInfo,
18191836 node: Ast.Node.Index,
18201837) InnerError!Zir.Inst.Ref {
18211838 const astgen = gz.astgen;
......@@ -1826,7 +1843,7 @@ fn comptimeExprAst(
18261843 const node_datas = tree.nodes.items(.data);
18271844 const body_node = node_datas[node].lhs;
18281845 gz.force_comptime = true;
1829 const result = try expr(gz, scope, rl, body_node);
1846 const result = try expr(gz, scope, ri, body_node);
18301847 gz.force_comptime = false;
18311848 return result;
18321849}
......@@ -1904,7 +1921,7 @@ fn breakExpr(parent_gz: *GenZir, parent_scope: *Scope, node: Ast.Node.Index) Inn
19041921 }
19051922 block_gz.break_count += 1;
19061923
1907 const operand = try reachableExpr(parent_gz, parent_scope, block_gz.break_result_loc, rhs, node);
1924 const operand = try reachableExpr(parent_gz, parent_scope, block_gz.break_result_info, rhs, node);
19081925 const search_index = @intCast(Zir.Inst.Index, astgen.instructions.len);
19091926
19101927 try genDefers(parent_gz, scope, parent_scope, .normal_only);
......@@ -1915,14 +1932,14 @@ fn breakExpr(parent_gz: *GenZir, parent_scope: *Scope, node: Ast.Node.Index) Inn
19151932 try popErrorReturnTrace(
19161933 parent_gz,
19171934 scope,
1918 block_gz.break_result_loc,
1935 block_gz.break_result_info,
19191936 rhs,
19201937 operand,
19211938 err_trace_index_to_restore,
19221939 );
19231940 }
19241941
1925 switch (block_gz.break_result_loc) {
1942 switch (block_gz.break_result_info.rl) {
19261943 .block_ptr => {
19271944 const br = try parent_gz.addBreak(break_tag, block_inst, operand);
19281945 try block_gz.labeled_breaks.append(astgen.gpa, .{ .br = br, .search = search_index });
......@@ -2028,7 +2045,7 @@ fn continueExpr(parent_gz: *GenZir, parent_scope: *Scope, node: Ast.Node.Index)
20282045fn blockExpr(
20292046 gz: *GenZir,
20302047 scope: *Scope,
2031 rl: ResultLoc,
2048 ri: ResultInfo,
20322049 block_node: Ast.Node.Index,
20332050 statements: []const Ast.Node.Index,
20342051) InnerError!Zir.Inst.Ref {
......@@ -2044,12 +2061,12 @@ fn blockExpr(
20442061 if (token_tags[lbrace - 1] == .colon and
20452062 token_tags[lbrace - 2] == .identifier)
20462063 {
2047 return labeledBlockExpr(gz, scope, rl, block_node, statements);
2064 return labeledBlockExpr(gz, scope, ri, block_node, statements);
20482065 }
20492066
20502067 var sub_gz = gz.makeSubBlock(scope);
20512068 try blockExprStmts(&sub_gz, &sub_gz.base, statements);
2052 return rvalue(gz, rl, .void_value, block_node);
2069 return rvalue(gz, ri, .void_value, block_node);
20532070}
20542071
20552072fn checkLabelRedefinition(astgen: *AstGen, parent_scope: *Scope, label: Ast.TokenIndex) !void {
......@@ -2087,7 +2104,7 @@ fn checkLabelRedefinition(astgen: *AstGen, parent_scope: *Scope, label: Ast.Toke
20872104fn labeledBlockExpr(
20882105 gz: *GenZir,
20892106 parent_scope: *Scope,
2090 rl: ResultLoc,
2107 ri: ResultInfo,
20912108 block_node: Ast.Node.Index,
20922109 statements: []const Ast.Node.Index,
20932110) InnerError!Zir.Inst.Ref {
......@@ -2116,7 +2133,7 @@ fn labeledBlockExpr(
21162133 .token = label_token,
21172134 .block_inst = block_inst,
21182135 };
2119 block_scope.setBreakResultLoc(rl);
2136 block_scope.setBreakResultInfo(ri);
21202137 defer block_scope.unstack();
21212138 defer block_scope.labeled_breaks.deinit(astgen.gpa);
21222139
......@@ -2132,7 +2149,7 @@ fn labeledBlockExpr(
21322149
21332150 const zir_datas = gz.astgen.instructions.items(.data);
21342151 const zir_tags = gz.astgen.instructions.items(.tag);
2135 const strat = rl.strategy(&block_scope);
2152 const strat = ri.rl.strategy(&block_scope);
21362153 switch (strat.tag) {
21372154 .break_void => {
21382155 // The code took advantage of the result location as a pointer.
......@@ -2173,9 +2190,9 @@ fn labeledBlockExpr(
21732190 }
21742191 try block_scope.setBlockBody(block_inst);
21752192 const block_ref = indexToRef(block_inst);
2176 switch (rl) {
2177 .ref, .catch_ref => return block_ref,
2178 else => return rvalue(gz, rl, block_ref, block_node),
2193 switch (ri.rl) {
2194 .ref => return block_ref,
2195 else => return rvalue(gz, ri, block_ref, block_node),
21792196 }
21802197 },
21812198 }
......@@ -2246,12 +2263,12 @@ fn blockExprStmts(gz: *GenZir, parent_scope: *Scope, statements: []const Ast.Nod
22462263 continue;
22472264 },
22482265
2249 .while_simple => _ = try whileExpr(gz, scope, .discard, inner_node, tree.whileSimple(inner_node), true),
2250 .while_cont => _ = try whileExpr(gz, scope, .discard, inner_node, tree.whileCont(inner_node), true),
2251 .@"while" => _ = try whileExpr(gz, scope, .discard, inner_node, tree.whileFull(inner_node), true),
2266 .while_simple => _ = try whileExpr(gz, scope, .{ .rl = .discard }, inner_node, tree.whileSimple(inner_node), true),
2267 .while_cont => _ = try whileExpr(gz, scope, .{ .rl = .discard }, inner_node, tree.whileCont(inner_node), true),
2268 .@"while" => _ = try whileExpr(gz, scope, .{ .rl = .discard }, inner_node, tree.whileFull(inner_node), true),
22522269
2253 .for_simple => _ = try forExpr(gz, scope, .discard, inner_node, tree.forSimple(inner_node), true),
2254 .@"for" => _ = try forExpr(gz, scope, .discard, inner_node, tree.forFull(inner_node), true),
2270 .for_simple => _ = try forExpr(gz, scope, .{ .rl = .discard }, inner_node, tree.forSimple(inner_node), true),
2271 .@"for" => _ = try forExpr(gz, scope, .{ .rl = .discard }, inner_node, tree.forFull(inner_node), true),
22552272
22562273 else => noreturn_src_node = try unusedResultExpr(gz, scope, inner_node),
22572274 // zig fmt: on
......@@ -2272,7 +2289,7 @@ fn unusedResultExpr(gz: *GenZir, scope: *Scope, statement: Ast.Node.Index) Inner
22722289 try emitDbgNode(gz, statement);
22732290 // We need to emit an error if the result is not `noreturn` or `void`, but
22742291 // we want to avoid adding the ZIR instruction if possible for performance.
2275 const maybe_unused_result = try expr(gz, scope, .none, statement);
2292 const maybe_unused_result = try expr(gz, scope, .{ .rl = .none }, statement);
22762293 return addEnsureResult(gz, maybe_unused_result, statement);
22772294}
22782295
......@@ -2839,7 +2856,7 @@ fn varDecl(
28392856 }
28402857
28412858 const align_inst: Zir.Inst.Ref = if (var_decl.ast.align_node != 0)
2842 try expr(gz, scope, align_rl, var_decl.ast.align_node)
2859 try expr(gz, scope, align_ri, var_decl.ast.align_node)
28432860 else
28442861 .none;
28452862
......@@ -2856,12 +2873,12 @@ fn varDecl(
28562873 if (align_inst == .none and
28572874 !nodeMayNeedMemoryLocation(tree, var_decl.ast.init_node, type_node != 0))
28582875 {
2859 const result_loc: ResultLoc = if (type_node != 0) .{
2860 .ty = try typeExpr(gz, scope, type_node),
2861 } else .none;
2876 const result_info: ResultInfo = if (type_node != 0) .{
2877 .rl = .{ .ty = try typeExpr(gz, scope, type_node) },
2878 } else .{ .rl = .none };
28622879 const prev_anon_name_strategy = gz.anon_name_strategy;
28632880 gz.anon_name_strategy = .dbg_var;
2864 const init_inst = try reachableExpr(gz, scope, result_loc, var_decl.ast.init_node, node);
2881 const init_inst = try reachableExpr(gz, scope, result_info, var_decl.ast.init_node, node);
28652882 gz.anon_name_strategy = prev_anon_name_strategy;
28662883
28672884 try gz.addDbgVar(.dbg_var_val, ident_name, init_inst);
......@@ -2931,8 +2948,8 @@ fn varDecl(
29312948 init_scope.rl_ptr = alloc;
29322949 init_scope.rl_ty_inst = .none;
29332950 }
2934 const init_result_loc: ResultLoc = .{ .block_ptr = &init_scope };
2935 const init_inst = try reachableExpr(&init_scope, &init_scope.base, init_result_loc, var_decl.ast.init_node, node);
2951 const init_result_info: ResultInfo = .{ .rl = .{ .block_ptr = &init_scope } };
2952 const init_inst = try reachableExpr(&init_scope, &init_scope.base, init_result_info, var_decl.ast.init_node, node);
29362953
29372954 const zir_tags = astgen.instructions.items(.tag);
29382955 const zir_datas = astgen.instructions.items(.data);
......@@ -3021,7 +3038,7 @@ fn varDecl(
30213038 const is_comptime = var_decl.comptime_token != null or gz.force_comptime;
30223039 var resolve_inferred_alloc: Zir.Inst.Ref = .none;
30233040 const var_data: struct {
3024 result_loc: ResultLoc,
3041 result_info: ResultInfo,
30253042 alloc: Zir.Inst.Ref,
30263043 } = if (var_decl.ast.type_node != 0) a: {
30273044 const type_inst = try typeExpr(gz, scope, var_decl.ast.type_node);
......@@ -3043,7 +3060,7 @@ fn varDecl(
30433060 }
30443061 };
30453062 gz.rl_ty_inst = type_inst;
3046 break :a .{ .alloc = alloc, .result_loc = .{ .ptr = .{ .inst = alloc } } };
3063 break :a .{ .alloc = alloc, .result_info = .{ .rl = .{ .ptr = .{ .inst = alloc } } } };
30473064 } else a: {
30483065 const alloc = alloc: {
30493066 if (align_inst == .none) {
......@@ -3064,11 +3081,11 @@ fn varDecl(
30643081 };
30653082 gz.rl_ty_inst = .none;
30663083 resolve_inferred_alloc = alloc;
3067 break :a .{ .alloc = alloc, .result_loc = .{ .inferred_ptr = alloc } };
3084 break :a .{ .alloc = alloc, .result_info = .{ .rl = .{ .inferred_ptr = alloc } } };
30683085 };
30693086 const prev_anon_name_strategy = gz.anon_name_strategy;
30703087 gz.anon_name_strategy = .dbg_var;
3071 _ = try reachableExprComptime(gz, scope, var_data.result_loc, var_decl.ast.init_node, node, is_comptime);
3088 _ = try reachableExprComptime(gz, scope, var_data.result_info, var_decl.ast.init_node, node, is_comptime);
30723089 gz.anon_name_strategy = prev_anon_name_strategy;
30733090 if (resolve_inferred_alloc != .none) {
30743091 _ = try gz.addUnNode(.resolve_inferred_alloc, resolve_inferred_alloc, node);
......@@ -3138,15 +3155,15 @@ fn assign(gz: *GenZir, scope: *Scope, infix_node: Ast.Node.Index) InnerError!voi
31383155 // This intentionally does not support `@"_"` syntax.
31393156 const ident_name = tree.tokenSlice(main_tokens[lhs]);
31403157 if (mem.eql(u8, ident_name, "_")) {
3141 _ = try expr(gz, scope, .discard, rhs);
3158 _ = try expr(gz, scope, .{ .rl = .discard }, rhs);
31423159 return;
31433160 }
31443161 }
31453162 const lvalue = try lvalExpr(gz, scope, lhs);
3146 _ = try expr(gz, scope, .{ .ptr = .{
3163 _ = try expr(gz, scope, .{ .rl = .{ .ptr = .{
31473164 .inst = lvalue,
31483165 .src_node = infix_node,
3149 } }, rhs);
3166 } } }, rhs);
31503167}
31513168
31523169fn assignOp(
......@@ -3163,7 +3180,7 @@ fn assignOp(
31633180 const lhs_ptr = try lvalExpr(gz, scope, node_datas[infix_node].lhs);
31643181 const lhs = try gz.addUnNode(.load, lhs_ptr, infix_node);
31653182 const lhs_type = try gz.addUnNode(.typeof, lhs, infix_node);
3166 const rhs = try expr(gz, scope, .{ .coerced_ty = lhs_type }, node_datas[infix_node].rhs);
3183 const rhs = try expr(gz, scope, .{ .rl = .{ .coerced_ty = lhs_type } }, node_datas[infix_node].rhs);
31673184
31683185 const result = try gz.addPlNode(op_inst_tag, infix_node, Zir.Inst.Bin{
31693186 .lhs = lhs,
......@@ -3186,7 +3203,7 @@ fn assignShift(
31863203 const lhs_ptr = try lvalExpr(gz, scope, node_datas[infix_node].lhs);
31873204 const lhs = try gz.addUnNode(.load, lhs_ptr, infix_node);
31883205 const rhs_type = try gz.addUnNode(.typeof_log2_int_type, lhs, infix_node);
3189 const rhs = try expr(gz, scope, .{ .ty = rhs_type }, node_datas[infix_node].rhs);
3206 const rhs = try expr(gz, scope, .{ .rl = .{ .ty = rhs_type } }, node_datas[infix_node].rhs);
31903207
31913208 const result = try gz.addPlNode(op_inst_tag, infix_node, Zir.Inst.Bin{
31923209 .lhs = lhs,
......@@ -3204,7 +3221,7 @@ fn assignShiftSat(gz: *GenZir, scope: *Scope, infix_node: Ast.Node.Index) InnerE
32043221 const lhs_ptr = try lvalExpr(gz, scope, node_datas[infix_node].lhs);
32053222 const lhs = try gz.addUnNode(.load, lhs_ptr, infix_node);
32063223 // Saturating shift-left allows any integer type for both the LHS and RHS.
3207 const rhs = try expr(gz, scope, .none, node_datas[infix_node].rhs);
3224 const rhs = try expr(gz, scope, .{ .rl = .none }, node_datas[infix_node].rhs);
32083225
32093226 const result = try gz.addPlNode(.shl_sat, infix_node, Zir.Inst.Bin{
32103227 .lhs = lhs,
......@@ -3216,7 +3233,7 @@ fn assignShiftSat(gz: *GenZir, scope: *Scope, infix_node: Ast.Node.Index) InnerE
32163233fn ptrType(
32173234 gz: *GenZir,
32183235 scope: *Scope,
3219 rl: ResultLoc,
3236 ri: ResultInfo,
32203237 node: Ast.Node.Index,
32213238 ptr_info: Ast.full.PtrType,
32223239) InnerError!Zir.Inst.Ref {
......@@ -3234,21 +3251,21 @@ fn ptrType(
32343251 var trailing_count: u32 = 0;
32353252
32363253 if (ptr_info.ast.sentinel != 0) {
3237 sentinel_ref = try expr(gz, scope, .{ .ty = elem_type }, ptr_info.ast.sentinel);
3254 sentinel_ref = try expr(gz, scope, .{ .rl = .{ .ty = elem_type } }, ptr_info.ast.sentinel);
32383255 trailing_count += 1;
32393256 }
32403257 if (ptr_info.ast.align_node != 0) {
3241 align_ref = try expr(gz, scope, coerced_align_rl, ptr_info.ast.align_node);
3258 align_ref = try expr(gz, scope, coerced_align_ri, ptr_info.ast.align_node);
32423259 trailing_count += 1;
32433260 }
32443261 if (ptr_info.ast.addrspace_node != 0) {
3245 addrspace_ref = try expr(gz, scope, .{ .ty = .address_space_type }, ptr_info.ast.addrspace_node);
3262 addrspace_ref = try expr(gz, scope, .{ .rl = .{ .ty = .address_space_type } }, ptr_info.ast.addrspace_node);
32463263 trailing_count += 1;
32473264 }
32483265 if (ptr_info.ast.bit_range_start != 0) {
32493266 assert(ptr_info.ast.bit_range_end != 0);
3250 bit_start_ref = try expr(gz, scope, .{ .coerced_ty = .u16_type }, ptr_info.ast.bit_range_start);
3251 bit_end_ref = try expr(gz, scope, .{ .coerced_ty = .u16_type }, ptr_info.ast.bit_range_end);
3267 bit_start_ref = try expr(gz, scope, .{ .rl = .{ .coerced_ty = .u16_type } }, ptr_info.ast.bit_range_start);
3268 bit_end_ref = try expr(gz, scope, .{ .rl = .{ .coerced_ty = .u16_type } }, ptr_info.ast.bit_range_end);
32523269 trailing_count += 2;
32533270 }
32543271
......@@ -3295,10 +3312,10 @@ fn ptrType(
32953312 } });
32963313 gz.instructions.appendAssumeCapacity(new_index);
32973314
3298 return rvalue(gz, rl, result, node);
3315 return rvalue(gz, ri, result, node);
32993316}
33003317
3301fn arrayType(gz: *GenZir, scope: *Scope, rl: ResultLoc, node: Ast.Node.Index) !Zir.Inst.Ref {
3318fn arrayType(gz: *GenZir, scope: *Scope, ri: ResultInfo, node: Ast.Node.Index) !Zir.Inst.Ref {
33023319 const astgen = gz.astgen;
33033320 const tree = astgen.tree;
33043321 const node_datas = tree.nodes.items(.data);
......@@ -3311,17 +3328,17 @@ fn arrayType(gz: *GenZir, scope: *Scope, rl: ResultLoc, node: Ast.Node.Index) !Z
33113328 {
33123329 return astgen.failNode(len_node, "unable to infer array size", .{});
33133330 }
3314 const len = try expr(gz, scope, .{ .coerced_ty = .usize_type }, len_node);
3331 const len = try expr(gz, scope, .{ .rl = .{ .coerced_ty = .usize_type } }, len_node);
33153332 const elem_type = try typeExpr(gz, scope, node_datas[node].rhs);
33163333
33173334 const result = try gz.addPlNode(.array_type, node, Zir.Inst.Bin{
33183335 .lhs = len,
33193336 .rhs = elem_type,
33203337 });
3321 return rvalue(gz, rl, result, node);
3338 return rvalue(gz, ri, result, node);
33223339}
33233340
3324fn arrayTypeSentinel(gz: *GenZir, scope: *Scope, rl: ResultLoc, node: Ast.Node.Index) !Zir.Inst.Ref {
3341fn arrayTypeSentinel(gz: *GenZir, scope: *Scope, ri: ResultInfo, node: Ast.Node.Index) !Zir.Inst.Ref {
33253342 const astgen = gz.astgen;
33263343 const tree = astgen.tree;
33273344 const node_datas = tree.nodes.items(.data);
......@@ -3335,16 +3352,16 @@ fn arrayTypeSentinel(gz: *GenZir, scope: *Scope, rl: ResultLoc, node: Ast.Node.I
33353352 {
33363353 return astgen.failNode(len_node, "unable to infer array size", .{});
33373354 }
3338 const len = try reachableExpr(gz, scope, .{ .coerced_ty = .usize_type }, len_node, node);
3355 const len = try reachableExpr(gz, scope, .{ .rl = .{ .coerced_ty = .usize_type } }, len_node, node);
33393356 const elem_type = try typeExpr(gz, scope, extra.elem_type);
3340 const sentinel = try reachableExpr(gz, scope, .{ .coerced_ty = elem_type }, extra.sentinel, node);
3357 const sentinel = try reachableExpr(gz, scope, .{ .rl = .{ .coerced_ty = elem_type } }, extra.sentinel, node);
33413358
33423359 const result = try gz.addPlNode(.array_type_sentinel, node, Zir.Inst.ArrayTypeSentinel{
33433360 .len = len,
33443361 .elem_type = elem_type,
33453362 .sentinel = sentinel,
33463363 });
3347 return rvalue(gz, rl, result, node);
3364 return rvalue(gz, ri, result, node);
33483365}
33493366
33503367const WipMembers = struct {
......@@ -3580,7 +3597,7 @@ fn fnDecl(
35803597 assert(param_type_node != 0);
35813598 var param_gz = decl_gz.makeSubBlock(scope);
35823599 defer param_gz.unstack();
3583 const param_type = try expr(&param_gz, params_scope, coerced_type_rl, param_type_node);
3600 const param_type = try expr(&param_gz, params_scope, coerced_type_ri, param_type_node);
35843601 const param_inst_expected = @intCast(u32, astgen.instructions.len + 1);
35853602 _ = try param_gz.addBreak(.break_inline, param_inst_expected, param_type);
35863603
......@@ -3629,7 +3646,7 @@ fn fnDecl(
36293646 var align_gz = decl_gz.makeSubBlock(params_scope);
36303647 defer align_gz.unstack();
36313648 const align_ref: Zir.Inst.Ref = if (fn_proto.ast.align_expr == 0) .none else inst: {
3632 const inst = try expr(&decl_gz, params_scope, coerced_align_rl, fn_proto.ast.align_expr);
3649 const inst = try expr(&decl_gz, params_scope, coerced_align_ri, fn_proto.ast.align_expr);
36333650 if (align_gz.instructionsSlice().len == 0) {
36343651 // In this case we will send a len=0 body which can be encoded more efficiently.
36353652 break :inst inst;
......@@ -3641,7 +3658,7 @@ fn fnDecl(
36413658 var addrspace_gz = decl_gz.makeSubBlock(params_scope);
36423659 defer addrspace_gz.unstack();
36433660 const addrspace_ref: Zir.Inst.Ref = if (fn_proto.ast.addrspace_expr == 0) .none else inst: {
3644 const inst = try expr(&decl_gz, params_scope, .{ .coerced_ty = .address_space_type }, fn_proto.ast.addrspace_expr);
3661 const inst = try expr(&decl_gz, params_scope, .{ .rl = .{ .coerced_ty = .address_space_type } }, fn_proto.ast.addrspace_expr);
36453662 if (addrspace_gz.instructionsSlice().len == 0) {
36463663 // In this case we will send a len=0 body which can be encoded more efficiently.
36473664 break :inst inst;
......@@ -3653,7 +3670,7 @@ fn fnDecl(
36533670 var section_gz = decl_gz.makeSubBlock(params_scope);
36543671 defer section_gz.unstack();
36553672 const section_ref: Zir.Inst.Ref = if (fn_proto.ast.section_expr == 0) .none else inst: {
3656 const inst = try expr(&decl_gz, params_scope, .{ .coerced_ty = .const_slice_u8_type }, fn_proto.ast.section_expr);
3673 const inst = try expr(&decl_gz, params_scope, .{ .rl = .{ .coerced_ty = .const_slice_u8_type } }, fn_proto.ast.section_expr);
36573674 if (section_gz.instructionsSlice().len == 0) {
36583675 // In this case we will send a len=0 body which can be encoded more efficiently.
36593676 break :inst inst;
......@@ -3676,7 +3693,7 @@ fn fnDecl(
36763693 const inst = try expr(
36773694 &decl_gz,
36783695 params_scope,
3679 .{ .coerced_ty = .calling_convention_type },
3696 .{ .rl = .{ .coerced_ty = .calling_convention_type } },
36803697 fn_proto.ast.callconv_expr,
36813698 );
36823699 if (cc_gz.instructionsSlice().len == 0) {
......@@ -3698,7 +3715,7 @@ fn fnDecl(
36983715 var ret_gz = decl_gz.makeSubBlock(params_scope);
36993716 defer ret_gz.unstack();
37003717 const ret_ref: Zir.Inst.Ref = inst: {
3701 const inst = try expr(&ret_gz, params_scope, coerced_type_rl, fn_proto.ast.return_type);
3718 const inst = try expr(&ret_gz, params_scope, coerced_type_ri, fn_proto.ast.return_type);
37023719 if (ret_gz.instructionsSlice().len == 0) {
37033720 // In this case we will send a len=0 body which can be encoded more efficiently.
37043721 break :inst inst;
......@@ -3752,7 +3769,7 @@ fn fnDecl(
37523769 const lbrace_line = astgen.source_line - decl_gz.decl_line;
37533770 const lbrace_column = astgen.source_column;
37543771
3755 _ = try expr(&fn_gz, params_scope, .none, body_node);
3772 _ = try expr(&fn_gz, params_scope, .{ .rl = .none }, body_node);
37563773 try checkUsed(gz, &fn_gz.base, params_scope);
37573774
37583775 if (!fn_gz.endsWithNoReturn()) {
......@@ -3848,13 +3865,13 @@ fn globalVarDecl(
38483865 break :blk token_tags[maybe_extern_token] == .keyword_extern;
38493866 };
38503867 const align_inst: Zir.Inst.Ref = if (var_decl.ast.align_node == 0) .none else inst: {
3851 break :inst try expr(&block_scope, &block_scope.base, align_rl, var_decl.ast.align_node);
3868 break :inst try expr(&block_scope, &block_scope.base, align_ri, var_decl.ast.align_node);
38523869 };
38533870 const addrspace_inst: Zir.Inst.Ref = if (var_decl.ast.addrspace_node == 0) .none else inst: {
3854 break :inst try expr(&block_scope, &block_scope.base, .{ .ty = .address_space_type }, var_decl.ast.addrspace_node);
3871 break :inst try expr(&block_scope, &block_scope.base, .{ .rl = .{ .ty = .address_space_type } }, var_decl.ast.addrspace_node);
38553872 };
38563873 const section_inst: Zir.Inst.Ref = if (var_decl.ast.section_node == 0) .none else inst: {
3857 break :inst try comptimeExpr(&block_scope, &block_scope.base, .{ .ty = .const_slice_u8_type }, var_decl.ast.section_node);
3874 break :inst try comptimeExpr(&block_scope, &block_scope.base, .{ .rl = .{ .ty = .const_slice_u8_type } }, var_decl.ast.section_node);
38583875 };
38593876 const has_section_or_addrspace = section_inst != .none or addrspace_inst != .none;
38603877 wip_members.nextDecl(is_pub, is_export, align_inst != .none, has_section_or_addrspace);
......@@ -3894,7 +3911,7 @@ fn globalVarDecl(
38943911 try expr(
38953912 &block_scope,
38963913 &block_scope.base,
3897 .{ .ty = .type_type },
3914 .{ .rl = .{ .ty = .type_type } },
38983915 var_decl.ast.type_node,
38993916 )
39003917 else
......@@ -3903,7 +3920,7 @@ fn globalVarDecl(
39033920 const init_inst = try expr(
39043921 &block_scope,
39053922 &block_scope.base,
3906 if (type_inst != .none) .{ .ty = type_inst } else .none,
3923 if (type_inst != .none) .{ .rl = .{ .ty = type_inst } } else .{ .rl = .none },
39073924 var_decl.ast.init_node,
39083925 );
39093926
......@@ -3992,7 +4009,7 @@ fn comptimeDecl(
39924009 };
39934010 defer decl_block.unstack();
39944011
3995 const block_result = try expr(&decl_block, &decl_block.base, .none, body_node);
4012 const block_result = try expr(&decl_block, &decl_block.base, .{ .rl = .none }, body_node);
39964013 if (decl_block.isEmpty() or !decl_block.refIsNoReturn(block_result)) {
39974014 _ = try decl_block.addBreak(.break_inline, block_inst, .void_value);
39984015 }
......@@ -4196,7 +4213,7 @@ fn testDecl(
41964213 const lbrace_line = astgen.source_line - decl_block.decl_line;
41974214 const lbrace_column = astgen.source_column;
41984215
4199 const block_result = try expr(&fn_block, &fn_block.base, .none, body_node);
4216 const block_result = try expr(&fn_block, &fn_block.base, .{ .rl = .none }, body_node);
42004217 if (fn_block.isEmpty() or !fn_block.refIsNoReturn(block_result)) {
42014218 // Since we are adding the return instruction here, we must handle the coercion.
42024219 // We do this by using the `ret_tok` instruction.
......@@ -4410,7 +4427,7 @@ fn structDeclInner(
44104427 if (layout == .Packed) {
44114428 try astgen.appendErrorNode(member.ast.align_expr, "unable to override alignment of packed struct fields", .{});
44124429 }
4413 const align_ref = try expr(&block_scope, &namespace.base, coerced_align_rl, member.ast.align_expr);
4430 const align_ref = try expr(&block_scope, &namespace.base, coerced_align_ri, member.ast.align_expr);
44144431 if (!block_scope.endsWithNoReturn()) {
44154432 _ = try block_scope.addBreak(.break_inline, decl_inst, align_ref);
44164433 }
......@@ -4423,9 +4440,9 @@ fn structDeclInner(
44234440 }
44244441
44254442 if (have_value) {
4426 const rl: ResultLoc = if (field_type == .none) .none else .{ .coerced_ty = field_type };
4443 const ri: ResultInfo = .{ .rl = if (field_type == .none) .none else .{ .coerced_ty = field_type } };
44274444
4428 const default_inst = try expr(&block_scope, &namespace.base, rl, member.ast.value_expr);
4445 const default_inst = try expr(&block_scope, &namespace.base, ri, member.ast.value_expr);
44294446 if (!block_scope.endsWithNoReturn()) {
44304447 _ = try block_scope.addBreak(.break_inline, decl_inst, default_inst);
44314448 }
......@@ -4554,7 +4571,7 @@ fn unionDeclInner(
45544571 return astgen.failNode(member_node, "union field missing type", .{});
45554572 }
45564573 if (have_align) {
4557 const align_inst = try expr(&block_scope, &block_scope.base, .{ .ty = .u32_type }, member.ast.align_expr);
4574 const align_inst = try expr(&block_scope, &block_scope.base, .{ .rl = .{ .ty = .u32_type } }, member.ast.align_expr);
45584575 wip_members.appendToField(@enumToInt(align_inst));
45594576 }
45604577 if (have_value) {
......@@ -4586,7 +4603,7 @@ fn unionDeclInner(
45864603 },
45874604 );
45884605 }
4589 const tag_value = try expr(&block_scope, &block_scope.base, .{ .ty = arg_inst }, member.ast.value_expr);
4606 const tag_value = try expr(&block_scope, &block_scope.base, .{ .rl = .{ .ty = arg_inst } }, member.ast.value_expr);
45904607 wip_members.appendToField(@enumToInt(tag_value));
45914608 }
45924609 }
......@@ -4624,7 +4641,7 @@ fn unionDeclInner(
46244641fn containerDecl(
46254642 gz: *GenZir,
46264643 scope: *Scope,
4627 rl: ResultLoc,
4644 ri: ResultInfo,
46284645 node: Ast.Node.Index,
46294646 container_decl: Ast.full.ContainerDecl,
46304647) InnerError!Zir.Inst.Ref {
......@@ -4650,7 +4667,7 @@ fn containerDecl(
46504667 } else std.builtin.Type.ContainerLayout.Auto;
46514668
46524669 const result = try structDeclInner(gz, scope, node, container_decl, layout, container_decl.ast.arg);
4653 return rvalue(gz, rl, result, node);
4670 return rvalue(gz, ri, result, node);
46544671 },
46554672 .keyword_union => {
46564673 const layout = if (container_decl.layout_token) |t| switch (token_tags[t]) {
......@@ -4660,7 +4677,7 @@ fn containerDecl(
46604677 } else std.builtin.Type.ContainerLayout.Auto;
46614678
46624679 const result = try unionDeclInner(gz, scope, node, container_decl.ast.members, layout, container_decl.ast.arg, container_decl.ast.enum_token);
4663 return rvalue(gz, rl, result, node);
4680 return rvalue(gz, ri, result, node);
46644681 },
46654682 .keyword_enum => {
46664683 if (container_decl.layout_token) |t| {
......@@ -4790,7 +4807,7 @@ fn containerDecl(
47904807 _ = try astgen.scanDecls(&namespace, container_decl.ast.members);
47914808
47924809 const arg_inst: Zir.Inst.Ref = if (container_decl.ast.arg != 0)
4793 try comptimeExpr(&block_scope, &namespace.base, .{ .ty = .type_type }, container_decl.ast.arg)
4810 try comptimeExpr(&block_scope, &namespace.base, .{ .rl = .{ .ty = .type_type } }, container_decl.ast.arg)
47944811 else
47954812 .none;
47964813
......@@ -4834,7 +4851,7 @@ fn containerDecl(
48344851 },
48354852 );
48364853 }
4837 const tag_value_inst = try expr(&block_scope, &namespace.base, .{ .ty = arg_inst }, member.ast.value_expr);
4854 const tag_value_inst = try expr(&block_scope, &namespace.base, .{ .rl = .{ .ty = arg_inst } }, member.ast.value_expr);
48384855 wip_members.appendToField(@enumToInt(tag_value_inst));
48394856 }
48404857 }
......@@ -4865,7 +4882,7 @@ fn containerDecl(
48654882
48664883 block_scope.unstack();
48674884 try gz.addNamespaceCaptures(&namespace);
4868 return rvalue(gz, rl, indexToRef(decl_inst), node);
4885 return rvalue(gz, ri, indexToRef(decl_inst), node);
48694886 },
48704887 .keyword_opaque => {
48714888 assert(container_decl.ast.arg == 0);
......@@ -4915,7 +4932,7 @@ fn containerDecl(
49154932 astgen.extra.appendSliceAssumeCapacity(decls_slice);
49164933
49174934 try gz.addNamespaceCaptures(&namespace);
4918 return rvalue(gz, rl, indexToRef(decl_inst), node);
4935 return rvalue(gz, ri, indexToRef(decl_inst), node);
49194936 },
49204937 else => unreachable,
49214938 }
......@@ -5046,7 +5063,7 @@ fn containerMember(
50465063 return .decl;
50475064}
50485065
5049fn errorSetDecl(gz: *GenZir, rl: ResultLoc, node: Ast.Node.Index) InnerError!Zir.Inst.Ref {
5066fn errorSetDecl(gz: *GenZir, ri: ResultInfo, node: Ast.Node.Index) InnerError!Zir.Inst.Ref {
50505067 const astgen = gz.astgen;
50515068 const gpa = astgen.gpa;
50525069 const tree = astgen.tree;
......@@ -5101,13 +5118,13 @@ fn errorSetDecl(gz: *GenZir, rl: ResultLoc, node: Ast.Node.Index) InnerError!Zir
51015118 .fields_len = @intCast(u32, fields_len),
51025119 });
51035120 const result = try gz.addPlNodePayloadIndex(.error_set_decl, node, payload_index);
5104 return rvalue(gz, rl, result, node);
5121 return rvalue(gz, ri, result, node);
51055122}
51065123
51075124fn tryExpr(
51085125 parent_gz: *GenZir,
51095126 scope: *Scope,
5110 rl: ResultLoc,
5127 ri: ResultInfo,
51115128 node: Ast.Node.Index,
51125129 operand_node: Ast.Node.Index,
51135130) InnerError!Zir.Inst.Ref {
......@@ -5137,15 +5154,15 @@ fn tryExpr(
51375154 const try_line = astgen.source_line - parent_gz.decl_line;
51385155 const try_column = astgen.source_column;
51395156
5140 const operand_rl: ResultLoc = switch (rl) {
5141 .ref, .catch_ref => .catch_ref,
5142 else => .catch_none,
5157 const operand_ri: ResultInfo = switch (ri.rl) {
5158 .ref => .{ .rl = .ref, .ctx = .error_handling_expr },
5159 else => .{ .rl = .none, .ctx = .error_handling_expr },
51435160 };
5144 // This could be a pointer or value depending on the `rl` parameter.
5145 const operand = try reachableExpr(parent_gz, scope, operand_rl, operand_node, node);
5161 // This could be a pointer or value depending on the `ri` parameter.
5162 const operand = try reachableExpr(parent_gz, scope, operand_ri, operand_node, node);
51465163 const is_inline = parent_gz.force_comptime;
51475164 const is_inline_bit = @as(u2, @boolToInt(is_inline));
5148 const is_ptr_bit = @as(u2, @boolToInt(operand_rl == .ref or operand_rl == .catch_ref)) << 1;
5165 const is_ptr_bit = @as(u2, @boolToInt(operand_ri.rl == .ref)) << 1;
51495166 const block_tag: Zir.Inst.Tag = switch (is_inline_bit | is_ptr_bit) {
51505167 0b00 => .@"try",
51515168 0b01 => .@"try",
......@@ -5160,8 +5177,8 @@ fn tryExpr(
51605177 var else_scope = parent_gz.makeSubBlock(scope);
51615178 defer else_scope.unstack();
51625179
5163 const err_tag = switch (rl) {
5164 .ref, .catch_ref => Zir.Inst.Tag.err_union_code_ptr,
5180 const err_tag = switch (ri.rl) {
5181 .ref => Zir.Inst.Tag.err_union_code_ptr,
51655182 else => Zir.Inst.Tag.err_union_code,
51665183 };
51675184 const err_code = try else_scope.addUnNode(err_tag, operand, node);
......@@ -5171,9 +5188,9 @@ fn tryExpr(
51715188
51725189 try else_scope.setTryBody(try_inst, operand);
51735190 const result = indexToRef(try_inst);
5174 switch (rl) {
5175 .ref, .catch_ref => return result,
5176 else => return rvalue(parent_gz, rl, result, node),
5191 switch (ri.rl) {
5192 .ref => return result,
5193 else => return rvalue(parent_gz, ri, result, node),
51775194 }
51785195}
51795196
......@@ -5190,7 +5207,7 @@ fn tryExpr(
51905207fn popErrorReturnTrace(
51915208 gz: *GenZir,
51925209 scope: *Scope,
5193 rl: ResultLoc,
5210 ri: ResultInfo,
51945211 node: Ast.Node.Index,
51955212 result_inst: Zir.Inst.Ref,
51965213 error_trace_index: Zir.Inst.Ref,
......@@ -5201,13 +5218,8 @@ fn popErrorReturnTrace(
52015218 const result_is_err = nodeMayEvalToError(tree, node);
52025219
52035220 // If we are breaking to a try/catch/error-union-if/return, the error trace propagates.
5204 const propagate_error_trace = switch (rl) {
5205 .catch_none, .catch_ref => true, // Propagate to try/catch/error-union-if
5206 .ptr, .ty => |ref| b: { // Otherwise, propagate if result loc is a return
5207 const inst = refToIndex(ref) orelse break :b false;
5208 const zir_tags = astgen.instructions.items(.tag);
5209 break :b zir_tags[inst] == .ret_ptr or zir_tags[inst] == .ret_type;
5210 },
5221 const propagate_error_trace = switch (ri.ctx) {
5222 .error_handling_expr, .@"return" => true,
52115223 else => false,
52125224 };
52135225
......@@ -5219,14 +5231,14 @@ fn popErrorReturnTrace(
52195231 // We are returning to an error-handling operator with a maybe-error.
52205232 // Restore only if it's a non-error, implying the catch was successfully handled.
52215233 var block_scope = gz.makeSubBlock(scope);
5222 block_scope.setBreakResultLoc(.discard);
5234 block_scope.setBreakResultInfo(.{ .rl = .discard });
52235235 defer block_scope.unstack();
52245236
52255237 // Emit conditional branch for restoring error trace index
5226 const is_non_err = switch (rl) {
5227 .catch_ref => try block_scope.addUnNode(.is_non_err_ptr, result_inst, node),
5228 .ptr => |ptr| try block_scope.addUnNode(.is_non_err_ptr, ptr, node),
5229 .ty, .catch_none => try block_scope.addUnNode(.is_non_err, result_inst, node),
5238 const is_non_err = switch (ri.rl) {
5239 .ref => try block_scope.addUnNode(.is_non_err_ptr, result_inst, node),
5240 .ptr => |ptr| try block_scope.addUnNode(.is_non_err_ptr, ptr.inst, node),
5241 .ty, .none => try block_scope.addUnNode(.is_non_err, result_inst, node),
52305242 else => unreachable, // Error-handling operators only generate the above result locations
52315243 };
52325244 const condbr = try block_scope.addCondBr(.condbr, node);
......@@ -5255,7 +5267,7 @@ fn popErrorReturnTrace(
52555267fn orelseCatchExpr(
52565268 parent_gz: *GenZir,
52575269 scope: *Scope,
5258 rl: ResultLoc,
5270 ri: ResultInfo,
52595271 node: Ast.Node.Index,
52605272 lhs: Ast.Node.Index,
52615273 cond_op: Zir.Inst.Tag,
......@@ -5270,21 +5282,21 @@ fn orelseCatchExpr(
52705282 const do_err_trace = astgen.fn_block != null and (cond_op == .is_non_err or cond_op == .is_non_err_ptr);
52715283
52725284 var block_scope = parent_gz.makeSubBlock(scope);
5273 block_scope.setBreakResultLoc(rl);
5285 block_scope.setBreakResultInfo(ri);
52745286 defer block_scope.unstack();
52755287
52765288 const saved_err_trace_index = if (do_err_trace) try parent_gz.addNode(.save_err_ret_index, node) else .none;
52775289
5278 const operand_rl: ResultLoc = switch (block_scope.break_result_loc) {
5279 .ref, .catch_ref => if (do_err_trace) ResultLoc{ .catch_ref = {} } else .ref,
5280 else => if (do_err_trace) ResultLoc{ .catch_none = {} } else .none,
5290 const operand_ri: ResultInfo = switch (block_scope.break_result_info.rl) {
5291 .ref => .{ .rl = .ref, .ctx = if (do_err_trace) .error_handling_expr else .none },
5292 else => .{ .rl = .none, .ctx = if (do_err_trace) .error_handling_expr else .none },
52815293 };
52825294 block_scope.break_count += 1;
5283 // This could be a pointer or value depending on the `operand_rl` parameter.
5284 // We cannot use `block_scope.break_result_loc` because that has the bare
5295 // This could be a pointer or value depending on the `operand_ri` parameter.
5296 // We cannot use `block_scope.break_result_info` because that has the bare
52855297 // type, whereas this expression has the optional type. Later we make
52865298 // up for this fact by calling rvalue on the else branch.
5287 const operand = try reachableExpr(&block_scope, &block_scope.base, operand_rl, lhs, rhs);
5299 const operand = try reachableExpr(&block_scope, &block_scope.base, operand_ri, lhs, rhs);
52885300 const cond = try block_scope.addUnNode(cond_op, operand, node);
52895301 const condbr = try block_scope.addCondBr(.condbr, node);
52905302
......@@ -5298,9 +5310,9 @@ fn orelseCatchExpr(
52985310
52995311 // This could be a pointer or value depending on `unwrap_op`.
53005312 const unwrapped_payload = try then_scope.addUnNode(unwrap_op, operand, node);
5301 const then_result = switch (rl) {
5302 .ref, .catch_ref => unwrapped_payload,
5303 else => try rvalue(&then_scope, block_scope.break_result_loc, unwrapped_payload, node),
5313 const then_result = switch (ri.rl) {
5314 .ref => unwrapped_payload,
5315 else => try rvalue(&then_scope, block_scope.break_result_info, unwrapped_payload, node),
53045316 };
53055317
53065318 var else_scope = block_scope.makeSubBlock(scope);
......@@ -5334,7 +5346,7 @@ fn orelseCatchExpr(
53345346 break :blk &err_val_scope.base;
53355347 };
53365348
5337 const else_result = try expr(&else_scope, else_sub_scope, block_scope.break_result_loc, rhs);
5349 const else_result = try expr(&else_scope, else_sub_scope, block_scope.break_result_info, rhs);
53385350 if (!else_scope.endsWithNoReturn()) {
53395351 block_scope.break_count += 1;
53405352
......@@ -5342,7 +5354,7 @@ fn orelseCatchExpr(
53425354 try popErrorReturnTrace(
53435355 &else_scope,
53445356 else_sub_scope,
5345 block_scope.break_result_loc,
5357 block_scope.break_result_info,
53465358 rhs,
53475359 else_result,
53485360 saved_err_trace_index,
......@@ -5358,7 +5370,7 @@ fn orelseCatchExpr(
53585370 const break_tag: Zir.Inst.Tag = if (parent_gz.force_comptime) .break_inline else .@"break";
53595371 const result = try finishThenElseBlock(
53605372 parent_gz,
5361 rl,
5373 ri,
53625374 node,
53635375 &block_scope,
53645376 &then_scope,
......@@ -5377,7 +5389,7 @@ fn orelseCatchExpr(
53775389/// Supports `else_scope` stacked on `then_scope` stacked on `block_scope`. Unstacks `else_scope` then `then_scope`.
53785390fn finishThenElseBlock(
53795391 parent_gz: *GenZir,
5380 rl: ResultLoc,
5392 ri: ResultInfo,
53815393 node: Ast.Node.Index,
53825394 block_scope: *GenZir,
53835395 then_scope: *GenZir,
......@@ -5392,7 +5404,7 @@ fn finishThenElseBlock(
53925404) InnerError!Zir.Inst.Ref {
53935405 // We now have enough information to decide whether the result instruction should
53945406 // be communicated via result location pointer or break instructions.
5395 const strat = rl.strategy(block_scope);
5407 const strat = ri.rl.strategy(block_scope);
53965408 // else_scope may be stacked on then_scope, so check for no-return on then_scope manually
53975409 const tags = parent_gz.astgen.instructions.items(.tag);
53985410 const then_slice = then_scope.instructionsSliceUpto(else_scope);
......@@ -5422,9 +5434,9 @@ fn finishThenElseBlock(
54225434 try setCondBrPayload(condbr, cond, then_scope, then_break, else_scope, else_break);
54235435 }
54245436 const block_ref = indexToRef(main_block);
5425 switch (rl) {
5426 .ref, .catch_ref => return block_ref,
5427 else => return rvalue(parent_gz, rl, block_ref, node),
5437 switch (ri.rl) {
5438 .ref => return block_ref,
5439 else => return rvalue(parent_gz, ri, block_ref, node),
54285440 }
54295441 },
54305442 }
......@@ -5443,14 +5455,14 @@ fn tokenIdentEql(astgen: *AstGen, token1: Ast.TokenIndex, token2: Ast.TokenIndex
54435455fn fieldAccess(
54445456 gz: *GenZir,
54455457 scope: *Scope,
5446 rl: ResultLoc,
5458 ri: ResultInfo,
54475459 node: Ast.Node.Index,
54485460) InnerError!Zir.Inst.Ref {
5449 switch (rl) {
5450 .ref, .catch_ref => return addFieldAccess(.field_ptr, gz, scope, .ref, node),
5461 switch (ri.rl) {
5462 .ref => return addFieldAccess(.field_ptr, gz, scope, .{ .rl = .ref }, node),
54515463 else => {
5452 const access = try addFieldAccess(.field_val, gz, scope, .none, node);
5453 return rvalue(gz, rl, access, node);
5464 const access = try addFieldAccess(.field_val, gz, scope, .{ .rl = .none }, node);
5465 return rvalue(gz, ri, access, node);
54545466 },
54555467 }
54565468}
......@@ -5459,7 +5471,7 @@ fn addFieldAccess(
54595471 tag: Zir.Inst.Tag,
54605472 gz: *GenZir,
54615473 scope: *Scope,
5462 lhs_rl: ResultLoc,
5474 lhs_ri: ResultInfo,
54635475 node: Ast.Node.Index,
54645476) InnerError!Zir.Inst.Ref {
54655477 const astgen = gz.astgen;
......@@ -5473,7 +5485,7 @@ fn addFieldAccess(
54735485 const str_index = try astgen.identAsString(field_ident);
54745486
54755487 return gz.addPlNode(tag, node, Zir.Inst.Field{
5476 .lhs = try expr(gz, scope, lhs_rl, object_node),
5488 .lhs = try expr(gz, scope, lhs_ri, object_node),
54775489 .field_name_start = str_index,
54785490 });
54795491}
......@@ -5481,20 +5493,20 @@ fn addFieldAccess(
54815493fn arrayAccess(
54825494 gz: *GenZir,
54835495 scope: *Scope,
5484 rl: ResultLoc,
5496 ri: ResultInfo,
54855497 node: Ast.Node.Index,
54865498) InnerError!Zir.Inst.Ref {
54875499 const astgen = gz.astgen;
54885500 const tree = astgen.tree;
54895501 const node_datas = tree.nodes.items(.data);
5490 switch (rl) {
5491 .ref, .catch_ref => return gz.addPlNode(.elem_ptr_node, node, Zir.Inst.Bin{
5492 .lhs = try expr(gz, scope, .ref, node_datas[node].lhs),
5493 .rhs = try expr(gz, scope, .{ .ty = .usize_type }, node_datas[node].rhs),
5502 switch (ri.rl) {
5503 .ref => return gz.addPlNode(.elem_ptr_node, node, Zir.Inst.Bin{
5504 .lhs = try expr(gz, scope, .{ .rl = .ref }, node_datas[node].lhs),
5505 .rhs = try expr(gz, scope, .{ .rl = .{ .ty = .usize_type } }, node_datas[node].rhs),
54945506 }),
5495 else => return rvalue(gz, rl, try gz.addPlNode(.elem_val_node, node, Zir.Inst.Bin{
5496 .lhs = try expr(gz, scope, .none, node_datas[node].lhs),
5497 .rhs = try expr(gz, scope, .{ .ty = .usize_type }, node_datas[node].rhs),
5507 else => return rvalue(gz, ri, try gz.addPlNode(.elem_val_node, node, Zir.Inst.Bin{
5508 .lhs = try expr(gz, scope, .{ .rl = .none }, node_datas[node].lhs),
5509 .rhs = try expr(gz, scope, .{ .rl = .{ .ty = .usize_type } }, node_datas[node].rhs),
54985510 }), node),
54995511 }
55005512}
......@@ -5502,7 +5514,7 @@ fn arrayAccess(
55025514fn simpleBinOp(
55035515 gz: *GenZir,
55045516 scope: *Scope,
5505 rl: ResultLoc,
5517 ri: ResultInfo,
55065518 node: Ast.Node.Index,
55075519 op_inst_tag: Zir.Inst.Tag,
55085520) InnerError!Zir.Inst.Ref {
......@@ -5511,15 +5523,15 @@ fn simpleBinOp(
55115523 const node_datas = tree.nodes.items(.data);
55125524
55135525 const result = try gz.addPlNode(op_inst_tag, node, Zir.Inst.Bin{
5514 .lhs = try reachableExpr(gz, scope, .none, node_datas[node].lhs, node),
5515 .rhs = try reachableExpr(gz, scope, .none, node_datas[node].rhs, node),
5526 .lhs = try reachableExpr(gz, scope, .{ .rl = .none }, node_datas[node].lhs, node),
5527 .rhs = try reachableExpr(gz, scope, .{ .rl = .none }, node_datas[node].rhs, node),
55165528 });
5517 return rvalue(gz, rl, result, node);
5529 return rvalue(gz, ri, result, node);
55185530}
55195531
55205532fn simpleStrTok(
55215533 gz: *GenZir,
5522 rl: ResultLoc,
5534 ri: ResultInfo,
55235535 ident_token: Ast.TokenIndex,
55245536 node: Ast.Node.Index,
55255537 op_inst_tag: Zir.Inst.Tag,
......@@ -5527,13 +5539,13 @@ fn simpleStrTok(
55275539 const astgen = gz.astgen;
55285540 const str_index = try astgen.identAsString(ident_token);
55295541 const result = try gz.addStrTok(op_inst_tag, str_index, ident_token);
5530 return rvalue(gz, rl, result, node);
5542 return rvalue(gz, ri, result, node);
55315543}
55325544
55335545fn boolBinOp(
55345546 gz: *GenZir,
55355547 scope: *Scope,
5536 rl: ResultLoc,
5548 ri: ResultInfo,
55375549 node: Ast.Node.Index,
55385550 zir_tag: Zir.Inst.Tag,
55395551) InnerError!Zir.Inst.Ref {
......@@ -5541,25 +5553,25 @@ fn boolBinOp(
55415553 const tree = astgen.tree;
55425554 const node_datas = tree.nodes.items(.data);
55435555
5544 const lhs = try expr(gz, scope, bool_rl, node_datas[node].lhs);
5556 const lhs = try expr(gz, scope, bool_ri, node_datas[node].lhs);
55455557 const bool_br = try gz.addBoolBr(zir_tag, lhs);
55465558
55475559 var rhs_scope = gz.makeSubBlock(scope);
55485560 defer rhs_scope.unstack();
5549 const rhs = try expr(&rhs_scope, &rhs_scope.base, bool_rl, node_datas[node].rhs);
5561 const rhs = try expr(&rhs_scope, &rhs_scope.base, bool_ri, node_datas[node].rhs);
55505562 if (!gz.refIsNoReturn(rhs)) {
55515563 _ = try rhs_scope.addBreak(.break_inline, bool_br, rhs);
55525564 }
55535565 try rhs_scope.setBoolBrBody(bool_br);
55545566
55555567 const block_ref = indexToRef(bool_br);
5556 return rvalue(gz, rl, block_ref, node);
5568 return rvalue(gz, ri, block_ref, node);
55575569}
55585570
55595571fn ifExpr(
55605572 parent_gz: *GenZir,
55615573 scope: *Scope,
5562 rl: ResultLoc,
5574 ri: ResultInfo,
55635575 node: Ast.Node.Index,
55645576 if_full: Ast.full.If,
55655577) InnerError!Zir.Inst.Ref {
......@@ -5570,7 +5582,7 @@ fn ifExpr(
55705582 const do_err_trace = astgen.fn_block != null and if_full.error_token != null;
55715583
55725584 var block_scope = parent_gz.makeSubBlock(scope);
5573 block_scope.setBreakResultLoc(rl);
5585 block_scope.setBreakResultInfo(ri);
55745586 defer block_scope.unstack();
55755587
55765588 const saved_err_trace_index = if (do_err_trace) try parent_gz.addNode(.save_err_ret_index, node) else .none;
......@@ -5586,23 +5598,23 @@ fn ifExpr(
55865598 bool_bit: Zir.Inst.Ref,
55875599 } = c: {
55885600 if (if_full.error_token) |_| {
5589 const cond_rl: ResultLoc = if (payload_is_ref) .catch_ref else .catch_none;
5590 const err_union = try expr(&block_scope, &block_scope.base, cond_rl, if_full.ast.cond_expr);
5601 const cond_ri: ResultInfo = .{ .rl = if (payload_is_ref) .ref else .none, .ctx = .error_handling_expr };
5602 const err_union = try expr(&block_scope, &block_scope.base, cond_ri, if_full.ast.cond_expr);
55915603 const tag: Zir.Inst.Tag = if (payload_is_ref) .is_non_err_ptr else .is_non_err;
55925604 break :c .{
55935605 .inst = err_union,
55945606 .bool_bit = try block_scope.addUnNode(tag, err_union, if_full.ast.cond_expr),
55955607 };
55965608 } else if (if_full.payload_token) |_| {
5597 const cond_rl: ResultLoc = if (payload_is_ref) .ref else .none;
5598 const optional = try expr(&block_scope, &block_scope.base, cond_rl, if_full.ast.cond_expr);
5609 const cond_ri: ResultInfo = .{ .rl = if (payload_is_ref) .ref else .none };
5610 const optional = try expr(&block_scope, &block_scope.base, cond_ri, if_full.ast.cond_expr);
55995611 const tag: Zir.Inst.Tag = if (payload_is_ref) .is_non_null_ptr else .is_non_null;
56005612 break :c .{
56015613 .inst = optional,
56025614 .bool_bit = try block_scope.addUnNode(tag, optional, if_full.ast.cond_expr),
56035615 };
56045616 } else {
5605 const cond = try expr(&block_scope, &block_scope.base, bool_rl, if_full.ast.cond_expr);
5617 const cond = try expr(&block_scope, &block_scope.base, bool_ri, if_full.ast.cond_expr);
56065618 break :c .{
56075619 .inst = cond,
56085620 .bool_bit = cond,
......@@ -5678,7 +5690,7 @@ fn ifExpr(
56785690 }
56795691 };
56805692
5681 const then_result = try expr(&then_scope, then_sub_scope, block_scope.break_result_loc, if_full.ast.then_expr);
5693 const then_result = try expr(&then_scope, then_sub_scope, block_scope.break_result_info, if_full.ast.then_expr);
56825694 if (!then_scope.endsWithNoReturn()) {
56835695 block_scope.break_count += 1;
56845696 }
......@@ -5729,7 +5741,7 @@ fn ifExpr(
57295741 break :s &else_scope.base;
57305742 }
57315743 };
5732 const e = try expr(&else_scope, sub_scope, block_scope.break_result_loc, else_node);
5744 const e = try expr(&else_scope, sub_scope, block_scope.break_result_info, else_node);
57335745 if (!else_scope.endsWithNoReturn()) {
57345746 block_scope.break_count += 1;
57355747
......@@ -5737,7 +5749,7 @@ fn ifExpr(
57375749 try popErrorReturnTrace(
57385750 &else_scope,
57395751 sub_scope,
5740 block_scope.break_result_loc,
5752 block_scope.break_result_info,
57415753 else_node,
57425754 e,
57435755 saved_err_trace_index,
......@@ -5752,9 +5764,9 @@ fn ifExpr(
57525764 };
57535765 } else .{
57545766 .src = if_full.ast.then_expr,
5755 .result = switch (rl) {
5767 .result = switch (ri.rl) {
57565768 // Explicitly store void to ptr result loc if there is no else branch
5757 .ptr, .block_ptr => try rvalue(&else_scope, rl, .void_value, node),
5769 .ptr, .block_ptr => try rvalue(&else_scope, ri, .void_value, node),
57585770 else => .none,
57595771 },
57605772 };
......@@ -5762,7 +5774,7 @@ fn ifExpr(
57625774 const break_tag: Zir.Inst.Tag = if (parent_gz.force_comptime) .break_inline else .@"break";
57635775 const result = try finishThenElseBlock(
57645776 parent_gz,
5765 rl,
5777 ri,
57665778 node,
57675779 &block_scope,
57685780 &then_scope,
......@@ -5896,7 +5908,7 @@ fn setCondBrPayloadElideBlockStorePtr(
58965908fn whileExpr(
58975909 parent_gz: *GenZir,
58985910 scope: *Scope,
5899 rl: ResultLoc,
5911 ri: ResultInfo,
59005912 node: Ast.Node.Index,
59015913 while_full: Ast.full.While,
59025914 is_statement: bool,
......@@ -5916,7 +5928,7 @@ fn whileExpr(
59165928
59175929 var loop_scope = parent_gz.makeSubBlock(scope);
59185930 loop_scope.is_inline = is_inline;
5919 loop_scope.setBreakResultLoc(rl);
5931 loop_scope.setBreakResultInfo(ri);
59205932 defer loop_scope.unstack();
59215933 defer loop_scope.labeled_breaks.deinit(astgen.gpa);
59225934
......@@ -5934,23 +5946,23 @@ fn whileExpr(
59345946 bool_bit: Zir.Inst.Ref,
59355947 } = c: {
59365948 if (while_full.error_token) |_| {
5937 const cond_rl: ResultLoc = if (payload_is_ref) .ref else .none;
5938 const err_union = try expr(&continue_scope, &continue_scope.base, cond_rl, while_full.ast.cond_expr);
5949 const cond_ri: ResultInfo = .{ .rl = if (payload_is_ref) .ref else .none };
5950 const err_union = try expr(&continue_scope, &continue_scope.base, cond_ri, while_full.ast.cond_expr);
59395951 const tag: Zir.Inst.Tag = if (payload_is_ref) .is_non_err_ptr else .is_non_err;
59405952 break :c .{
59415953 .inst = err_union,
59425954 .bool_bit = try continue_scope.addUnNode(tag, err_union, while_full.ast.then_expr),
59435955 };
59445956 } else if (while_full.payload_token) |_| {
5945 const cond_rl: ResultLoc = if (payload_is_ref) .ref else .none;
5946 const optional = try expr(&continue_scope, &continue_scope.base, cond_rl, while_full.ast.cond_expr);
5957 const cond_ri: ResultInfo = .{ .rl = if (payload_is_ref) .ref else .none };
5958 const optional = try expr(&continue_scope, &continue_scope.base, cond_ri, while_full.ast.cond_expr);
59475959 const tag: Zir.Inst.Tag = if (payload_is_ref) .is_non_null_ptr else .is_non_null;
59485960 break :c .{
59495961 .inst = optional,
59505962 .bool_bit = try continue_scope.addUnNode(tag, optional, while_full.ast.then_expr),
59515963 };
59525964 } else {
5953 const cond = try expr(&continue_scope, &continue_scope.base, bool_rl, while_full.ast.cond_expr);
5965 const cond = try expr(&continue_scope, &continue_scope.base, bool_ri, while_full.ast.cond_expr);
59545966 break :c .{
59555967 .inst = cond,
59565968 .bool_bit = cond,
......@@ -6069,7 +6081,7 @@ fn whileExpr(
60696081 if (dbg_var_name) |some| {
60706082 try then_scope.addDbgVar(.dbg_var_val, some, dbg_var_inst);
60716083 }
6072 const then_result = try expr(&then_scope, then_sub_scope, .none, while_full.ast.then_expr);
6084 const then_result = try expr(&then_scope, then_sub_scope, .{ .rl = .none }, while_full.ast.then_expr);
60736085 _ = try addEnsureResult(&then_scope, then_result, while_full.ast.then_expr);
60746086
60756087 try checkUsed(parent_gz, &then_scope.base, then_sub_scope);
......@@ -6114,7 +6126,7 @@ fn whileExpr(
61146126 // control flow apply to outer loops; not this one.
61156127 loop_scope.continue_block = 0;
61166128 loop_scope.break_block = 0;
6117 const else_result = try expr(&else_scope, sub_scope, loop_scope.break_result_loc, else_node);
6129 const else_result = try expr(&else_scope, sub_scope, loop_scope.break_result_info, else_node);
61186130 if (is_statement) {
61196131 _ = try addEnsureResult(&else_scope, else_result, else_node);
61206132 }
......@@ -6141,7 +6153,7 @@ fn whileExpr(
61416153 const break_tag: Zir.Inst.Tag = if (is_inline) .break_inline else .@"break";
61426154 const result = try finishThenElseBlock(
61436155 parent_gz,
6144 rl,
6156 ri,
61456157 node,
61466158 &loop_scope,
61476159 &then_scope,
......@@ -6163,7 +6175,7 @@ fn whileExpr(
61636175fn forExpr(
61646176 parent_gz: *GenZir,
61656177 scope: *Scope,
6166 rl: ResultLoc,
6178 ri: ResultInfo,
61676179 node: Ast.Node.Index,
61686180 for_full: Ast.full.While,
61696181 is_statement: bool,
......@@ -6186,8 +6198,8 @@ fn forExpr(
61866198
61876199 try emitDbgNode(parent_gz, for_full.ast.cond_expr);
61886200
6189 const cond_rl: ResultLoc = if (payload_is_ref) .ref else .none;
6190 const array_ptr = try expr(parent_gz, scope, cond_rl, for_full.ast.cond_expr);
6201 const cond_ri: ResultInfo = .{ .rl = if (payload_is_ref) .ref else .none };
6202 const array_ptr = try expr(parent_gz, scope, cond_ri, for_full.ast.cond_expr);
61916203 const len = try parent_gz.addUnNode(.indexable_ptr_len, array_ptr, for_full.ast.cond_expr);
61926204
61936205 const index_ptr = blk: {
......@@ -6204,7 +6216,7 @@ fn forExpr(
62046216
62056217 var loop_scope = parent_gz.makeSubBlock(scope);
62066218 loop_scope.is_inline = is_inline;
6207 loop_scope.setBreakResultLoc(rl);
6219 loop_scope.setBreakResultInfo(ri);
62086220 defer loop_scope.unstack();
62096221 defer loop_scope.labeled_breaks.deinit(astgen.gpa);
62106222
......@@ -6308,7 +6320,7 @@ fn forExpr(
63086320 break :blk &index_scope.base;
63096321 };
63106322
6311 const then_result = try expr(&then_scope, then_sub_scope, .none, for_full.ast.then_expr);
6323 const then_result = try expr(&then_scope, then_sub_scope, .{ .rl = .none }, for_full.ast.then_expr);
63126324 _ = try addEnsureResult(&then_scope, then_result, for_full.ast.then_expr);
63136325
63146326 try checkUsed(parent_gz, &then_scope.base, then_sub_scope);
......@@ -6327,7 +6339,7 @@ fn forExpr(
63276339 // control flow apply to outer loops; not this one.
63286340 loop_scope.continue_block = 0;
63296341 loop_scope.break_block = 0;
6330 const else_result = try expr(&else_scope, sub_scope, loop_scope.break_result_loc, else_node);
6342 const else_result = try expr(&else_scope, sub_scope, loop_scope.break_result_info, else_node);
63316343 if (is_statement) {
63326344 _ = try addEnsureResult(&else_scope, else_result, else_node);
63336345 }
......@@ -6352,7 +6364,7 @@ fn forExpr(
63526364 const break_tag: Zir.Inst.Tag = if (is_inline) .break_inline else .@"break";
63536365 const result = try finishThenElseBlock(
63546366 parent_gz,
6355 rl,
6367 ri,
63566368 node,
63576369 &loop_scope,
63586370 &then_scope,
......@@ -6374,7 +6386,7 @@ fn forExpr(
63746386fn switchExpr(
63756387 parent_gz: *GenZir,
63766388 scope: *Scope,
6377 rl: ResultLoc,
6389 ri: ResultInfo,
63786390 switch_node: Ast.Node.Index,
63796391) InnerError!Zir.Inst.Ref {
63806392 const astgen = parent_gz.astgen;
......@@ -6505,13 +6517,13 @@ fn switchExpr(
65056517 }
65066518 }
65076519
6508 const operand_rl: ResultLoc = if (any_payload_is_ref) .ref else .none;
6509 const raw_operand = try expr(parent_gz, scope, operand_rl, operand_node);
6520 const operand_ri: ResultInfo = .{ .rl = if (any_payload_is_ref) .ref else .none };
6521 const raw_operand = try expr(parent_gz, scope, operand_ri, operand_node);
65106522 const cond_tag: Zir.Inst.Tag = if (any_payload_is_ref) .switch_cond_ref else .switch_cond;
65116523 const cond = try parent_gz.addUnNode(cond_tag, raw_operand, operand_node);
65126524 // We need the type of the operand to use as the result location for all the prong items.
65136525 const cond_ty_inst = try parent_gz.addUnNode(.typeof, cond, operand_node);
6514 const item_rl: ResultLoc = .{ .ty = cond_ty_inst };
6526 const item_ri: ResultInfo = .{ .rl = .{ .ty = cond_ty_inst } };
65156527
65166528 // This contains the data that goes into the `extra` array for the SwitchBlock/SwitchBlockMulti,
65176529 // except the first cases_nodes.len slots are a table that indexes payloads later in the array, with
......@@ -6528,7 +6540,7 @@ fn switchExpr(
65286540 var block_scope = parent_gz.makeSubBlock(scope);
65296541 // block_scope not used for collecting instructions
65306542 block_scope.instructions_top = GenZir.unstacked_top;
6531 block_scope.setBreakResultLoc(rl);
6543 block_scope.setBreakResultInfo(ri);
65326544
65336545 // This gets added to the parent block later, after the item expressions.
65346546 const switch_block = try parent_gz.makeBlockInst(.switch_block, switch_node);
......@@ -6669,7 +6681,7 @@ fn switchExpr(
66696681 if (node_tags[item_node] == .switch_range) continue;
66706682 items_len += 1;
66716683
6672 const item_inst = try comptimeExpr(parent_gz, scope, item_rl, item_node);
6684 const item_inst = try comptimeExpr(parent_gz, scope, item_ri, item_node);
66736685 try payloads.append(gpa, @enumToInt(item_inst));
66746686 }
66756687
......@@ -6679,8 +6691,8 @@ fn switchExpr(
66796691 if (node_tags[range] != .switch_range) continue;
66806692 ranges_len += 1;
66816693
6682 const first = try comptimeExpr(parent_gz, scope, item_rl, node_datas[range].lhs);
6683 const last = try comptimeExpr(parent_gz, scope, item_rl, node_datas[range].rhs);
6694 const first = try comptimeExpr(parent_gz, scope, item_ri, node_datas[range].lhs);
6695 const last = try comptimeExpr(parent_gz, scope, item_ri, node_datas[range].rhs);
66846696 try payloads.appendSlice(gpa, &[_]u32{
66856697 @enumToInt(first), @enumToInt(last),
66866698 });
......@@ -6698,7 +6710,7 @@ fn switchExpr(
66986710 scalar_case_index += 1;
66996711 try payloads.resize(gpa, header_index + 2); // item, body_len
67006712 const item_node = case.ast.values[0];
6701 const item_inst = try comptimeExpr(parent_gz, scope, item_rl, item_node);
6713 const item_inst = try comptimeExpr(parent_gz, scope, item_ri, item_node);
67026714 payloads.items[header_index] = @enumToInt(item_inst);
67036715 break :blk header_index + 1;
67046716 };
......@@ -6717,7 +6729,7 @@ fn switchExpr(
67176729 if (dbg_var_tag_name) |some| {
67186730 try case_scope.addDbgVar(.dbg_var_val, some, dbg_var_tag_inst);
67196731 }
6720 const case_result = try expr(&case_scope, sub_scope, block_scope.break_result_loc, case.ast.target_expr);
6732 const case_result = try expr(&case_scope, sub_scope, block_scope.break_result_info, case.ast.target_expr);
67216733 try checkUsed(parent_gz, &case_scope.base, sub_scope);
67226734 try case_scope.addDbgBlockEnd();
67236735 if (!parent_gz.refIsNoReturn(case_result)) {
......@@ -6759,7 +6771,7 @@ fn switchExpr(
67596771
67606772 zir_datas[switch_block].pl_node.payload_index = payload_index;
67616773
6762 const strat = rl.strategy(&block_scope);
6774 const strat = ri.rl.strategy(&block_scope);
67636775 for (payloads.items[case_table_start..case_table_end]) |start_index, i| {
67646776 var body_len_index = start_index;
67656777 var end_index = start_index;
......@@ -6831,8 +6843,8 @@ fn switchExpr(
68316843 }
68326844
68336845 const block_ref = indexToRef(switch_block);
6834 if (strat.tag == .break_operand and strat.elide_store_to_block_ptr_instructions and rl != .ref and rl != .catch_ref)
6835 return rvalue(parent_gz, rl, block_ref, switch_node);
6846 if (strat.tag == .break_operand and strat.elide_store_to_block_ptr_instructions and ri.rl != .ref)
6847 return rvalue(parent_gz, ri, block_ref, switch_node);
68366848 return block_ref;
68376849}
68386850
......@@ -6895,14 +6907,16 @@ fn ret(gz: *GenZir, scope: *Scope, node: Ast.Node.Index) InnerError!Zir.Inst.Ref
68956907 return Zir.Inst.Ref.unreachable_value;
68966908 }
68976909
6898 const rl: ResultLoc = if (nodeMayNeedMemoryLocation(tree, operand_node, true)) .{
6899 .ptr = .{ .inst = try gz.addNode(.ret_ptr, node) },
6910 const ri: ResultInfo = if (nodeMayNeedMemoryLocation(tree, operand_node, true)) .{
6911 .rl = .{ .ptr = .{ .inst = try gz.addNode(.ret_ptr, node) } },
6912 .ctx = .@"return",
69006913 } else .{
6901 .ty = try gz.addNode(.ret_type, node),
6914 .rl = .{ .ty = try gz.addNode(.ret_type, node) },
6915 .ctx = .@"return",
69026916 };
69036917 const prev_anon_name_strategy = gz.anon_name_strategy;
69046918 gz.anon_name_strategy = .func;
6905 const operand = try reachableExpr(gz, scope, rl, operand_node, node);
6919 const operand = try reachableExpr(gz, scope, ri, operand_node, node);
69066920 gz.anon_name_strategy = prev_anon_name_strategy;
69076921
69086922 // TODO: This should be almost identical for every break/ret
......@@ -6916,15 +6930,15 @@ fn ret(gz: *GenZir, scope: *Scope, node: Ast.Node.Index) InnerError!Zir.Inst.Ref
69166930 _ = try gz.addUnNode(.restore_err_ret_index, gz.outermost_err_trace_index, node);
69176931
69186932 try emitDbgStmt(gz, ret_line, ret_column);
6919 try gz.addRet(rl, operand, node);
6933 try gz.addRet(ri, operand, node);
69206934 return Zir.Inst.Ref.unreachable_value;
69216935 },
69226936 .always => {
69236937 // Value is always an error. Emit both error defers and regular defers.
6924 const err_code = if (rl == .ptr) try gz.addUnNode(.load, rl.ptr.inst, node) else operand;
6938 const err_code = if (ri.rl == .ptr) try gz.addUnNode(.load, ri.rl.ptr.inst, node) else operand;
69256939 try genDefers(gz, defer_outer, scope, .{ .both = err_code });
69266940 try emitDbgStmt(gz, ret_line, ret_column);
6927 try gz.addRet(rl, operand, node);
6941 try gz.addRet(ri, operand, node);
69286942 return Zir.Inst.Ref.unreachable_value;
69296943 },
69306944 .maybe => {
......@@ -6933,12 +6947,12 @@ fn ret(gz: *GenZir, scope: *Scope, node: Ast.Node.Index) InnerError!Zir.Inst.Ref
69336947 // Only regular defers; no branch needed.
69346948 try genDefers(gz, defer_outer, scope, .normal_only);
69356949 try emitDbgStmt(gz, ret_line, ret_column);
6936 try gz.addRet(rl, operand, node);
6950 try gz.addRet(ri, operand, node);
69376951 return Zir.Inst.Ref.unreachable_value;
69386952 }
69396953
69406954 // Emit conditional branch for generating errdefers.
6941 const result = if (rl == .ptr) try gz.addUnNode(.load, rl.ptr.inst, node) else operand;
6955 const result = if (ri.rl == .ptr) try gz.addUnNode(.load, ri.rl.ptr.inst, node) else operand;
69426956 const is_non_err = try gz.addUnNode(.is_non_err, result, node);
69436957 const condbr = try gz.addCondBr(.condbr, node);
69446958
......@@ -6952,7 +6966,7 @@ fn ret(gz: *GenZir, scope: *Scope, node: Ast.Node.Index) InnerError!Zir.Inst.Ref
69526966 _ = try then_scope.addUnNode(.restore_err_ret_index, then_scope.outermost_err_trace_index, node);
69536967
69546968 try emitDbgStmt(&then_scope, ret_line, ret_column);
6955 try then_scope.addRet(rl, operand, node);
6969 try then_scope.addRet(ri, operand, node);
69566970
69576971 var else_scope = gz.makeSubBlock(scope);
69586972 defer else_scope.unstack();
......@@ -6962,7 +6976,7 @@ fn ret(gz: *GenZir, scope: *Scope, node: Ast.Node.Index) InnerError!Zir.Inst.Ref
69626976 };
69636977 try genDefers(&else_scope, defer_outer, scope, which_ones);
69646978 try emitDbgStmt(&else_scope, ret_line, ret_column);
6965 try else_scope.addRet(rl, operand, node);
6979 try else_scope.addRet(ri, operand, node);
69666980
69676981 try setCondBrPayload(condbr, is_non_err, &then_scope, 0, &else_scope, 0);
69686982
......@@ -6995,7 +7009,7 @@ fn parseBitCount(buf: []const u8) std.fmt.ParseIntError!u16 {
69957009fn identifier(
69967010 gz: *GenZir,
69977011 scope: *Scope,
6998 rl: ResultLoc,
7012 ri: ResultInfo,
69997013 ident: Ast.Node.Index,
70007014) InnerError!Zir.Inst.Ref {
70017015 const tracy = trace(@src());
......@@ -7014,7 +7028,7 @@ fn identifier(
70147028 // if not @"" syntax, just use raw token slice
70157029 if (ident_name_raw[0] != '@') {
70167030 if (primitives.get(ident_name_raw)) |zir_const_ref| {
7017 return rvalue(gz, rl, zir_const_ref, ident);
7031 return rvalue(gz, ri, zir_const_ref, ident);
70187032 }
70197033
70207034 if (ident_name_raw.len >= 2) integer: {
......@@ -7047,19 +7061,19 @@ fn identifier(
70477061 .bit_count = bit_count,
70487062 } },
70497063 });
7050 return rvalue(gz, rl, result, ident);
7064 return rvalue(gz, ri, result, ident);
70517065 }
70527066 }
70537067 }
70547068
70557069 // Local variables, including function parameters.
7056 return localVarRef(gz, scope, rl, ident, ident_token);
7070 return localVarRef(gz, scope, ri, ident, ident_token);
70577071}
70587072
70597073fn localVarRef(
70607074 gz: *GenZir,
70617075 scope: *Scope,
7062 rl: ResultLoc,
7076 ri: ResultInfo,
70637077 ident: Ast.Node.Index,
70647078 ident_token: Ast.TokenIndex,
70657079) InnerError!Zir.Inst.Ref {
......@@ -7077,7 +7091,7 @@ fn localVarRef(
70777091 if (local_val.name == name_str_index) {
70787092 // Locals cannot shadow anything, so we do not need to look for ambiguous
70797093 // references in this case.
7080 if (rl == .discard) {
7094 if (ri.rl == .discard) {
70817095 local_val.discarded = ident_token;
70827096 } else {
70837097 local_val.used = ident_token;
......@@ -7093,14 +7107,14 @@ fn localVarRef(
70937107 gpa,
70947108 );
70957109
7096 return rvalue(gz, rl, value_inst, ident);
7110 return rvalue(gz, ri, value_inst, ident);
70977111 }
70987112 s = local_val.parent;
70997113 },
71007114 .local_ptr => {
71017115 const local_ptr = s.cast(Scope.LocalPtr).?;
71027116 if (local_ptr.name == name_str_index) {
7103 if (rl == .discard) {
7117 if (ri.rl == .discard) {
71047118 local_ptr.discarded = ident_token;
71057119 } else {
71067120 local_ptr.used = ident_token;
......@@ -7125,11 +7139,11 @@ fn localVarRef(
71257139 gpa,
71267140 );
71277141
7128 switch (rl) {
7129 .ref, .catch_ref => return ptr_inst,
7142 switch (ri.rl) {
7143 .ref => return ptr_inst,
71307144 else => {
71317145 const loaded = try gz.addUnNode(.load, ptr_inst, ident);
7132 return rvalue(gz, rl, loaded, ident);
7146 return rvalue(gz, ri, loaded, ident);
71337147 },
71347148 }
71357149 }
......@@ -7162,11 +7176,11 @@ fn localVarRef(
71627176
71637177 // Decl references happen by name rather than ZIR index so that when unrelated
71647178 // decls are modified, ZIR code containing references to them can be unmodified.
7165 switch (rl) {
7166 .ref, .catch_ref => return gz.addStrTok(.decl_ref, name_str_index, ident_token),
7179 switch (ri.rl) {
7180 .ref => return gz.addStrTok(.decl_ref, name_str_index, ident_token),
71677181 else => {
71687182 const result = try gz.addStrTok(.decl_val, name_str_index, ident_token);
7169 return rvalue(gz, rl, result, ident);
7183 return rvalue(gz, ri, result, ident);
71707184 },
71717185 }
71727186}
......@@ -7210,7 +7224,7 @@ fn tunnelThroughClosure(
72107224
72117225fn stringLiteral(
72127226 gz: *GenZir,
7213 rl: ResultLoc,
7227 ri: ResultInfo,
72147228 node: Ast.Node.Index,
72157229) InnerError!Zir.Inst.Ref {
72167230 const astgen = gz.astgen;
......@@ -7225,12 +7239,12 @@ fn stringLiteral(
72257239 .len = str.len,
72267240 } },
72277241 });
7228 return rvalue(gz, rl, result, node);
7242 return rvalue(gz, ri, result, node);
72297243}
72307244
72317245fn multilineStringLiteral(
72327246 gz: *GenZir,
7233 rl: ResultLoc,
7247 ri: ResultInfo,
72347248 node: Ast.Node.Index,
72357249) InnerError!Zir.Inst.Ref {
72367250 const astgen = gz.astgen;
......@@ -7242,10 +7256,10 @@ fn multilineStringLiteral(
72427256 .len = str.len,
72437257 } },
72447258 });
7245 return rvalue(gz, rl, result, node);
7259 return rvalue(gz, ri, result, node);
72467260}
72477261
7248fn charLiteral(gz: *GenZir, rl: ResultLoc, node: Ast.Node.Index) InnerError!Zir.Inst.Ref {
7262fn charLiteral(gz: *GenZir, ri: ResultInfo, node: Ast.Node.Index) InnerError!Zir.Inst.Ref {
72497263 const astgen = gz.astgen;
72507264 const tree = astgen.tree;
72517265 const main_tokens = tree.nodes.items(.main_token);
......@@ -7255,7 +7269,7 @@ fn charLiteral(gz: *GenZir, rl: ResultLoc, node: Ast.Node.Index) InnerError!Zir.
72557269 switch (std.zig.parseCharLiteral(slice)) {
72567270 .success => |codepoint| {
72577271 const result = try gz.addInt(codepoint);
7258 return rvalue(gz, rl, result, node);
7272 return rvalue(gz, ri, result, node);
72597273 },
72607274 .failure => |err| return astgen.failWithStrLitError(err, main_token, slice, 0),
72617275 }
......@@ -7263,7 +7277,7 @@ fn charLiteral(gz: *GenZir, rl: ResultLoc, node: Ast.Node.Index) InnerError!Zir.
72637277
72647278const Sign = enum { negative, positive };
72657279
7266fn numberLiteral(gz: *GenZir, rl: ResultLoc, node: Ast.Node.Index, source_node: Ast.Node.Index, sign: Sign) InnerError!Zir.Inst.Ref {
7280fn numberLiteral(gz: *GenZir, ri: ResultInfo, node: Ast.Node.Index, source_node: Ast.Node.Index, sign: Sign) InnerError!Zir.Inst.Ref {
72677281 const astgen = gz.astgen;
72687282 const tree = astgen.tree;
72697283 const main_tokens = tree.nodes.items(.main_token);
......@@ -7305,7 +7319,7 @@ fn numberLiteral(gz: *GenZir, rl: ResultLoc, node: Ast.Node.Index, source_node:
73057319 const bigger_again: f128 = smaller_float;
73067320 if (bigger_again == float_number) {
73077321 const result = try gz.addFloat(smaller_float);
7308 return rvalue(gz, rl, result, source_node);
7322 return rvalue(gz, ri, result, source_node);
73097323 }
73107324 // We need to use 128 bits. Break the float into 4 u32 values so we can
73117325 // put it into the `extra` array.
......@@ -7316,16 +7330,16 @@ fn numberLiteral(gz: *GenZir, rl: ResultLoc, node: Ast.Node.Index, source_node:
73167330 .piece2 = @truncate(u32, int_bits >> 64),
73177331 .piece3 = @truncate(u32, int_bits >> 96),
73187332 });
7319 return rvalue(gz, rl, result, source_node);
7333 return rvalue(gz, ri, result, source_node);
73207334 },
73217335 .failure => |err| return astgen.failWithNumberError(err, num_token, bytes),
73227336 };
73237337
73247338 if (sign == .positive) {
7325 return rvalue(gz, rl, result, source_node);
7339 return rvalue(gz, ri, result, source_node);
73267340 } else {
73277341 const negated = try gz.addUnNode(.negate, result, source_node);
7328 return rvalue(gz, rl, negated, source_node);
7342 return rvalue(gz, ri, negated, source_node);
73297343 }
73307344}
73317345
......@@ -7361,7 +7375,7 @@ fn failWithNumberError(astgen: *AstGen, err: std.zig.number_literal.Error, token
73617375fn asmExpr(
73627376 gz: *GenZir,
73637377 scope: *Scope,
7364 rl: ResultLoc,
7378 ri: ResultInfo,
73657379 node: Ast.Node.Index,
73667380 full: Ast.full.Asm,
73677381) InnerError!Zir.Inst.Ref {
......@@ -7384,7 +7398,7 @@ fn asmExpr(
73847398 },
73857399 else => .{
73867400 .tag = .asm_expr,
7387 .tmpl = @enumToInt(try comptimeExpr(gz, scope, .none, full.ast.template)),
7401 .tmpl = @enumToInt(try comptimeExpr(gz, scope, .{ .rl = .none }, full.ast.template)),
73887402 },
73897403 };
73907404
......@@ -7436,7 +7450,7 @@ fn asmExpr(
74367450 outputs[i] = .{
74377451 .name = name,
74387452 .constraint = constraint,
7439 .operand = try localVarRef(gz, scope, .ref, node, ident_token),
7453 .operand = try localVarRef(gz, scope, .{ .rl = .ref }, node, ident_token),
74407454 };
74417455 }
74427456 }
......@@ -7452,7 +7466,7 @@ fn asmExpr(
74527466 const name = try astgen.identAsString(symbolic_name);
74537467 const constraint_token = symbolic_name + 2;
74547468 const constraint = (try astgen.strLitAsString(constraint_token)).index;
7455 const operand = try expr(gz, scope, .none, node_datas[input_node].lhs);
7469 const operand = try expr(gz, scope, .{ .rl = .none }, node_datas[input_node].lhs);
74567470 inputs[i] = .{
74577471 .name = name,
74587472 .constraint = constraint,
......@@ -7497,31 +7511,31 @@ fn asmExpr(
74977511 .inputs = inputs,
74987512 .clobbers = clobbers_buffer[0..clobber_i],
74997513 });
7500 return rvalue(gz, rl, result, node);
7514 return rvalue(gz, ri, result, node);
75017515}
75027516
75037517fn as(
75047518 gz: *GenZir,
75057519 scope: *Scope,
7506 rl: ResultLoc,
7520 ri: ResultInfo,
75077521 node: Ast.Node.Index,
75087522 lhs: Ast.Node.Index,
75097523 rhs: Ast.Node.Index,
75107524) InnerError!Zir.Inst.Ref {
75117525 const dest_type = try typeExpr(gz, scope, lhs);
7512 switch (rl) {
7513 .none, .catch_none, .discard, .ref, .catch_ref, .ty, .ty_shift_operand, .coerced_ty => {
7514 const result = try reachableExpr(gz, scope, .{ .ty = dest_type }, rhs, node);
7515 return rvalue(gz, rl, result, node);
7526 switch (ri.rl) {
7527 .none, .discard, .ref, .ty, .coerced_ty => {
7528 const result = try reachableExpr(gz, scope, .{ .rl = .{ .ty = dest_type } }, rhs, node);
7529 return rvalue(gz, ri, result, node);
75167530 },
75177531 .ptr => |result_ptr| {
7518 return asRlPtr(gz, scope, rl, node, result_ptr.inst, rhs, dest_type);
7532 return asRlPtr(gz, scope, ri, node, result_ptr.inst, rhs, dest_type);
75197533 },
75207534 .inferred_ptr => |result_ptr| {
7521 return asRlPtr(gz, scope, rl, node, result_ptr, rhs, dest_type);
7535 return asRlPtr(gz, scope, ri, node, result_ptr, rhs, dest_type);
75227536 },
75237537 .block_ptr => |block_scope| {
7524 return asRlPtr(gz, scope, rl, node, block_scope.rl_ptr, rhs, dest_type);
7538 return asRlPtr(gz, scope, ri, node, block_scope.rl_ptr, rhs, dest_type);
75257539 },
75267540 }
75277541}
......@@ -7529,29 +7543,29 @@ fn as(
75297543fn unionInit(
75307544 gz: *GenZir,
75317545 scope: *Scope,
7532 rl: ResultLoc,
7546 ri: ResultInfo,
75337547 node: Ast.Node.Index,
75347548 params: []const Ast.Node.Index,
75357549) InnerError!Zir.Inst.Ref {
75367550 const union_type = try typeExpr(gz, scope, params[0]);
7537 const field_name = try comptimeExpr(gz, scope, .{ .ty = .const_slice_u8_type }, params[1]);
7551 const field_name = try comptimeExpr(gz, scope, .{ .rl = .{ .ty = .const_slice_u8_type } }, params[1]);
75387552 const field_type = try gz.addPlNode(.field_type_ref, params[1], Zir.Inst.FieldTypeRef{
75397553 .container_type = union_type,
75407554 .field_name = field_name,
75417555 });
7542 const init = try reachableExpr(gz, scope, .{ .ty = field_type }, params[2], node);
7556 const init = try reachableExpr(gz, scope, .{ .rl = .{ .ty = field_type } }, params[2], node);
75437557 const result = try gz.addPlNode(.union_init, node, Zir.Inst.UnionInit{
75447558 .union_type = union_type,
75457559 .init = init,
75467560 .field_name = field_name,
75477561 });
7548 return rvalue(gz, rl, result, node);
7562 return rvalue(gz, ri, result, node);
75497563}
75507564
75517565fn asRlPtr(
75527566 parent_gz: *GenZir,
75537567 scope: *Scope,
7554 rl: ResultLoc,
7568 ri: ResultInfo,
75557569 src_node: Ast.Node.Index,
75567570 result_ptr: Zir.Inst.Ref,
75577571 operand_node: Ast.Node.Index,
......@@ -7560,31 +7574,31 @@ fn asRlPtr(
75607574 var as_scope = try parent_gz.makeCoercionScope(scope, dest_type, result_ptr, src_node);
75617575 defer as_scope.unstack();
75627576
7563 const result = try reachableExpr(&as_scope, &as_scope.base, .{ .block_ptr = &as_scope }, operand_node, src_node);
7564 return as_scope.finishCoercion(parent_gz, rl, operand_node, result, dest_type);
7577 const result = try reachableExpr(&as_scope, &as_scope.base, .{ .rl = .{ .block_ptr = &as_scope } }, operand_node, src_node);
7578 return as_scope.finishCoercion(parent_gz, ri, operand_node, result, dest_type);
75657579}
75667580
75677581fn bitCast(
75687582 gz: *GenZir,
75697583 scope: *Scope,
7570 rl: ResultLoc,
7584 ri: ResultInfo,
75717585 node: Ast.Node.Index,
75727586 lhs: Ast.Node.Index,
75737587 rhs: Ast.Node.Index,
75747588) InnerError!Zir.Inst.Ref {
75757589 const dest_type = try reachableTypeExpr(gz, scope, lhs, node);
7576 const operand = try reachableExpr(gz, scope, .none, rhs, node);
7590 const operand = try reachableExpr(gz, scope, .{ .rl = .none }, rhs, node);
75777591 const result = try gz.addPlNode(.bitcast, node, Zir.Inst.Bin{
75787592 .lhs = dest_type,
75797593 .rhs = operand,
75807594 });
7581 return rvalue(gz, rl, result, node);
7595 return rvalue(gz, ri, result, node);
75827596}
75837597
75847598fn typeOf(
75857599 gz: *GenZir,
75867600 scope: *Scope,
7587 rl: ResultLoc,
7601 ri: ResultInfo,
75887602 node: Ast.Node.Index,
75897603 args: []const Ast.Node.Index,
75907604) InnerError!Zir.Inst.Ref {
......@@ -7600,7 +7614,7 @@ fn typeOf(
76007614 typeof_scope.force_comptime = false;
76017615 defer typeof_scope.unstack();
76027616
7603 const ty_expr = try reachableExpr(&typeof_scope, &typeof_scope.base, .none, args[0], node);
7617 const ty_expr = try reachableExpr(&typeof_scope, &typeof_scope.base, .{ .rl = .none }, args[0], node);
76047618 if (!gz.refIsNoReturn(ty_expr)) {
76057619 _ = try typeof_scope.addBreak(.break_inline, typeof_inst, ty_expr);
76067620 }
......@@ -7608,7 +7622,7 @@ fn typeOf(
76087622
76097623 // typeof_scope unstacked now, can add new instructions to gz
76107624 try gz.instructions.append(gpa, typeof_inst);
7611 return rvalue(gz, rl, indexToRef(typeof_inst), node);
7625 return rvalue(gz, ri, indexToRef(typeof_inst), node);
76127626 }
76137627 const payload_size: u32 = std.meta.fields(Zir.Inst.TypeOfPeer).len;
76147628 const payload_index = try reserveExtra(astgen, payload_size + args.len);
......@@ -7620,7 +7634,7 @@ fn typeOf(
76207634 typeof_scope.force_comptime = false;
76217635
76227636 for (args) |arg, i| {
7623 const param_ref = try reachableExpr(&typeof_scope, &typeof_scope.base, .none, arg, node);
7637 const param_ref = try reachableExpr(&typeof_scope, &typeof_scope.base, .{ .rl = .none }, arg, node);
76247638 astgen.extra.items[args_index + i] = @enumToInt(param_ref);
76257639 }
76267640 _ = try typeof_scope.addBreak(.break_inline, refToIndex(typeof_inst).?, .void_value);
......@@ -7636,13 +7650,13 @@ fn typeOf(
76367650 astgen.appendBodyWithFixups(body);
76377651 typeof_scope.unstack();
76387652
7639 return rvalue(gz, rl, typeof_inst, node);
7653 return rvalue(gz, ri, typeof_inst, node);
76407654}
76417655
76427656fn builtinCall(
76437657 gz: *GenZir,
76447658 scope: *Scope,
7645 rl: ResultLoc,
7659 ri: ResultInfo,
76467660 node: Ast.Node.Index,
76477661 params: []const Ast.Node.Index,
76487662) InnerError!Zir.Inst.Ref {
......@@ -7694,7 +7708,7 @@ fn builtinCall(
76947708 if (!gop.found_existing) {
76957709 gop.value_ptr.* = str_lit_token;
76967710 }
7697 return rvalue(gz, rl, result, node);
7711 return rvalue(gz, ri, result, node);
76987712 },
76997713 .compile_log => {
77007714 const payload_index = try addExtra(gz.astgen, Zir.Inst.NodeMultiOp{
......@@ -7702,32 +7716,32 @@ fn builtinCall(
77027716 });
77037717 var extra_index = try reserveExtra(gz.astgen, params.len);
77047718 for (params) |param| {
7705 const param_ref = try expr(gz, scope, .none, param);
7719 const param_ref = try expr(gz, scope, .{ .rl = .none }, param);
77067720 astgen.extra.items[extra_index] = @enumToInt(param_ref);
77077721 extra_index += 1;
77087722 }
77097723 const result = try gz.addExtendedMultiOpPayloadIndex(.compile_log, payload_index, params.len);
7710 return rvalue(gz, rl, result, node);
7724 return rvalue(gz, ri, result, node);
77117725 },
77127726 .field => {
7713 if (rl == .ref or rl == .catch_ref) {
7727 if (ri.rl == .ref) {
77147728 return gz.addPlNode(.field_ptr_named, node, Zir.Inst.FieldNamed{
7715 .lhs = try expr(gz, scope, .ref, params[0]),
7716 .field_name = try comptimeExpr(gz, scope, .{ .ty = .const_slice_u8_type }, params[1]),
7729 .lhs = try expr(gz, scope, .{ .rl = .ref }, params[0]),
7730 .field_name = try comptimeExpr(gz, scope, .{ .rl = .{ .ty = .const_slice_u8_type } }, params[1]),
77177731 });
77187732 }
77197733 const result = try gz.addPlNode(.field_val_named, node, Zir.Inst.FieldNamed{
7720 .lhs = try expr(gz, scope, .none, params[0]),
7721 .field_name = try comptimeExpr(gz, scope, .{ .ty = .const_slice_u8_type }, params[1]),
7734 .lhs = try expr(gz, scope, .{ .rl = .none }, params[0]),
7735 .field_name = try comptimeExpr(gz, scope, .{ .rl = .{ .ty = .const_slice_u8_type } }, params[1]),
77227736 });
7723 return rvalue(gz, rl, result, node);
7737 return rvalue(gz, ri, result, node);
77247738 },
77257739
77267740 // zig fmt: off
7727 .as => return as( gz, scope, rl, node, params[0], params[1]),
7728 .bit_cast => return bitCast( gz, scope, rl, node, params[0], params[1]),
7729 .TypeOf => return typeOf( gz, scope, rl, node, params),
7730 .union_init => return unionInit(gz, scope, rl, node, params),
7741 .as => return as( gz, scope, ri, node, params[0], params[1]),
7742 .bit_cast => return bitCast( gz, scope, ri, node, params[0], params[1]),
7743 .TypeOf => return typeOf( gz, scope, ri, node, params),
7744 .union_init => return unionInit(gz, scope, ri, node, params),
77317745 .c_import => return cImport( gz, scope, node, params[0]),
77327746 // zig fmt: on
77337747
......@@ -7752,9 +7766,9 @@ fn builtinCall(
77527766 local_val.used = ident_token;
77537767 _ = try gz.addPlNode(.export_value, node, Zir.Inst.ExportValue{
77547768 .operand = local_val.inst,
7755 .options = try comptimeExpr(gz, scope, .{ .coerced_ty = .export_options_type }, params[1]),
7769 .options = try comptimeExpr(gz, scope, .{ .rl = .{ .coerced_ty = .export_options_type } }, params[1]),
77567770 });
7757 return rvalue(gz, rl, .void_value, node);
7771 return rvalue(gz, ri, .void_value, node);
77587772 }
77597773 s = local_val.parent;
77607774 },
......@@ -7767,9 +7781,9 @@ fn builtinCall(
77677781 const loaded = try gz.addUnNode(.load, local_ptr.ptr, node);
77687782 _ = try gz.addPlNode(.export_value, node, Zir.Inst.ExportValue{
77697783 .operand = loaded,
7770 .options = try comptimeExpr(gz, scope, .{ .coerced_ty = .export_options_type }, params[1]),
7784 .options = try comptimeExpr(gz, scope, .{ .rl = .{ .coerced_ty = .export_options_type } }, params[1]),
77717785 });
7772 return rvalue(gz, rl, .void_value, node);
7786 return rvalue(gz, ri, .void_value, node);
77737787 }
77747788 s = local_ptr.parent;
77757789 },
......@@ -7801,47 +7815,47 @@ fn builtinCall(
78017815 },
78027816 else => return astgen.failNode(params[0], "symbol to export must identify a declaration", .{}),
78037817 }
7804 const options = try comptimeExpr(gz, scope, .{ .ty = .export_options_type }, params[1]);
7818 const options = try comptimeExpr(gz, scope, .{ .rl = .{ .ty = .export_options_type } }, params[1]);
78057819 _ = try gz.addPlNode(.@"export", node, Zir.Inst.Export{
78067820 .namespace = namespace,
78077821 .decl_name = decl_name,
78087822 .options = options,
78097823 });
7810 return rvalue(gz, rl, .void_value, node);
7824 return rvalue(gz, ri, .void_value, node);
78117825 },
78127826 .@"extern" => {
78137827 const type_inst = try typeExpr(gz, scope, params[0]);
7814 const options = try comptimeExpr(gz, scope, .{ .ty = .extern_options_type }, params[1]);
7828 const options = try comptimeExpr(gz, scope, .{ .rl = .{ .ty = .extern_options_type } }, params[1]);
78157829 const result = try gz.addExtendedPayload(.builtin_extern, Zir.Inst.BinNode{
78167830 .node = gz.nodeIndexToRelative(node),
78177831 .lhs = type_inst,
78187832 .rhs = options,
78197833 });
7820 return rvalue(gz, rl, result, node);
7834 return rvalue(gz, ri, result, node);
78217835 },
78227836 .fence => {
7823 const order = try expr(gz, scope, .{ .coerced_ty = .atomic_order_type }, params[0]);
7837 const order = try expr(gz, scope, .{ .rl = .{ .coerced_ty = .atomic_order_type } }, params[0]);
78247838 const result = try gz.addExtendedPayload(.fence, Zir.Inst.UnNode{
78257839 .node = gz.nodeIndexToRelative(node),
78267840 .operand = order,
78277841 });
7828 return rvalue(gz, rl, result, node);
7842 return rvalue(gz, ri, result, node);
78297843 },
78307844 .set_float_mode => {
7831 const order = try expr(gz, scope, .{ .coerced_ty = .float_mode_type }, params[0]);
7845 const order = try expr(gz, scope, .{ .rl = .{ .coerced_ty = .float_mode_type } }, params[0]);
78327846 const result = try gz.addExtendedPayload(.set_float_mode, Zir.Inst.UnNode{
78337847 .node = gz.nodeIndexToRelative(node),
78347848 .operand = order,
78357849 });
7836 return rvalue(gz, rl, result, node);
7850 return rvalue(gz, ri, result, node);
78377851 },
78387852 .set_align_stack => {
7839 const order = try expr(gz, scope, align_rl, params[0]);
7853 const order = try expr(gz, scope, align_ri, params[0]);
78407854 const result = try gz.addExtendedPayload(.set_align_stack, Zir.Inst.UnNode{
78417855 .node = gz.nodeIndexToRelative(node),
78427856 .operand = order,
78437857 });
7844 return rvalue(gz, rl, result, node);
7858 return rvalue(gz, ri, result, node);
78457859 },
78467860
78477861 .src => {
......@@ -7853,62 +7867,62 @@ fn builtinCall(
78537867 .line = astgen.source_line,
78547868 .column = astgen.source_column,
78557869 });
7856 return rvalue(gz, rl, result, node);
7870 return rvalue(gz, ri, result, node);
78577871 },
78587872
78597873 // zig fmt: off
7860 .This => return rvalue(gz, rl, try gz.addNodeExtended(.this, node), node),
7861 .return_address => return rvalue(gz, rl, try gz.addNodeExtended(.ret_addr, node), node),
7862 .error_return_trace => return rvalue(gz, rl, try gz.addNodeExtended(.error_return_trace, node), node),
7863 .frame => return rvalue(gz, rl, try gz.addNodeExtended(.frame, node), node),
7864 .frame_address => return rvalue(gz, rl, try gz.addNodeExtended(.frame_address, node), node),
7865 .breakpoint => return rvalue(gz, rl, try gz.addNodeExtended(.breakpoint, node), node),
7866
7867 .type_info => return simpleUnOpType(gz, scope, rl, node, params[0], .type_info),
7868 .size_of => return simpleUnOpType(gz, scope, rl, node, params[0], .size_of),
7869 .bit_size_of => return simpleUnOpType(gz, scope, rl, node, params[0], .bit_size_of),
7870 .align_of => return simpleUnOpType(gz, scope, rl, node, params[0], .align_of),
7871
7872 .ptr_to_int => return simpleUnOp(gz, scope, rl, node, .none, params[0], .ptr_to_int),
7873 .compile_error => return simpleUnOp(gz, scope, rl, node, .{ .ty = .const_slice_u8_type }, params[0], .compile_error),
7874 .set_eval_branch_quota => return simpleUnOp(gz, scope, rl, node, .{ .coerced_ty = .u32_type }, params[0], .set_eval_branch_quota),
7875 .enum_to_int => return simpleUnOp(gz, scope, rl, node, .none, params[0], .enum_to_int),
7876 .bool_to_int => return simpleUnOp(gz, scope, rl, node, bool_rl, params[0], .bool_to_int),
7877 .embed_file => return simpleUnOp(gz, scope, rl, node, .{ .ty = .const_slice_u8_type }, params[0], .embed_file),
7878 .error_name => return simpleUnOp(gz, scope, rl, node, .{ .ty = .anyerror_type }, params[0], .error_name),
7879 .set_cold => return simpleUnOp(gz, scope, rl, node, bool_rl, params[0], .set_cold),
7880 .set_runtime_safety => return simpleUnOp(gz, scope, rl, node, bool_rl, params[0], .set_runtime_safety),
7881 .sqrt => return simpleUnOp(gz, scope, rl, node, .none, params[0], .sqrt),
7882 .sin => return simpleUnOp(gz, scope, rl, node, .none, params[0], .sin),
7883 .cos => return simpleUnOp(gz, scope, rl, node, .none, params[0], .cos),
7884 .tan => return simpleUnOp(gz, scope, rl, node, .none, params[0], .tan),
7885 .exp => return simpleUnOp(gz, scope, rl, node, .none, params[0], .exp),
7886 .exp2 => return simpleUnOp(gz, scope, rl, node, .none, params[0], .exp2),
7887 .log => return simpleUnOp(gz, scope, rl, node, .none, params[0], .log),
7888 .log2 => return simpleUnOp(gz, scope, rl, node, .none, params[0], .log2),
7889 .log10 => return simpleUnOp(gz, scope, rl, node, .none, params[0], .log10),
7890 .fabs => return simpleUnOp(gz, scope, rl, node, .none, params[0], .fabs),
7891 .floor => return simpleUnOp(gz, scope, rl, node, .none, params[0], .floor),
7892 .ceil => return simpleUnOp(gz, scope, rl, node, .none, params[0], .ceil),
7893 .trunc => return simpleUnOp(gz, scope, rl, node, .none, params[0], .trunc),
7894 .round => return simpleUnOp(gz, scope, rl, node, .none, params[0], .round),
7895 .tag_name => return simpleUnOp(gz, scope, rl, node, .none, params[0], .tag_name),
7896 .type_name => return simpleUnOp(gz, scope, rl, node, .none, params[0], .type_name),
7897 .Frame => return simpleUnOp(gz, scope, rl, node, .none, params[0], .frame_type),
7898 .frame_size => return simpleUnOp(gz, scope, rl, node, .none, params[0], .frame_size),
7899
7900 .float_to_int => return typeCast(gz, scope, rl, node, params[0], params[1], .float_to_int),
7901 .int_to_float => return typeCast(gz, scope, rl, node, params[0], params[1], .int_to_float),
7902 .int_to_ptr => return typeCast(gz, scope, rl, node, params[0], params[1], .int_to_ptr),
7903 .int_to_enum => return typeCast(gz, scope, rl, node, params[0], params[1], .int_to_enum),
7904 .float_cast => return typeCast(gz, scope, rl, node, params[0], params[1], .float_cast),
7905 .int_cast => return typeCast(gz, scope, rl, node, params[0], params[1], .int_cast),
7906 .ptr_cast => return typeCast(gz, scope, rl, node, params[0], params[1], .ptr_cast),
7907 .truncate => return typeCast(gz, scope, rl, node, params[0], params[1], .truncate),
7874 .This => return rvalue(gz, ri, try gz.addNodeExtended(.this, node), node),
7875 .return_address => return rvalue(gz, ri, try gz.addNodeExtended(.ret_addr, node), node),
7876 .error_return_trace => return rvalue(gz, ri, try gz.addNodeExtended(.error_return_trace, node), node),
7877 .frame => return rvalue(gz, ri, try gz.addNodeExtended(.frame, node), node),
7878 .frame_address => return rvalue(gz, ri, try gz.addNodeExtended(.frame_address, node), node),
7879 .breakpoint => return rvalue(gz, ri, try gz.addNodeExtended(.breakpoint, node), node),
7880
7881 .type_info => return simpleUnOpType(gz, scope, ri, node, params[0], .type_info),
7882 .size_of => return simpleUnOpType(gz, scope, ri, node, params[0], .size_of),
7883 .bit_size_of => return simpleUnOpType(gz, scope, ri, node, params[0], .bit_size_of),
7884 .align_of => return simpleUnOpType(gz, scope, ri, node, params[0], .align_of),
7885
7886 .ptr_to_int => return simpleUnOp(gz, scope, ri, node, .{ .rl = .none }, params[0], .ptr_to_int),
7887 .compile_error => return simpleUnOp(gz, scope, ri, node, .{ .rl = .{ .ty = .const_slice_u8_type } }, params[0], .compile_error),
7888 .set_eval_branch_quota => return simpleUnOp(gz, scope, ri, node, .{ .rl = .{ .coerced_ty = .u32_type } }, params[0], .set_eval_branch_quota),
7889 .enum_to_int => return simpleUnOp(gz, scope, ri, node, .{ .rl = .none }, params[0], .enum_to_int),
7890 .bool_to_int => return simpleUnOp(gz, scope, ri, node, bool_ri, params[0], .bool_to_int),
7891 .embed_file => return simpleUnOp(gz, scope, ri, node, .{ .rl = .{ .ty = .const_slice_u8_type } }, params[0], .embed_file),
7892 .error_name => return simpleUnOp(gz, scope, ri, node, .{ .rl = .{ .ty = .anyerror_type } }, params[0], .error_name),
7893 .set_cold => return simpleUnOp(gz, scope, ri, node, bool_ri, params[0], .set_cold),
7894 .set_runtime_safety => return simpleUnOp(gz, scope, ri, node, bool_ri, params[0], .set_runtime_safety),
7895 .sqrt => return simpleUnOp(gz, scope, ri, node, .{ .rl = .none }, params[0], .sqrt),
7896 .sin => return simpleUnOp(gz, scope, ri, node, .{ .rl = .none }, params[0], .sin),
7897 .cos => return simpleUnOp(gz, scope, ri, node, .{ .rl = .none }, params[0], .cos),
7898 .tan => return simpleUnOp(gz, scope, ri, node, .{ .rl = .none }, params[0], .tan),
7899 .exp => return simpleUnOp(gz, scope, ri, node, .{ .rl = .none }, params[0], .exp),
7900 .exp2 => return simpleUnOp(gz, scope, ri, node, .{ .rl = .none }, params[0], .exp2),
7901 .log => return simpleUnOp(gz, scope, ri, node, .{ .rl = .none }, params[0], .log),
7902 .log2 => return simpleUnOp(gz, scope, ri, node, .{ .rl = .none }, params[0], .log2),
7903 .log10 => return simpleUnOp(gz, scope, ri, node, .{ .rl = .none }, params[0], .log10),
7904 .fabs => return simpleUnOp(gz, scope, ri, node, .{ .rl = .none }, params[0], .fabs),
7905 .floor => return simpleUnOp(gz, scope, ri, node, .{ .rl = .none }, params[0], .floor),
7906 .ceil => return simpleUnOp(gz, scope, ri, node, .{ .rl = .none }, params[0], .ceil),
7907 .trunc => return simpleUnOp(gz, scope, ri, node, .{ .rl = .none }, params[0], .trunc),
7908 .round => return simpleUnOp(gz, scope, ri, node, .{ .rl = .none }, params[0], .round),
7909 .tag_name => return simpleUnOp(gz, scope, ri, node, .{ .rl = .none }, params[0], .tag_name),
7910 .type_name => return simpleUnOp(gz, scope, ri, node, .{ .rl = .none }, params[0], .type_name),
7911 .Frame => return simpleUnOp(gz, scope, ri, node, .{ .rl = .none }, params[0], .frame_type),
7912 .frame_size => return simpleUnOp(gz, scope, ri, node, .{ .rl = .none }, params[0], .frame_size),
7913
7914 .float_to_int => return typeCast(gz, scope, ri, node, params[0], params[1], .float_to_int),
7915 .int_to_float => return typeCast(gz, scope, ri, node, params[0], params[1], .int_to_float),
7916 .int_to_ptr => return typeCast(gz, scope, ri, node, params[0], params[1], .int_to_ptr),
7917 .int_to_enum => return typeCast(gz, scope, ri, node, params[0], params[1], .int_to_enum),
7918 .float_cast => return typeCast(gz, scope, ri, node, params[0], params[1], .float_cast),
7919 .int_cast => return typeCast(gz, scope, ri, node, params[0], params[1], .int_cast),
7920 .ptr_cast => return typeCast(gz, scope, ri, node, params[0], params[1], .ptr_cast),
7921 .truncate => return typeCast(gz, scope, ri, node, params[0], params[1], .truncate),
79087922 // zig fmt: on
79097923
79107924 .Type => {
7911 const operand = try expr(gz, scope, .{ .coerced_ty = .type_info_type }, params[0]);
7925 const operand = try expr(gz, scope, .{ .rl = .{ .coerced_ty = .type_info_type } }, params[0]);
79127926
79137927 const gpa = gz.astgen.gpa;
79147928
......@@ -7930,219 +7944,219 @@ fn builtinCall(
79307944 });
79317945 gz.instructions.appendAssumeCapacity(new_index);
79327946 const result = indexToRef(new_index);
7933 return rvalue(gz, rl, result, node);
7947 return rvalue(gz, ri, result, node);
79347948 },
79357949 .panic => {
79367950 try emitDbgNode(gz, node);
7937 return simpleUnOp(gz, scope, rl, node, .{ .ty = .const_slice_u8_type }, params[0], if (gz.force_comptime) .panic_comptime else .panic);
7951 return simpleUnOp(gz, scope, ri, node, .{ .rl = .{ .ty = .const_slice_u8_type } }, params[0], if (gz.force_comptime) .panic_comptime else .panic);
79387952 },
79397953 .error_to_int => {
7940 const operand = try expr(gz, scope, .none, params[0]);
7954 const operand = try expr(gz, scope, .{ .rl = .none }, params[0]);
79417955 const result = try gz.addExtendedPayload(.error_to_int, Zir.Inst.UnNode{
79427956 .node = gz.nodeIndexToRelative(node),
79437957 .operand = operand,
79447958 });
7945 return rvalue(gz, rl, result, node);
7959 return rvalue(gz, ri, result, node);
79467960 },
79477961 .int_to_error => {
7948 const operand = try expr(gz, scope, .{ .coerced_ty = .u16_type }, params[0]);
7962 const operand = try expr(gz, scope, .{ .rl = .{ .coerced_ty = .u16_type } }, params[0]);
79497963 const result = try gz.addExtendedPayload(.int_to_error, Zir.Inst.UnNode{
79507964 .node = gz.nodeIndexToRelative(node),
79517965 .operand = operand,
79527966 });
7953 return rvalue(gz, rl, result, node);
7967 return rvalue(gz, ri, result, node);
79547968 },
79557969 .align_cast => {
7956 const dest_align = try comptimeExpr(gz, scope, align_rl, params[0]);
7957 const rhs = try expr(gz, scope, .none, params[1]);
7970 const dest_align = try comptimeExpr(gz, scope, align_ri, params[0]);
7971 const rhs = try expr(gz, scope, .{ .rl = .none }, params[1]);
79587972 const result = try gz.addPlNode(.align_cast, node, Zir.Inst.Bin{
79597973 .lhs = dest_align,
79607974 .rhs = rhs,
79617975 });
7962 return rvalue(gz, rl, result, node);
7976 return rvalue(gz, ri, result, node);
79637977 },
79647978 .err_set_cast => {
79657979 const result = try gz.addExtendedPayload(.err_set_cast, Zir.Inst.BinNode{
79667980 .lhs = try typeExpr(gz, scope, params[0]),
7967 .rhs = try expr(gz, scope, .none, params[1]),
7981 .rhs = try expr(gz, scope, .{ .rl = .none }, params[1]),
79687982 .node = gz.nodeIndexToRelative(node),
79697983 });
7970 return rvalue(gz, rl, result, node);
7984 return rvalue(gz, ri, result, node);
79717985 },
79727986 .addrspace_cast => {
79737987 const result = try gz.addExtendedPayload(.addrspace_cast, Zir.Inst.BinNode{
7974 .lhs = try comptimeExpr(gz, scope, .{ .ty = .address_space_type }, params[0]),
7975 .rhs = try expr(gz, scope, .none, params[1]),
7988 .lhs = try comptimeExpr(gz, scope, .{ .rl = .{ .ty = .address_space_type } }, params[0]),
7989 .rhs = try expr(gz, scope, .{ .rl = .none }, params[1]),
79767990 .node = gz.nodeIndexToRelative(node),
79777991 });
7978 return rvalue(gz, rl, result, node);
7992 return rvalue(gz, ri, result, node);
79797993 },
79807994
79817995 // zig fmt: off
7982 .has_decl => return hasDeclOrField(gz, scope, rl, node, params[0], params[1], .has_decl),
7983 .has_field => return hasDeclOrField(gz, scope, rl, node, params[0], params[1], .has_field),
7996 .has_decl => return hasDeclOrField(gz, scope, ri, node, params[0], params[1], .has_decl),
7997 .has_field => return hasDeclOrField(gz, scope, ri, node, params[0], params[1], .has_field),
79847998
7985 .clz => return bitBuiltin(gz, scope, rl, node, params[0], .clz),
7986 .ctz => return bitBuiltin(gz, scope, rl, node, params[0], .ctz),
7987 .pop_count => return bitBuiltin(gz, scope, rl, node, params[0], .pop_count),
7988 .byte_swap => return bitBuiltin(gz, scope, rl, node, params[0], .byte_swap),
7989 .bit_reverse => return bitBuiltin(gz, scope, rl, node, params[0], .bit_reverse),
7999 .clz => return bitBuiltin(gz, scope, ri, node, params[0], .clz),
8000 .ctz => return bitBuiltin(gz, scope, ri, node, params[0], .ctz),
8001 .pop_count => return bitBuiltin(gz, scope, ri, node, params[0], .pop_count),
8002 .byte_swap => return bitBuiltin(gz, scope, ri, node, params[0], .byte_swap),
8003 .bit_reverse => return bitBuiltin(gz, scope, ri, node, params[0], .bit_reverse),
79908004
7991 .div_exact => return divBuiltin(gz, scope, rl, node, params[0], params[1], .div_exact),
7992 .div_floor => return divBuiltin(gz, scope, rl, node, params[0], params[1], .div_floor),
7993 .div_trunc => return divBuiltin(gz, scope, rl, node, params[0], params[1], .div_trunc),
7994 .mod => return divBuiltin(gz, scope, rl, node, params[0], params[1], .mod),
7995 .rem => return divBuiltin(gz, scope, rl, node, params[0], params[1], .rem),
8005 .div_exact => return divBuiltin(gz, scope, ri, node, params[0], params[1], .div_exact),
8006 .div_floor => return divBuiltin(gz, scope, ri, node, params[0], params[1], .div_floor),
8007 .div_trunc => return divBuiltin(gz, scope, ri, node, params[0], params[1], .div_trunc),
8008 .mod => return divBuiltin(gz, scope, ri, node, params[0], params[1], .mod),
8009 .rem => return divBuiltin(gz, scope, ri, node, params[0], params[1], .rem),
79968010
7997 .shl_exact => return shiftOp(gz, scope, rl, node, params[0], params[1], .shl_exact),
7998 .shr_exact => return shiftOp(gz, scope, rl, node, params[0], params[1], .shr_exact),
8011 .shl_exact => return shiftOp(gz, scope, ri, node, params[0], params[1], .shl_exact),
8012 .shr_exact => return shiftOp(gz, scope, ri, node, params[0], params[1], .shr_exact),
79998013
8000 .bit_offset_of => return offsetOf(gz, scope, rl, node, params[0], params[1], .bit_offset_of),
8001 .offset_of => return offsetOf(gz, scope, rl, node, params[0], params[1], .offset_of),
8014 .bit_offset_of => return offsetOf(gz, scope, ri, node, params[0], params[1], .bit_offset_of),
8015 .offset_of => return offsetOf(gz, scope, ri, node, params[0], params[1], .offset_of),
80028016
8003 .c_undef => return simpleCBuiltin(gz, scope, rl, node, params[0], .c_undef),
8004 .c_include => return simpleCBuiltin(gz, scope, rl, node, params[0], .c_include),
8017 .c_undef => return simpleCBuiltin(gz, scope, ri, node, params[0], .c_undef),
8018 .c_include => return simpleCBuiltin(gz, scope, ri, node, params[0], .c_include),
80058019
8006 .cmpxchg_strong => return cmpxchg(gz, scope, rl, node, params, 1),
8007 .cmpxchg_weak => return cmpxchg(gz, scope, rl, node, params, 0),
8020 .cmpxchg_strong => return cmpxchg(gz, scope, ri, node, params, 1),
8021 .cmpxchg_weak => return cmpxchg(gz, scope, ri, node, params, 0),
80088022 // zig fmt: on
80098023
80108024 .wasm_memory_size => {
8011 const operand = try comptimeExpr(gz, scope, .{ .coerced_ty = .u32_type }, params[0]);
8025 const operand = try comptimeExpr(gz, scope, .{ .rl = .{ .coerced_ty = .u32_type } }, params[0]);
80128026 const result = try gz.addExtendedPayload(.wasm_memory_size, Zir.Inst.UnNode{
80138027 .node = gz.nodeIndexToRelative(node),
80148028 .operand = operand,
80158029 });
8016 return rvalue(gz, rl, result, node);
8030 return rvalue(gz, ri, result, node);
80178031 },
80188032 .wasm_memory_grow => {
8019 const index_arg = try comptimeExpr(gz, scope, .{ .coerced_ty = .u32_type }, params[0]);
8020 const delta_arg = try expr(gz, scope, .{ .coerced_ty = .u32_type }, params[1]);
8033 const index_arg = try comptimeExpr(gz, scope, .{ .rl = .{ .coerced_ty = .u32_type } }, params[0]);
8034 const delta_arg = try expr(gz, scope, .{ .rl = .{ .coerced_ty = .u32_type } }, params[1]);
80218035 const result = try gz.addExtendedPayload(.wasm_memory_grow, Zir.Inst.BinNode{
80228036 .node = gz.nodeIndexToRelative(node),
80238037 .lhs = index_arg,
80248038 .rhs = delta_arg,
80258039 });
8026 return rvalue(gz, rl, result, node);
8040 return rvalue(gz, ri, result, node);
80278041 },
80288042 .c_define => {
80298043 if (!gz.c_import) return gz.astgen.failNode(node, "C define valid only inside C import block", .{});
8030 const name = try comptimeExpr(gz, scope, .{ .ty = .const_slice_u8_type }, params[0]);
8031 const value = try comptimeExpr(gz, scope, .none, params[1]);
8044 const name = try comptimeExpr(gz, scope, .{ .rl = .{ .ty = .const_slice_u8_type } }, params[0]);
8045 const value = try comptimeExpr(gz, scope, .{ .rl = .none }, params[1]);
80328046 const result = try gz.addExtendedPayload(.c_define, Zir.Inst.BinNode{
80338047 .node = gz.nodeIndexToRelative(node),
80348048 .lhs = name,
80358049 .rhs = value,
80368050 });
8037 return rvalue(gz, rl, result, node);
8051 return rvalue(gz, ri, result, node);
80388052 },
80398053
80408054 .splat => {
8041 const len = try expr(gz, scope, .{ .coerced_ty = .u32_type }, params[0]);
8042 const scalar = try expr(gz, scope, .none, params[1]);
8055 const len = try expr(gz, scope, .{ .rl = .{ .coerced_ty = .u32_type } }, params[0]);
8056 const scalar = try expr(gz, scope, .{ .rl = .none }, params[1]);
80438057 const result = try gz.addPlNode(.splat, node, Zir.Inst.Bin{
80448058 .lhs = len,
80458059 .rhs = scalar,
80468060 });
8047 return rvalue(gz, rl, result, node);
8061 return rvalue(gz, ri, result, node);
80488062 },
80498063 .reduce => {
8050 const op = try expr(gz, scope, .{ .ty = .reduce_op_type }, params[0]);
8051 const scalar = try expr(gz, scope, .none, params[1]);
8064 const op = try expr(gz, scope, .{ .rl = .{ .ty = .reduce_op_type } }, params[0]);
8065 const scalar = try expr(gz, scope, .{ .rl = .none }, params[1]);
80528066 const result = try gz.addPlNode(.reduce, node, Zir.Inst.Bin{
80538067 .lhs = op,
80548068 .rhs = scalar,
80558069 });
8056 return rvalue(gz, rl, result, node);
8070 return rvalue(gz, ri, result, node);
80578071 },
80588072
80598073 .max => {
8060 const a = try expr(gz, scope, .none, params[0]);
8061 const b = try expr(gz, scope, .none, params[1]);
8074 const a = try expr(gz, scope, .{ .rl = .none }, params[0]);
8075 const b = try expr(gz, scope, .{ .rl = .none }, params[1]);
80628076 const result = try gz.addPlNode(.max, node, Zir.Inst.Bin{
80638077 .lhs = a,
80648078 .rhs = b,
80658079 });
8066 return rvalue(gz, rl, result, node);
8080 return rvalue(gz, ri, result, node);
80678081 },
80688082 .min => {
8069 const a = try expr(gz, scope, .none, params[0]);
8070 const b = try expr(gz, scope, .none, params[1]);
8083 const a = try expr(gz, scope, .{ .rl = .none }, params[0]);
8084 const b = try expr(gz, scope, .{ .rl = .none }, params[1]);
80718085 const result = try gz.addPlNode(.min, node, Zir.Inst.Bin{
80728086 .lhs = a,
80738087 .rhs = b,
80748088 });
8075 return rvalue(gz, rl, result, node);
8089 return rvalue(gz, ri, result, node);
80768090 },
80778091
8078 .add_with_overflow => return overflowArithmetic(gz, scope, rl, node, params, .add_with_overflow),
8079 .sub_with_overflow => return overflowArithmetic(gz, scope, rl, node, params, .sub_with_overflow),
8080 .mul_with_overflow => return overflowArithmetic(gz, scope, rl, node, params, .mul_with_overflow),
8092 .add_with_overflow => return overflowArithmetic(gz, scope, ri, node, params, .add_with_overflow),
8093 .sub_with_overflow => return overflowArithmetic(gz, scope, ri, node, params, .sub_with_overflow),
8094 .mul_with_overflow => return overflowArithmetic(gz, scope, ri, node, params, .mul_with_overflow),
80818095 .shl_with_overflow => {
80828096 const int_type = try typeExpr(gz, scope, params[0]);
80838097 const log2_int_type = try gz.addUnNode(.log2_int_type, int_type, params[0]);
80848098 const ptr_type = try gz.addUnNode(.overflow_arithmetic_ptr, int_type, params[0]);
8085 const lhs = try expr(gz, scope, .{ .ty = int_type }, params[1]);
8086 const rhs = try expr(gz, scope, .{ .ty = log2_int_type }, params[2]);
8087 const ptr = try expr(gz, scope, .{ .ty = ptr_type }, params[3]);
8099 const lhs = try expr(gz, scope, .{ .rl = .{ .ty = int_type } }, params[1]);
8100 const rhs = try expr(gz, scope, .{ .rl = .{ .ty = log2_int_type } }, params[2]);
8101 const ptr = try expr(gz, scope, .{ .rl = .{ .ty = ptr_type } }, params[3]);
80888102 const result = try gz.addExtendedPayload(.shl_with_overflow, Zir.Inst.OverflowArithmetic{
80898103 .node = gz.nodeIndexToRelative(node),
80908104 .lhs = lhs,
80918105 .rhs = rhs,
80928106 .ptr = ptr,
80938107 });
8094 return rvalue(gz, rl, result, node);
8108 return rvalue(gz, ri, result, node);
80958109 },
80968110
80978111 .atomic_load => {
80988112 const result = try gz.addPlNode(.atomic_load, node, Zir.Inst.AtomicLoad{
80998113 // zig fmt: off
8100 .elem_type = try typeExpr(gz, scope, params[0]),
8101 .ptr = try expr (gz, scope, .none, params[1]),
8102 .ordering = try expr (gz, scope, .{ .coerced_ty = .atomic_order_type }, params[2]),
8114 .elem_type = try typeExpr(gz, scope, params[0]),
8115 .ptr = try expr (gz, scope, .{ .rl = .none }, params[1]),
8116 .ordering = try expr (gz, scope, .{ .rl = .{ .coerced_ty = .atomic_order_type } }, params[2]),
81038117 // zig fmt: on
81048118 });
8105 return rvalue(gz, rl, result, node);
8119 return rvalue(gz, ri, result, node);
81068120 },
81078121 .atomic_rmw => {
81088122 const int_type = try typeExpr(gz, scope, params[0]);
81098123 const result = try gz.addPlNode(.atomic_rmw, node, Zir.Inst.AtomicRmw{
81108124 // zig fmt: off
8111 .ptr = try expr(gz, scope, .none, params[1]),
8112 .operation = try expr(gz, scope, .{ .coerced_ty = .atomic_rmw_op_type }, params[2]),
8113 .operand = try expr(gz, scope, .{ .ty = int_type }, params[3]),
8114 .ordering = try expr(gz, scope, .{ .coerced_ty = .atomic_order_type }, params[4]),
8125 .ptr = try expr(gz, scope, .{ .rl = .none }, params[1]),
8126 .operation = try expr(gz, scope, .{ .rl = .{ .coerced_ty = .atomic_rmw_op_type } }, params[2]),
8127 .operand = try expr(gz, scope, .{ .rl = .{ .ty = int_type } }, params[3]),
8128 .ordering = try expr(gz, scope, .{ .rl = .{ .coerced_ty = .atomic_order_type } }, params[4]),
81158129 // zig fmt: on
81168130 });
8117 return rvalue(gz, rl, result, node);
8131 return rvalue(gz, ri, result, node);
81188132 },
81198133 .atomic_store => {
81208134 const int_type = try typeExpr(gz, scope, params[0]);
81218135 const result = try gz.addPlNode(.atomic_store, node, Zir.Inst.AtomicStore{
81228136 // zig fmt: off
8123 .ptr = try expr(gz, scope, .none, params[1]),
8124 .operand = try expr(gz, scope, .{ .ty = int_type }, params[2]),
8125 .ordering = try expr(gz, scope, .{ .coerced_ty = .atomic_order_type }, params[3]),
8137 .ptr = try expr(gz, scope, .{ .rl = .none }, params[1]),
8138 .operand = try expr(gz, scope, .{ .rl = .{ .ty = int_type } }, params[2]),
8139 .ordering = try expr(gz, scope, .{ .rl = .{ .coerced_ty = .atomic_order_type } }, params[3]),
81268140 // zig fmt: on
81278141 });
8128 return rvalue(gz, rl, result, node);
8142 return rvalue(gz, ri, result, node);
81298143 },
81308144 .mul_add => {
81318145 const float_type = try typeExpr(gz, scope, params[0]);
8132 const mulend1 = try expr(gz, scope, .{ .coerced_ty = float_type }, params[1]);
8133 const mulend2 = try expr(gz, scope, .{ .coerced_ty = float_type }, params[2]);
8134 const addend = try expr(gz, scope, .{ .ty = float_type }, params[3]);
8146 const mulend1 = try expr(gz, scope, .{ .rl = .{ .coerced_ty = float_type } }, params[1]);
8147 const mulend2 = try expr(gz, scope, .{ .rl = .{ .coerced_ty = float_type } }, params[2]);
8148 const addend = try expr(gz, scope, .{ .rl = .{ .ty = float_type } }, params[3]);
81358149 const result = try gz.addPlNode(.mul_add, node, Zir.Inst.MulAdd{
81368150 .mulend1 = mulend1,
81378151 .mulend2 = mulend2,
81388152 .addend = addend,
81398153 });
8140 return rvalue(gz, rl, result, node);
8154 return rvalue(gz, ri, result, node);
81418155 },
81428156 .call => {
8143 const options = try comptimeExpr(gz, scope, .{ .ty = .call_options_type }, params[0]);
8157 const options = try comptimeExpr(gz, scope, .{ .rl = .{ .ty = .call_options_type } }, params[0]);
81448158 const callee = try calleeExpr(gz, scope, params[1]);
8145 const args = try expr(gz, scope, .none, params[2]);
8159 const args = try expr(gz, scope, .{ .rl = .none }, params[2]);
81468160 const result = try gz.addPlNode(.builtin_call, node, Zir.Inst.BuiltinCall{
81478161 .options = options,
81488162 .callee = callee,
......@@ -8153,115 +8167,115 @@ fn builtinCall(
81538167 .ensure_result_used = false,
81548168 },
81558169 });
8156 return rvalue(gz, rl, result, node);
8170 return rvalue(gz, ri, result, node);
81578171 },
81588172 .field_parent_ptr => {
81598173 const parent_type = try typeExpr(gz, scope, params[0]);
8160 const field_name = try comptimeExpr(gz, scope, .{ .ty = .const_slice_u8_type }, params[1]);
8174 const field_name = try comptimeExpr(gz, scope, .{ .rl = .{ .ty = .const_slice_u8_type } }, params[1]);
81618175 const result = try gz.addPlNode(.field_parent_ptr, node, Zir.Inst.FieldParentPtr{
81628176 .parent_type = parent_type,
81638177 .field_name = field_name,
8164 .field_ptr = try expr(gz, scope, .none, params[2]),
8178 .field_ptr = try expr(gz, scope, .{ .rl = .none }, params[2]),
81658179 });
8166 return rvalue(gz, rl, result, node);
8180 return rvalue(gz, ri, result, node);
81678181 },
81688182 .memcpy => {
81698183 const result = try gz.addPlNode(.memcpy, node, Zir.Inst.Memcpy{
8170 .dest = try expr(gz, scope, .{ .coerced_ty = .manyptr_u8_type }, params[0]),
8171 .source = try expr(gz, scope, .{ .coerced_ty = .manyptr_const_u8_type }, params[1]),
8172 .byte_count = try expr(gz, scope, .{ .coerced_ty = .usize_type }, params[2]),
8184 .dest = try expr(gz, scope, .{ .rl = .{ .coerced_ty = .manyptr_u8_type } }, params[0]),
8185 .source = try expr(gz, scope, .{ .rl = .{ .coerced_ty = .manyptr_const_u8_type } }, params[1]),
8186 .byte_count = try expr(gz, scope, .{ .rl = .{ .coerced_ty = .usize_type } }, params[2]),
81738187 });
8174 return rvalue(gz, rl, result, node);
8188 return rvalue(gz, ri, result, node);
81758189 },
81768190 .memset => {
81778191 const result = try gz.addPlNode(.memset, node, Zir.Inst.Memset{
8178 .dest = try expr(gz, scope, .{ .coerced_ty = .manyptr_u8_type }, params[0]),
8179 .byte = try expr(gz, scope, .{ .coerced_ty = .u8_type }, params[1]),
8180 .byte_count = try expr(gz, scope, .{ .coerced_ty = .usize_type }, params[2]),
8192 .dest = try expr(gz, scope, .{ .rl = .{ .coerced_ty = .manyptr_u8_type } }, params[0]),
8193 .byte = try expr(gz, scope, .{ .rl = .{ .coerced_ty = .u8_type } }, params[1]),
8194 .byte_count = try expr(gz, scope, .{ .rl = .{ .coerced_ty = .usize_type } }, params[2]),
81818195 });
8182 return rvalue(gz, rl, result, node);
8196 return rvalue(gz, ri, result, node);
81838197 },
81848198 .shuffle => {
81858199 const result = try gz.addPlNode(.shuffle, node, Zir.Inst.Shuffle{
81868200 .elem_type = try typeExpr(gz, scope, params[0]),
8187 .a = try expr(gz, scope, .none, params[1]),
8188 .b = try expr(gz, scope, .none, params[2]),
8189 .mask = try comptimeExpr(gz, scope, .none, params[3]),
8201 .a = try expr(gz, scope, .{ .rl = .none }, params[1]),
8202 .b = try expr(gz, scope, .{ .rl = .none }, params[2]),
8203 .mask = try comptimeExpr(gz, scope, .{ .rl = .none }, params[3]),
81908204 });
8191 return rvalue(gz, rl, result, node);
8205 return rvalue(gz, ri, result, node);
81928206 },
81938207 .select => {
81948208 const result = try gz.addExtendedPayload(.select, Zir.Inst.Select{
81958209 .node = gz.nodeIndexToRelative(node),
81968210 .elem_type = try typeExpr(gz, scope, params[0]),
8197 .pred = try expr(gz, scope, .none, params[1]),
8198 .a = try expr(gz, scope, .none, params[2]),
8199 .b = try expr(gz, scope, .none, params[3]),
8211 .pred = try expr(gz, scope, .{ .rl = .none }, params[1]),
8212 .a = try expr(gz, scope, .{ .rl = .none }, params[2]),
8213 .b = try expr(gz, scope, .{ .rl = .none }, params[3]),
82008214 });
8201 return rvalue(gz, rl, result, node);
8215 return rvalue(gz, ri, result, node);
82028216 },
82038217 .async_call => {
82048218 const result = try gz.addExtendedPayload(.builtin_async_call, Zir.Inst.AsyncCall{
82058219 .node = gz.nodeIndexToRelative(node),
8206 .frame_buffer = try expr(gz, scope, .none, params[0]),
8207 .result_ptr = try expr(gz, scope, .none, params[1]),
8208 .fn_ptr = try expr(gz, scope, .none, params[2]),
8209 .args = try expr(gz, scope, .none, params[3]),
8220 .frame_buffer = try expr(gz, scope, .{ .rl = .none }, params[0]),
8221 .result_ptr = try expr(gz, scope, .{ .rl = .none }, params[1]),
8222 .fn_ptr = try expr(gz, scope, .{ .rl = .none }, params[2]),
8223 .args = try expr(gz, scope, .{ .rl = .none }, params[3]),
82108224 });
8211 return rvalue(gz, rl, result, node);
8225 return rvalue(gz, ri, result, node);
82128226 },
82138227 .Vector => {
82148228 const result = try gz.addPlNode(.vector_type, node, Zir.Inst.Bin{
8215 .lhs = try comptimeExpr(gz, scope, .{ .coerced_ty = .u32_type }, params[0]),
8229 .lhs = try comptimeExpr(gz, scope, .{ .rl = .{ .coerced_ty = .u32_type } }, params[0]),
82168230 .rhs = try typeExpr(gz, scope, params[1]),
82178231 });
8218 return rvalue(gz, rl, result, node);
8232 return rvalue(gz, ri, result, node);
82198233 },
82208234 .prefetch => {
8221 const ptr = try expr(gz, scope, .none, params[0]);
8222 const options = try comptimeExpr(gz, scope, .{ .ty = .prefetch_options_type }, params[1]);
8235 const ptr = try expr(gz, scope, .{ .rl = .none }, params[0]);
8236 const options = try comptimeExpr(gz, scope, .{ .rl = .{ .ty = .prefetch_options_type } }, params[1]);
82238237 const result = try gz.addExtendedPayload(.prefetch, Zir.Inst.BinNode{
82248238 .node = gz.nodeIndexToRelative(node),
82258239 .lhs = ptr,
82268240 .rhs = options,
82278241 });
8228 return rvalue(gz, rl, result, node);
8242 return rvalue(gz, ri, result, node);
82298243 },
82308244 }
82318245}
82328246
82338247fn simpleNoOpVoid(
82348248 gz: *GenZir,
8235 rl: ResultLoc,
8249 ri: ResultInfo,
82368250 node: Ast.Node.Index,
82378251 tag: Zir.Inst.Tag,
82388252) InnerError!Zir.Inst.Ref {
82398253 _ = try gz.addNode(tag, node);
8240 return rvalue(gz, rl, .void_value, node);
8254 return rvalue(gz, ri, .void_value, node);
82418255}
82428256
82438257fn hasDeclOrField(
82448258 gz: *GenZir,
82458259 scope: *Scope,
8246 rl: ResultLoc,
8260 ri: ResultInfo,
82478261 node: Ast.Node.Index,
82488262 lhs_node: Ast.Node.Index,
82498263 rhs_node: Ast.Node.Index,
82508264 tag: Zir.Inst.Tag,
82518265) InnerError!Zir.Inst.Ref {
82528266 const container_type = try typeExpr(gz, scope, lhs_node);
8253 const name = try comptimeExpr(gz, scope, .{ .ty = .const_slice_u8_type }, rhs_node);
8267 const name = try comptimeExpr(gz, scope, .{ .rl = .{ .ty = .const_slice_u8_type } }, rhs_node);
82548268 const result = try gz.addPlNode(tag, node, Zir.Inst.Bin{
82558269 .lhs = container_type,
82568270 .rhs = name,
82578271 });
8258 return rvalue(gz, rl, result, node);
8272 return rvalue(gz, ri, result, node);
82598273}
82608274
82618275fn typeCast(
82628276 gz: *GenZir,
82638277 scope: *Scope,
8264 rl: ResultLoc,
8278 ri: ResultInfo,
82658279 node: Ast.Node.Index,
82668280 lhs_node: Ast.Node.Index,
82678281 rhs_node: Ast.Node.Index,
......@@ -8269,42 +8283,42 @@ fn typeCast(
82698283) InnerError!Zir.Inst.Ref {
82708284 const result = try gz.addPlNode(tag, node, Zir.Inst.Bin{
82718285 .lhs = try typeExpr(gz, scope, lhs_node),
8272 .rhs = try expr(gz, scope, .none, rhs_node),
8286 .rhs = try expr(gz, scope, .{ .rl = .none }, rhs_node),
82738287 });
8274 return rvalue(gz, rl, result, node);
8288 return rvalue(gz, ri, result, node);
82758289}
82768290
82778291fn simpleUnOpType(
82788292 gz: *GenZir,
82798293 scope: *Scope,
8280 rl: ResultLoc,
8294 ri: ResultInfo,
82818295 node: Ast.Node.Index,
82828296 operand_node: Ast.Node.Index,
82838297 tag: Zir.Inst.Tag,
82848298) InnerError!Zir.Inst.Ref {
82858299 const operand = try typeExpr(gz, scope, operand_node);
82868300 const result = try gz.addUnNode(tag, operand, node);
8287 return rvalue(gz, rl, result, node);
8301 return rvalue(gz, ri, result, node);
82888302}
82898303
82908304fn simpleUnOp(
82918305 gz: *GenZir,
82928306 scope: *Scope,
8293 rl: ResultLoc,
8307 ri: ResultInfo,
82948308 node: Ast.Node.Index,
8295 operand_rl: ResultLoc,
8309 operand_ri: ResultInfo,
82968310 operand_node: Ast.Node.Index,
82978311 tag: Zir.Inst.Tag,
82988312) InnerError!Zir.Inst.Ref {
8299 const operand = try expr(gz, scope, operand_rl, operand_node);
8313 const operand = try expr(gz, scope, operand_ri, operand_node);
83008314 const result = try gz.addUnNode(tag, operand, node);
8301 return rvalue(gz, rl, result, node);
8315 return rvalue(gz, ri, result, node);
83028316}
83038317
83048318fn negation(
83058319 gz: *GenZir,
83068320 scope: *Scope,
8307 rl: ResultLoc,
8321 ri: ResultInfo,
83088322 node: Ast.Node.Index,
83098323) InnerError!Zir.Inst.Ref {
83108324 const astgen = gz.astgen;
......@@ -8316,18 +8330,18 @@ fn negation(
83168330 // its negativity rather than having it go through comptime subtraction.
83178331 const operand_node = node_datas[node].lhs;
83188332 if (node_tags[operand_node] == .number_literal) {
8319 return numberLiteral(gz, rl, operand_node, node, .negative);
8333 return numberLiteral(gz, ri, operand_node, node, .negative);
83208334 }
83218335
8322 const operand = try expr(gz, scope, .none, operand_node);
8336 const operand = try expr(gz, scope, .{ .rl = .none }, operand_node);
83238337 const result = try gz.addUnNode(.negate, operand, node);
8324 return rvalue(gz, rl, result, node);
8338 return rvalue(gz, ri, result, node);
83258339}
83268340
83278341fn cmpxchg(
83288342 gz: *GenZir,
83298343 scope: *Scope,
8330 rl: ResultLoc,
8344 ri: ResultInfo,
83318345 node: Ast.Node.Index,
83328346 params: []const Ast.Node.Index,
83338347 small: u16,
......@@ -8336,98 +8350,98 @@ fn cmpxchg(
83368350 const result = try gz.addExtendedPayloadSmall(.cmpxchg, small, Zir.Inst.Cmpxchg{
83378351 // zig fmt: off
83388352 .node = gz.nodeIndexToRelative(node),
8339 .ptr = try expr(gz, scope, .none, params[1]),
8340 .expected_value = try expr(gz, scope, .{ .ty = int_type }, params[2]),
8341 .new_value = try expr(gz, scope, .{ .coerced_ty = int_type }, params[3]),
8342 .success_order = try expr(gz, scope, .{ .coerced_ty = .atomic_order_type }, params[4]),
8343 .failure_order = try expr(gz, scope, .{ .coerced_ty = .atomic_order_type }, params[5]),
8353 .ptr = try expr(gz, scope, .{ .rl = .none }, params[1]),
8354 .expected_value = try expr(gz, scope, .{ .rl = .{ .ty = int_type } }, params[2]),
8355 .new_value = try expr(gz, scope, .{ .rl = .{ .coerced_ty = int_type } }, params[3]),
8356 .success_order = try expr(gz, scope, .{ .rl = .{ .coerced_ty = .atomic_order_type } }, params[4]),
8357 .failure_order = try expr(gz, scope, .{ .rl = .{ .coerced_ty = .atomic_order_type } }, params[5]),
83448358 // zig fmt: on
83458359 });
8346 return rvalue(gz, rl, result, node);
8360 return rvalue(gz, ri, result, node);
83478361}
83488362
83498363fn bitBuiltin(
83508364 gz: *GenZir,
83518365 scope: *Scope,
8352 rl: ResultLoc,
8366 ri: ResultInfo,
83538367 node: Ast.Node.Index,
83548368 operand_node: Ast.Node.Index,
83558369 tag: Zir.Inst.Tag,
83568370) InnerError!Zir.Inst.Ref {
8357 const operand = try expr(gz, scope, .none, operand_node);
8371 const operand = try expr(gz, scope, .{ .rl = .none }, operand_node);
83588372 const result = try gz.addUnNode(tag, operand, node);
8359 return rvalue(gz, rl, result, node);
8373 return rvalue(gz, ri, result, node);
83608374}
83618375
83628376fn divBuiltin(
83638377 gz: *GenZir,
83648378 scope: *Scope,
8365 rl: ResultLoc,
8379 ri: ResultInfo,
83668380 node: Ast.Node.Index,
83678381 lhs_node: Ast.Node.Index,
83688382 rhs_node: Ast.Node.Index,
83698383 tag: Zir.Inst.Tag,
83708384) InnerError!Zir.Inst.Ref {
83718385 const result = try gz.addPlNode(tag, node, Zir.Inst.Bin{
8372 .lhs = try expr(gz, scope, .none, lhs_node),
8373 .rhs = try expr(gz, scope, .none, rhs_node),
8386 .lhs = try expr(gz, scope, .{ .rl = .none }, lhs_node),
8387 .rhs = try expr(gz, scope, .{ .rl = .none }, rhs_node),
83748388 });
8375 return rvalue(gz, rl, result, node);
8389 return rvalue(gz, ri, result, node);
83768390}
83778391
83788392fn simpleCBuiltin(
83798393 gz: *GenZir,
83808394 scope: *Scope,
8381 rl: ResultLoc,
8395 ri: ResultInfo,
83828396 node: Ast.Node.Index,
83838397 operand_node: Ast.Node.Index,
83848398 tag: Zir.Inst.Extended,
83858399) InnerError!Zir.Inst.Ref {
83868400 const name: []const u8 = if (tag == .c_undef) "C undef" else "C include";
83878401 if (!gz.c_import) return gz.astgen.failNode(node, "{s} valid only inside C import block", .{name});
8388 const operand = try comptimeExpr(gz, scope, .{ .ty = .const_slice_u8_type }, operand_node);
8402 const operand = try comptimeExpr(gz, scope, .{ .rl = .{ .ty = .const_slice_u8_type } }, operand_node);
83898403 _ = try gz.addExtendedPayload(tag, Zir.Inst.UnNode{
83908404 .node = gz.nodeIndexToRelative(node),
83918405 .operand = operand,
83928406 });
8393 return rvalue(gz, rl, .void_value, node);
8407 return rvalue(gz, ri, .void_value, node);
83948408}
83958409
83968410fn offsetOf(
83978411 gz: *GenZir,
83988412 scope: *Scope,
8399 rl: ResultLoc,
8413 ri: ResultInfo,
84008414 node: Ast.Node.Index,
84018415 lhs_node: Ast.Node.Index,
84028416 rhs_node: Ast.Node.Index,
84038417 tag: Zir.Inst.Tag,
84048418) InnerError!Zir.Inst.Ref {
84058419 const type_inst = try typeExpr(gz, scope, lhs_node);
8406 const field_name = try comptimeExpr(gz, scope, .{ .ty = .const_slice_u8_type }, rhs_node);
8420 const field_name = try comptimeExpr(gz, scope, .{ .rl = .{ .ty = .const_slice_u8_type } }, rhs_node);
84078421 const result = try gz.addPlNode(tag, node, Zir.Inst.Bin{
84088422 .lhs = type_inst,
84098423 .rhs = field_name,
84108424 });
8411 return rvalue(gz, rl, result, node);
8425 return rvalue(gz, ri, result, node);
84128426}
84138427
84148428fn shiftOp(
84158429 gz: *GenZir,
84168430 scope: *Scope,
8417 rl: ResultLoc,
8431 ri: ResultInfo,
84188432 node: Ast.Node.Index,
84198433 lhs_node: Ast.Node.Index,
84208434 rhs_node: Ast.Node.Index,
84218435 tag: Zir.Inst.Tag,
84228436) InnerError!Zir.Inst.Ref {
8423 const lhs = try expr(gz, scope, .none, lhs_node);
8437 const lhs = try expr(gz, scope, .{ .rl = .none }, lhs_node);
84248438 const log2_int_type = try gz.addUnNode(.typeof_log2_int_type, lhs, lhs_node);
8425 const rhs = try expr(gz, scope, .{ .ty_shift_operand = log2_int_type }, rhs_node);
8439 const rhs = try expr(gz, scope, .{ .rl = .{ .ty = log2_int_type }, .ctx = .shift_op }, rhs_node);
84268440 const result = try gz.addPlNode(tag, node, Zir.Inst.Bin{
84278441 .lhs = lhs,
84288442 .rhs = rhs,
84298443 });
8430 return rvalue(gz, rl, result, node);
8444 return rvalue(gz, ri, result, node);
84318445}
84328446
84338447fn cImport(
......@@ -8445,7 +8459,7 @@ fn cImport(
84458459 defer block_scope.unstack();
84468460
84478461 const block_inst = try gz.makeBlockInst(.c_import, node);
8448 const block_result = try expr(&block_scope, &block_scope.base, .none, body_node);
8462 const block_result = try expr(&block_scope, &block_scope.base, .{ .rl = .none }, body_node);
84498463 _ = try gz.addUnNode(.ensure_result_used, block_result, node);
84508464 if (!gz.refIsNoReturn(block_result)) {
84518465 _ = try block_scope.addBreak(.break_inline, block_inst, .void_value);
......@@ -8460,29 +8474,29 @@ fn cImport(
84608474fn overflowArithmetic(
84618475 gz: *GenZir,
84628476 scope: *Scope,
8463 rl: ResultLoc,
8477 ri: ResultInfo,
84648478 node: Ast.Node.Index,
84658479 params: []const Ast.Node.Index,
84668480 tag: Zir.Inst.Extended,
84678481) InnerError!Zir.Inst.Ref {
84688482 const int_type = try typeExpr(gz, scope, params[0]);
84698483 const ptr_type = try gz.addUnNode(.overflow_arithmetic_ptr, int_type, params[0]);
8470 const lhs = try expr(gz, scope, .{ .ty = int_type }, params[1]);
8471 const rhs = try expr(gz, scope, .{ .ty = int_type }, params[2]);
8472 const ptr = try expr(gz, scope, .{ .ty = ptr_type }, params[3]);
8484 const lhs = try expr(gz, scope, .{ .rl = .{ .ty = int_type } }, params[1]);
8485 const rhs = try expr(gz, scope, .{ .rl = .{ .ty = int_type } }, params[2]);
8486 const ptr = try expr(gz, scope, .{ .rl = .{ .ty = ptr_type } }, params[3]);
84738487 const result = try gz.addExtendedPayload(tag, Zir.Inst.OverflowArithmetic{
84748488 .node = gz.nodeIndexToRelative(node),
84758489 .lhs = lhs,
84768490 .rhs = rhs,
84778491 .ptr = ptr,
84788492 });
8479 return rvalue(gz, rl, result, node);
8493 return rvalue(gz, ri, result, node);
84808494}
84818495
84828496fn callExpr(
84838497 gz: *GenZir,
84848498 scope: *Scope,
8485 rl: ResultLoc,
8499 ri: ResultInfo,
84868500 node: Ast.Node.Index,
84878501 call: Ast.full.Call,
84888502) InnerError!Zir.Inst.Ref {
......@@ -8534,7 +8548,7 @@ fn callExpr(
85348548 defer arg_block.unstack();
85358549
85368550 // `call_inst` is reused to provide the param type.
8537 const arg_ref = try expr(&arg_block, &arg_block.base, .{ .coerced_ty = call_inst }, param_node);
8551 const arg_ref = try expr(&arg_block, &arg_block.base, .{ .rl = .{ .coerced_ty = call_inst } }, param_node);
85388552 _ = try arg_block.addBreak(.break_inline, call_index, arg_ref);
85398553
85408554 const body = arg_block.instructionsSlice();
......@@ -8547,13 +8561,8 @@ fn callExpr(
85478561
85488562 // If our result location is a try/catch/error-union-if/return, the error trace propagates.
85498563 // Otherwise, it should always be popped (handled in Sema).
8550 const propagate_error_trace = switch (rl) {
8551 .catch_none, .catch_ref => true, // Propagate to try/catch/error-union-if
8552 .ptr, .ty => |ref| b: { // Otherwise, propagate if result loc is a return
8553 const inst = refToIndex(ref) orelse break :b false;
8554 const zir_tags = astgen.instructions.items(.tag);
8555 break :b zir_tags[inst] == .ret_ptr or zir_tags[inst] == .ret_type;
8556 },
8564 const propagate_error_trace = switch (ri.ctx) {
8565 .error_handling_expr, .@"return" => true, // Propagate to try/catch/error-union-if and return
85578566 else => false,
85588567 };
85598568
......@@ -8575,7 +8584,7 @@ fn callExpr(
85758584 .payload_index = payload_index,
85768585 } },
85778586 });
8578 return rvalue(gz, rl, call_inst, node); // TODO function call with result location
8587 return rvalue(gz, ri, call_inst, node); // TODO function call with result location
85798588}
85808589
85818590/// calleeExpr generates the function part of a call expression (f in f(x)), or the
......@@ -8596,7 +8605,7 @@ fn calleeExpr(
85968605
85978606 const tag = tree.nodes.items(.tag)[node];
85988607 switch (tag) {
8599 .field_access => return addFieldAccess(.field_call_bind, gz, scope, .ref, node),
8608 .field_access => return addFieldAccess(.field_call_bind, gz, scope, .{ .rl = .ref }, node),
86008609
86018610 .builtin_call_two,
86028611 .builtin_call_two_comma,
......@@ -8628,8 +8637,8 @@ fn calleeExpr(
86288637 // If anything is wrong, fall back to builtinCall.
86298638 // It will emit any necessary compile errors and notes.
86308639 if (std.mem.eql(u8, builtin_name, "@field") and params.len == 2) {
8631 const lhs = try expr(gz, scope, .ref, params[0]);
8632 const field_name = try comptimeExpr(gz, scope, .{ .ty = .const_slice_u8_type }, params[1]);
8640 const lhs = try expr(gz, scope, .{ .rl = .ref }, params[0]);
8641 const field_name = try comptimeExpr(gz, scope, .{ .rl = .{ .ty = .const_slice_u8_type } }, params[1]);
86338642 return gz.addExtendedPayload(.field_call_bind_named, Zir.Inst.FieldNamedNode{
86348643 .node = gz.nodeIndexToRelative(node),
86358644 .lhs = lhs,
......@@ -8637,9 +8646,9 @@ fn calleeExpr(
86378646 });
86388647 }
86398648
8640 return builtinCall(gz, scope, .none, node, params);
8649 return builtinCall(gz, scope, .{ .rl = .none }, node, params);
86418650 },
8642 else => return expr(gz, scope, .none, node),
8651 else => return expr(gz, scope, .{ .rl = .none }, node),
86438652 }
86448653}
86458654
......@@ -9655,7 +9664,7 @@ fn nodeUsesAnonNameStrategy(tree: *const Ast, node: Ast.Node.Index) bool {
96559664/// Assumes nothing stacked on `gz`.
96569665fn rvalue(
96579666 gz: *GenZir,
9658 rl: ResultLoc,
9667 ri: ResultInfo,
96599668 raw_result: Zir.Inst.Ref,
96609669 src_node: Ast.Node.Index,
96619670) InnerError!Zir.Inst.Ref {
......@@ -9670,14 +9679,14 @@ fn rvalue(
96709679 break :r raw_result;
96719680 };
96729681 if (gz.endsWithNoReturn()) return result;
9673 switch (rl) {
9674 .none, .catch_none, .coerced_ty => return result,
9682 switch (ri.rl) {
9683 .none, .coerced_ty => return result,
96759684 .discard => {
96769685 // Emit a compile error for discarding error values.
96779686 _ = try gz.addUnNode(.ensure_result_non_error, result, src_node);
96789687 return result;
96799688 },
9680 .ref, .catch_ref => {
9689 .ref => {
96819690 // We need a pointer but we have a value.
96829691 // Unfortunately it's not quite as simple as directly emitting a ref
96839692 // instruction here because we need subsequent address-of operator on
......@@ -9696,7 +9705,7 @@ fn rvalue(
96969705 }
96979706 return indexToRef(gop.value_ptr.*);
96989707 },
9699 .ty, .ty_shift_operand => |ty_inst| {
9708 .ty => |ty_inst| {
97009709 // Quickly eliminate some common, unnecessary type coercion.
97019710 const as_ty = @as(u64, @enumToInt(Zir.Inst.Ref.type_type)) << 32;
97029711 const as_comptime_int = @as(u64, @enumToInt(Zir.Inst.Ref.comptime_int_type)) << 32;
......@@ -9757,7 +9766,7 @@ fn rvalue(
97579766 => return result, // type of result is already correct
97589767
97599768 // Need an explicit type coercion instruction.
9760 else => return gz.addPlNode(rl.zirTag(), src_node, Zir.Inst.As{
9769 else => return gz.addPlNode(ri.zirTag(), src_node, Zir.Inst.As{
97619770 .dest_type = ty_inst,
97629771 .operand = result,
97639772 }),
......@@ -10451,8 +10460,8 @@ const GenZir = struct {
1045110460 label: ?Label = null,
1045210461 break_block: Zir.Inst.Index = 0,
1045310462 continue_block: Zir.Inst.Index = 0,
10454 /// Only valid when setBreakResultLoc is called.
10455 break_result_loc: AstGen.ResultLoc = undefined,
10463 /// Only valid when setBreakResultInfo is called.
10464 break_result_info: AstGen.ResultInfo = undefined,
1045610465 /// When a block has a pointer result location, here it is.
1045710466 rl_ptr: Zir.Inst.Ref = .none,
1045810467 /// When a block has a type result location, here it is.
......@@ -10562,7 +10571,7 @@ const GenZir = struct {
1056210571 fn finishCoercion(
1056310572 as_scope: *GenZir,
1056410573 parent_gz: *GenZir,
10565 rl: ResultLoc,
10574 ri: ResultInfo,
1056610575 src_node: Ast.Node.Index,
1056710576 result: Zir.Inst.Ref,
1056810577 dest_type: Zir.Inst.Ref,
......@@ -10588,7 +10597,7 @@ const GenZir = struct {
1058810597 as_scope.instructions_top = GenZir.unstacked_top;
1058910598 // as_scope now unstacked, can add new instructions to parent_gz
1059010599 const casted_result = try parent_gz.addBin(.as, dest_type, result);
10591 return rvalue(parent_gz, rl, casted_result, src_node);
10600 return rvalue(parent_gz, ri, casted_result, src_node);
1059210601 } else {
1059310602 // implicitly move all as_scope instructions to parent_gz
1059410603 as_scope.instructions_top = GenZir.unstacked_top;
......@@ -10631,7 +10640,7 @@ const GenZir = struct {
1063110640 return gz.astgen.tree.firstToken(gz.decl_node_index);
1063210641 }
1063310642
10634 fn setBreakResultLoc(gz: *GenZir, parent_rl: AstGen.ResultLoc) void {
10643 fn setBreakResultInfo(gz: *GenZir, parent_ri: AstGen.ResultInfo) void {
1063510644 // Depending on whether the result location is a pointer or value, different
1063610645 // ZIR needs to be generated. In the former case we rely on storing to the
1063710646 // pointer to communicate the result, and use breakvoid; in the latter case
......@@ -10640,32 +10649,32 @@ const GenZir = struct {
1064010649 // the scenario where the result location is not consumed. In this case
1064110650 // we emit ZIR for the block break instructions to have the result values,
1064210651 // and then rvalue() on that to pass the value to the result location.
10643 switch (parent_rl) {
10644 .ty, .ty_shift_operand, .coerced_ty => |ty_inst| {
10652 switch (parent_ri.rl) {
10653 .ty, .coerced_ty => |ty_inst| {
1064510654 gz.rl_ty_inst = ty_inst;
10646 gz.break_result_loc = parent_rl;
10655 gz.break_result_info = parent_ri;
1064710656 },
1064810657
10649 .discard, .none, .catch_none, .ref, .catch_ref => {
10658 .discard, .none, .ref => {
1065010659 gz.rl_ty_inst = .none;
10651 gz.break_result_loc = parent_rl;
10660 gz.break_result_info = parent_ri;
1065210661 },
1065310662
1065410663 .ptr => |ptr_res| {
1065510664 gz.rl_ty_inst = .none;
10656 gz.break_result_loc = .{ .ptr = .{ .inst = ptr_res.inst } };
10665 gz.break_result_info = .{ .rl = .{ .ptr = .{ .inst = ptr_res.inst } } };
1065710666 },
1065810667
1065910668 .inferred_ptr => |ptr| {
1066010669 gz.rl_ty_inst = .none;
1066110670 gz.rl_ptr = ptr;
10662 gz.break_result_loc = .{ .block_ptr = gz };
10671 gz.break_result_info = .{ .rl = .{ .block_ptr = gz }, .ctx = parent_ri.ctx };
1066310672 },
1066410673
1066510674 .block_ptr => |parent_block_scope| {
1066610675 gz.rl_ty_inst = parent_block_scope.rl_ty_inst;
1066710676 gz.rl_ptr = parent_block_scope.rl_ptr;
10668 gz.break_result_loc = .{ .block_ptr = gz };
10677 gz.break_result_info = .{ .rl = .{ .block_ptr = gz }, .ctx = parent_ri.ctx };
1066910678 },
1067010679 }
1067110680 }
......@@ -11815,10 +11824,10 @@ const GenZir = struct {
1181511824 return new_index;
1181611825 }
1181711826
11818 fn addRet(gz: *GenZir, rl: ResultLoc, operand: Zir.Inst.Ref, node: Ast.Node.Index) !void {
11819 switch (rl) {
11827 fn addRet(gz: *GenZir, ri: ResultInfo, operand: Zir.Inst.Ref, node: Ast.Node.Index) !void {
11828 switch (ri.rl) {
1182011829 .ptr => |ptr_res| _ = try gz.addUnNode(.ret_load, ptr_res.inst, node),
11821 .ty, .ty_shift_operand => _ = try gz.addUnNode(.ret_node, operand, node),
11830 .ty => _ = try gz.addUnNode(.ret_node, operand, node),
1182211831 else => unreachable,
1182311832 }
1182411833 }
test/behavior/bugs/12891.zig+1
......@@ -7,6 +7,7 @@ test "issue12891" {
77 try std.testing.expect(i < f);
88}
99test "nan" {
10 if (builtin.zig_backend == .stage1) return error.SkipZigTest; // TODO
1011 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
1112
1213 const f = comptime std.math.nan(f64);