Commit 09a57583a4ccce30603ffc8d0e3d7359dc3cb978 | zig

author	Matthew Lugg <mlugg@mlugg.co.uk> 2023-09-18 14:49:18+01:00
committer	Matthew Lugg <mlugg@mlugg.co.uk> 2023-09-23 22:01:08+01:00
log	09a57583a4ccce30603ffc8d0e3d7359dc3cb978
tree	aab67cf7749a799ae9b236cd4f26bc9f115b82c5
parent	01906a3ad8b792627e55551686c25d02fef64e98
signature	Commit is signed but in an unrecognized format.

compiler: preserve result type information through address-of operator

This commit introduces the new `ref_coerced_ty` result type into AstGen.
This represents a expression which we want to treat as an lvalue, and
the pointer will be coerced to a given type.

This change gives known result types to many expressions, in particular
struct and array initializations. This allows certain casts to work
which previously required explicitly specifying types via `@as`. It also
eliminates our dependence on anonymous struct types for expressions of
the form `&.{ ... }` - this paves the way for #16865, and also results
in less Sema magic happening for such initializations, also leading to
potentially better runtime code.

As part of these changes, this commit also implements #17194 by
disallowing RLS on explicitly-typed struct and array initializations.
Apologies for linking these changes - it seemed rather pointless to try
and separate them, since they both make big changes to struct and array
initializations in AstGen. The rationale for this change can be found in
the proposal - in essence, performing RLS whilst maintaining the
semantics of the intermediary type is a very difficult problem to solve.

This allowed the problematic `coerce_result_ptr` ZIR instruction to be
completely eliminated, which in turn also simplified the logic for
inferred allocations in Sema - thanks to this, we almost break even on
line count!

In doing this, the ZIR instructions surrounding these initializations
have been restructured - some have been added and removed, and others
renamed for clarity (and their semantics changed slightly). In order to
optimize ZIR tag count, the `struct_init_anon_ref` and
`array_init_anon_ref` instructions have been removed in favour of using
`ref` on a standard anonymous value initialization, since these
instructions are now virtually never used.

Lastly, it's worth noting that this commit introduces a slightly strange
source of generic poison types: in the expression `@as(*anyopaque, &x)`,
the sub-expression `x` has a generic poison result type, despite no
generic code being involved. This turns out to be a logical choice,
because we don't know the result type for `x`, and the generic poison
type represents precisely this case, providing the semantics we need.

Resolves: #16512
Resolves: #17194

35 files changed, 1251 insertions(+), 1025 deletions(-)

lib
- std
  - debug.zig
src
test

lib/std/debug.zig+6-1

 @@ -514,7 +514,12 @@ pub const StackIterator = struct {
         return StackIterator{
             .first_address = first_address,
-            .fp = fp orelse @frameAddress(),
+            // TODO: this is a workaround for #16876
+            //.fp = fp orelse @frameAddress(),
+            .fp = fp orelse blk: {
+                const fa = @frameAddress();
+                break :blk fa;
+            },
         };
     }

src/AstGen.zig+318-305

...	@@ -265,14 +265,17 @@ const ResultInfo = struct {	...	@@ -265,14 +265,17 @@ const ResultInfo = struct {
265	discard,	265	discard,
266	/// The expression has an inferred type, and it will be evaluated as an rvalue.	266	/// The expression has an inferred type, and it will be evaluated as an rvalue.
267	none,	267	none,
268	/// The expression must generate a pointer rather than a value. For example, the left hand side
269	/// of an assignment uses this kind of result location.
270	ref,
271	/// The expression will be coerced into this type, but it will be evaluated as an rvalue.	268	/// The expression will be coerced into this type, but it will be evaluated as an rvalue.
272	ty: Zir.Inst.Ref,	269	ty: Zir.Inst.Ref,
273	/// Same as `ty` but it is guaranteed that Sema will additionally perform the coercion,	270	/// Same as `ty` but it is guaranteed that Sema will additionally perform the coercion,
274	/// so no `as` instruction needs to be emitted.	271	/// so no `as` instruction needs to be emitted.
275	coerced_ty: Zir.Inst.Ref,	272	coerced_ty: Zir.Inst.Ref,
		273	/// The expression must generate a pointer rather than a value. For example, the left hand side
		274	/// of an assignment uses this kind of result location.
		275	ref,
		276	/// The expression must generate a pointer rather than a value, and the pointer will be coerced
		277	/// by other code to this type, which is guaranteed by earlier instructions to be a pointer type.
		278	ref_coerced_ty: Zir.Inst.Ref,
276	/// The expression must store its result into this typed pointer. The result instruction	279	/// The expression must store its result into this typed pointer. The result instruction
277	/// from the expression must be ignored.	280	/// from the expression must be ignored.
278	ptr: PtrResultLoc,	281	ptr: PtrResultLoc,
...	@@ -303,26 +306,30 @@ const ResultInfo = struct {	...	@@ -303,26 +306,30 @@ const ResultInfo = struct {
303	/// Find the result type for a cast builtin given the result location.	306	/// Find the result type for a cast builtin given the result location.
304	/// If the location does not have a known result type, emits an error on	307	/// If the location does not have a known result type, emits an error on
305	/// the given node.	308	/// the given node.
306	fn resultType(rl: Loc, gz: *GenZir, node: Ast.Node.Index, builtin_name: []const u8) !Zir.Inst.Ref {	309	fn resultType(rl: Loc, gz: *GenZir, node: Ast.Node.Index) !?Zir.Inst.Ref {
307	const astgen = gz.astgen;	310	return switch (rl) {
308	switch (rl) {	311	.discard, .none, .ref, .inferred_ptr, .destructure => null,
309	.discard, .none, .ref, .inferred_ptr => {},	312	.ty, .coerced_ty => \|ty_ref\| ty_ref,
310	.ty, .coerced_ty => \|ty_ref\| return ty_ref,	313	.ref_coerced_ty => \|ptr_ty\| try gz.addUnNode(.elem_type, ptr_ty, node),
311	.ptr => \|ptr\| {	314	.ptr => \|ptr\| {
312	const ptr_ty = try gz.addUnNode(.typeof, ptr.inst, node);	315	const ptr_ty = try gz.addUnNode(.typeof, ptr.inst, node);
313	return gz.addUnNode(.elem_type, ptr_ty, node);	316	return try gz.addUnNode(.elem_type, ptr_ty, node);
314	},
315	.destructure => \|destructure\| {
316	return astgen.failNodeNotes(node, "{s} must have a known result type", .{builtin_name}, &.{
317	try astgen.errNoteNode(destructure.src_node, "destructure expressions do not provide a single result type", .{}),
318	try astgen.errNoteNode(node, "use @as to provide explicit result type", .{}),
319	});
320	},	317	},
321	}	318	};
		319	}
322		320
323	return astgen.failNodeNotes(node, "{s} must have a known result type", .{builtin_name}, &.{	321	fn resultTypeForCast(rl: Loc, gz: *GenZir, node: Ast.Node.Index, builtin_name: []const u8) !Zir.Inst.Ref {
324	try astgen.errNoteNode(node, "use @as to provide explicit result type", .{}),	322	const astgen = gz.astgen;
325	});	323	if (try rl.resultType(gz, node)) \|ty\| return ty;
		324	switch (rl) {
		325	.destructure => \|destructure\| return astgen.failNodeNotes(node, "{s} must have a known result type", .{builtin_name}, &.{
		326	try astgen.errNoteNode(destructure.src_node, "destructure expressions do not provide a single result type", .{}),
		327	try astgen.errNoteNode(node, "use @as to provide explicit result type", .{}),
		328	}),
		329	else => return astgen.failNodeNotes(node, "{s} must have a known result type", .{builtin_name}, &.{
		330	try astgen.errNoteNode(node, "use @as to provide explicit result type", .{}),
		331	}),
		332	}
326	}	333	}
327	};	334	};
328		335
...	@@ -933,7 +940,7 @@ fn expr(gz: GenZir, scope: Scope, ri: ResultInfo, node: Ast.Node.Index) InnerE	...	@@ -933,7 +940,7 @@ fn expr(gz: GenZir, scope: Scope, ri: ResultInfo, node: Ast.Node.Index) InnerE
933	const lhs = try expr(gz, scope, .{ .rl = .none }, node_datas[node].lhs);	940	const lhs = try expr(gz, scope, .{ .rl = .none }, node_datas[node].lhs);
934	_ = try gz.addUnNode(.validate_deref, lhs, node);	941	_ = try gz.addUnNode(.validate_deref, lhs, node);
935	switch (ri.rl) {	942	switch (ri.rl) {
936	.ref => return lhs,	943	.ref, .ref_coerced_ty => return lhs,
937	else => {	944	else => {
938	const result = try gz.addUnNode(.load, lhs, node);	945	const result = try gz.addUnNode(.load, lhs, node);
939	return rvalue(gz, ri, result, node);	946	return rvalue(gz, ri, result, node);
...	@@ -941,7 +948,11 @@ fn expr(gz: GenZir, scope: Scope, ri: ResultInfo, node: Ast.Node.Index) InnerE	...	@@ -941,7 +948,11 @@ fn expr(gz: GenZir, scope: Scope, ri: ResultInfo, node: Ast.Node.Index) InnerE
941	}	948	}
942	},	949	},
943	.address_of => {	950	.address_of => {
944	const result = try expr(gz, scope, .{ .rl = .ref }, node_datas[node].lhs);	951	const operand_rl: ResultInfo.Loc = if (try ri.rl.resultType(gz, node)) \|res_ty_inst\| rl: {
		952	_ = try gz.addUnTok(.validate_ref_ty, res_ty_inst, tree.firstToken(node));
		953	break :rl .{ .ref_coerced_ty = res_ty_inst };
		954	} else .ref;
		955	const result = try expr(gz, scope, .{ .rl = operand_rl }, node_datas[node].lhs);
945	return rvalue(gz, ri, result, node);	956	return rvalue(gz, ri, result, node);
946	},	957	},
947	.optional_type => {	958	.optional_type => {
...	@@ -950,7 +961,7 @@ fn expr(gz: GenZir, scope: Scope, ri: ResultInfo, node: Ast.Node.Index) InnerE	...	@@ -950,7 +961,7 @@ fn expr(gz: GenZir, scope: Scope, ri: ResultInfo, node: Ast.Node.Index) InnerE
950	return rvalue(gz, ri, result, node);	961	return rvalue(gz, ri, result, node);
951	},	962	},
952	.unwrap_optional => switch (ri.rl) {	963	.unwrap_optional => switch (ri.rl) {
953	.ref => {	964	.ref, .ref_coerced_ty => {
954	const lhs = try expr(gz, scope, .{ .rl = .ref }, node_datas[node].lhs);	965	const lhs = try expr(gz, scope, .{ .rl = .ref }, node_datas[node].lhs);
955		966
956	const cursor = maybeAdvanceSourceCursorToMainToken(gz, node);	967	const cursor = maybeAdvanceSourceCursorToMainToken(gz, node);
...	@@ -1001,7 +1012,7 @@ fn expr(gz: GenZir, scope: Scope, ri: ResultInfo, node: Ast.Node.Index) InnerE	...	@@ -1001,7 +1012,7 @@ fn expr(gz: GenZir, scope: Scope, ri: ResultInfo, node: Ast.Node.Index) InnerE
1001	else	1012	else
1002	null;	1013	null;
1003	switch (ri.rl) {	1014	switch (ri.rl) {
1004	.ref => return orelseCatchExpr(	1015	.ref, .ref_coerced_ty => return orelseCatchExpr(
1005	gz,	1016	gz,
1006	scope,	1017	scope,
1007	ri,	1018	ri,
...	@@ -1028,7 +1039,7 @@ fn expr(gz: GenZir, scope: Scope, ri: ResultInfo, node: Ast.Node.Index) InnerE	...	@@ -1028,7 +1039,7 @@ fn expr(gz: GenZir, scope: Scope, ri: ResultInfo, node: Ast.Node.Index) InnerE
1028	}	1039	}
1029	},	1040	},
1030	.@"orelse" => switch (ri.rl) {	1041	.@"orelse" => switch (ri.rl) {
1031	.ref => return orelseCatchExpr(	1042	.ref, .ref_coerced_ty => return orelseCatchExpr(
1032	gz,	1043	gz,
1033	scope,	1044	scope,
1034	ri,	1045	ri,
...	@@ -1432,73 +1443,75 @@ fn arrayInitExpr(	...	@@ -1432,73 +1443,75 @@ fn arrayInitExpr(
1432	break :inst .{ array_type_inst, .none };	1443	break :inst .{ array_type_inst, .none };
1433	};	1444	};
1434		1445
		1446	if (array_ty != .none) {
		1447	// Typed inits do not use RLS for language simplicity.
		1448	switch (ri.rl) {
		1449	.discard => {
		1450	if (elem_ty != .none) {
		1451	const elem_ri: ResultInfo = .{ .rl = .{ .ty = elem_ty } };
		1452	for (array_init.ast.elements) \|elem_init\| {
		1453	_ = try expr(gz, scope, elem_ri, elem_init);
		1454	}
		1455	} else {
		1456	for (array_init.ast.elements, 0..) \|elem_init, i\| {
		1457	const this_elem_ty = try gz.add(.{
		1458	.tag = .array_init_elem_type,
		1459	.data = .{ .bin = .{
		1460	.lhs = array_ty,
		1461	.rhs = @enumFromInt(i),
		1462	} },
		1463	});
		1464	_ = try expr(gz, scope, .{ .rl = .{ .ty = this_elem_ty } }, elem_init);
		1465	}
		1466	}
		1467	return .void_value;
		1468	},
		1469	.ref => return arrayInitExprTyped(gz, scope, node, array_init.ast.elements, array_ty, elem_ty, true),
		1470	else => {
		1471	const array_inst = try arrayInitExprTyped(gz, scope, node, array_init.ast.elements, array_ty, elem_ty, false);
		1472	return rvalue(gz, ri, array_inst, node);
		1473	},
		1474	}
		1475	}
		1476
1435	switch (ri.rl) {	1477	switch (ri.rl) {
		1478	.none => return arrayInitExprAnon(gz, scope, node, array_init.ast.elements),
1436	.discard => {	1479	.discard => {
1437	if (elem_ty != .none) {	1480	for (array_init.ast.elements) \|elem_init\| {
1438	const elem_ri: ResultInfo = .{ .rl = .{ .ty = elem_ty } };	1481	_ = try expr(gz, scope, .{ .rl = .discard }, elem_init);
1439	for (array_init.ast.elements) \|elem_init\| {
1440	_ = try expr(gz, scope, elem_ri, elem_init);
1441	}
1442	} else if (array_ty != .none) {
1443	for (array_init.ast.elements, 0..) \|elem_init, i\| {
1444	const this_elem_ty = try gz.add(.{
1445	.tag = .elem_type_index,
1446	.data = .{ .bin = .{
1447	.lhs = array_ty,
1448	.rhs = @enumFromInt(i),
1449	} },
1450	});
1451	_ = try expr(gz, scope, .{ .rl = .{ .ty = this_elem_ty } }, elem_init);
1452	}
1453	} else {
1454	for (array_init.ast.elements) \|elem_init\| {
1455	_ = try expr(gz, scope, .{ .rl = .discard }, elem_init);
1456	}
1457	}	1482	}
1458	return Zir.Inst.Ref.void_value;	1483	return Zir.Inst.Ref.void_value;
1459	},	1484	},
1460	.ref => {	1485	.ref => {
1461	const tag: Zir.Inst.Tag = if (array_ty != .none) .array_init_ref else .array_init_anon_ref;	1486	const result = try arrayInitExprAnon(gz, scope, node, array_init.ast.elements);
1462	return arrayInitExprInner(gz, scope, node, array_init.ast.elements, array_ty, elem_ty, tag);	1487	return gz.addUnTok(.ref, result, tree.firstToken(node));
1463	},
1464	.none => {
1465	const tag: Zir.Inst.Tag = if (array_ty != .none) .array_init else .array_init_anon;
1466	return arrayInitExprInner(gz, scope, node, array_init.ast.elements, array_ty, elem_ty, tag);
1467	},
1468	.ty, .coerced_ty => \|ty_inst\| {
1469	const arr_ty = if (array_ty != .none) array_ty else blk: {
1470	const arr_ty = try gz.addUnNode(.opt_eu_base_ty, ty_inst, node);
1471	_ = try gz.addPlNode(.validate_array_init_ty, node, Zir.Inst.ArrayInit{
1472	.ty = arr_ty,
1473	.init_count = @intCast(array_init.ast.elements.len),
1474	});
1475	break :blk arr_ty;
1476	};
1477	const result = try arrayInitExprInner(gz, scope, node, array_init.ast.elements, arr_ty, elem_ty, .array_init);
1478	return rvalue(gz, ri, result, node);
1479	},	1488	},
1480	.ptr => \|ptr_res\| {	1489	.ref_coerced_ty => \|ptr_ty_inst\| {
1481	return arrayInitExprRlPtr(gz, scope, node, ptr_res.inst, array_init.ast.elements, array_ty);	1490	const dest_arr_ty_inst = try gz.addPlNode(.validate_array_init_ref_ty, node, Zir.Inst.ArrayInitRefTy{
1482	},	1491	.ptr_ty = ptr_ty_inst,
1483	.inferred_ptr => \|ptr_inst\| {	1492	.elem_count = @intCast(array_init.ast.elements.len),
1484	if (array_ty == .none) {	1493	});
1485	// We treat this case differently so that we don't get a crash when	1494	return arrayInitExprTyped(gz, scope, node, array_init.ast.elements, dest_arr_ty_inst, .none, true);
1486	// analyzing array_base_ptr against an alloc_inferred_mut.	1495	},
1487	// See corresponding logic in structInitExpr.	1496	.ty, .coerced_ty => \|result_ty_inst\| {
1488	const result = try arrayInitExprRlNone(gz, scope, node, array_init.ast.elements, .array_init_anon);	1497	_ = try gz.addPlNode(.validate_array_init_result_ty, node, Zir.Inst.ArrayInit{
1489	return rvalue(gz, ri, result, node);	1498	.ty = result_ty_inst,
1490	} else {	1499	.init_count = @intCast(array_init.ast.elements.len),
1491	return arrayInitExprRlPtr(gz, scope, node, ptr_inst, array_init.ast.elements, array_ty);	1500	});
1492	}	1501	return arrayInitExprTyped(gz, scope, node, array_init.ast.elements, result_ty_inst, .none, false);
		1502	},
		1503	.ptr => \|ptr\| {
		1504	try arrayInitExprPtr(gz, scope, node, array_init.ast.elements, ptr.inst);
		1505	return .void_value;
		1506	},
		1507	.inferred_ptr => {
		1508	// We can't get elem pointers of an untyped inferred alloc, so must perform a
		1509	// standard anonymous initialization followed by an rvalue store.
		1510	// See corresponding logic in structInitExpr.
		1511	const result = try arrayInitExprAnon(gz, scope, node, array_init.ast.elements);
		1512	return rvalue(gz, ri, result, node);
1493	},	1513	},
1494	.destructure => \|destructure\| {	1514	.destructure => \|destructure\| {
1495	if (array_ty != .none) {
1496	// We have a specific type, so there may be things like default
1497	// field values messing with us. Do this as a standard typed
1498	// init followed by an rvalue destructure.
1499	const result = try arrayInitExprInner(gz, scope, node, array_init.ast.elements, array_ty, elem_ty, .array_init);
1500	return rvalue(gz, ri, result, node);
1501	}
1502	// Untyped init - destructure directly into result pointers	1515	// Untyped init - destructure directly into result pointers
1503	if (array_init.ast.elements.len != destructure.components.len) {	1516	if (array_init.ast.elements.len != destructure.components.len) {
1504	return astgen.failNodeNotes(node, "expected {} elements for destructure, found {}", .{	1517	return astgen.failNodeNotes(node, "expected {} elements for destructure, found {}", .{
...	@@ -1521,12 +1534,12 @@ fn arrayInitExpr(	...	@@ -1521,12 +1534,12 @@ fn arrayInitExpr(
1521	}	1534	}
1522	}	1535	}
1523		1536
1524	fn arrayInitExprRlNone(	1537	/// An array initialization expression using an `array_init_anon` instruction.
		1538	fn arrayInitExprAnon(
1525	gz: *GenZir,	1539	gz: *GenZir,
1526	scope: *Scope,	1540	scope: *Scope,
1527	node: Ast.Node.Index,	1541	node: Ast.Node.Index,
1528	elements: []const Ast.Node.Index,	1542	elements: []const Ast.Node.Index,
1529	tag: Zir.Inst.Tag,
1530	) InnerError!Zir.Inst.Ref {	1543	) InnerError!Zir.Inst.Ref {
1531	const astgen = gz.astgen;	1544	const astgen = gz.astgen;
1532		1545
...	@@ -1540,95 +1553,84 @@ fn arrayInitExprRlNone(	...	@@ -1540,95 +1553,84 @@ fn arrayInitExprRlNone(
1540	astgen.extra.items[extra_index] = @intFromEnum(elem_ref);	1553	astgen.extra.items[extra_index] = @intFromEnum(elem_ref);
1541	extra_index += 1;	1554	extra_index += 1;
1542	}	1555	}
1543	return try gz.addPlNodePayloadIndex(tag, node, payload_index);	1556	return try gz.addPlNodePayloadIndex(.array_init_anon, node, payload_index);
1544	}	1557	}
1545		1558
1546	fn arrayInitExprInner(	1559	/// An array initialization expression using an `array_init` or `array_init_ref` instruction.
		1560	fn arrayInitExprTyped(
1547	gz: *GenZir,	1561	gz: *GenZir,
1548	scope: *Scope,	1562	scope: *Scope,
1549	node: Ast.Node.Index,	1563	node: Ast.Node.Index,
1550	elements: []const Ast.Node.Index,	1564	elements: []const Ast.Node.Index,
1551	array_ty_inst: Zir.Inst.Ref,	1565	ty_inst: Zir.Inst.Ref,
1552	elem_ty: Zir.Inst.Ref,	1566	maybe_elem_ty_inst: Zir.Inst.Ref,
1553	tag: Zir.Inst.Tag,	1567	is_ref: bool,
1554	) InnerError!Zir.Inst.Ref {	1568	) InnerError!Zir.Inst.Ref {
1555	const astgen = gz.astgen;	1569	const astgen = gz.astgen;
1556		1570
1557	const len = elements.len + @intFromBool(array_ty_inst != .none);	1571	const len = elements.len + 1; // +1 for type
1558	const payload_index = try addExtra(astgen, Zir.Inst.MultiOp{	1572	const payload_index = try addExtra(astgen, Zir.Inst.MultiOp{
1559	.operands_len = @intCast(len),	1573	.operands_len = @intCast(len),
1560	});	1574	});
1561	var extra_index = try reserveExtra(astgen, len);	1575	var extra_index = try reserveExtra(astgen, len);
1562	if (array_ty_inst != .none) {	1576	astgen.extra.items[extra_index] = @intFromEnum(ty_inst);
1563	astgen.extra.items[extra_index] = @intFromEnum(array_ty_inst);	1577	extra_index += 1;
1564	extra_index += 1;
1565	}
1566		1578
1567	for (elements, 0..) \|elem_init, i\| {	1579	if (maybe_elem_ty_inst != .none) {
1568	const ri = if (elem_ty != .none)	1580	const elem_ri: ResultInfo = .{ .rl = .{ .coerced_ty = maybe_elem_ty_inst } };
1569	ResultInfo{ .rl = .{ .coerced_ty = elem_ty } }	1581	for (elements) \|elem_init\| {
1570	else if (array_ty_inst != .none) ri: {	1582	const elem_inst = try expr(gz, scope, elem_ri, elem_init);
1571	const ty_expr = try gz.add(.{	1583	astgen.extra.items[extra_index] = @intFromEnum(elem_inst);
1572	.tag = .elem_type_index,	1584	extra_index += 1;
		1585	}
		1586	} else {
		1587	for (elements, 0..) \|elem_init, i\| {
		1588	const ri: ResultInfo = .{ .rl = .{ .coerced_ty = try gz.add(.{
		1589	.tag = .array_init_elem_type,
1573	.data = .{ .bin = .{	1590	.data = .{ .bin = .{
1574	.lhs = array_ty_inst,	1591	.lhs = ty_inst,
1575	.rhs = @enumFromInt(i),	1592	.rhs = @enumFromInt(i),
1576	} },	1593	} },
1577	});	1594	}) } };
1578	break :ri ResultInfo{ .rl = .{ .coerced_ty = ty_expr } };
1579	} else ResultInfo{ .rl = .{ .none = {} } };
1580		1595
1581	const elem_ref = try expr(gz, scope, ri, elem_init);	1596	const elem_inst = try expr(gz, scope, ri, elem_init);
1582	astgen.extra.items[extra_index] = @intFromEnum(elem_ref);	1597	astgen.extra.items[extra_index] = @intFromEnum(elem_inst);
1583	extra_index += 1;	1598	extra_index += 1;
		1599	}
1584	}	1600	}
1585		1601
		1602	const tag: Zir.Inst.Tag = if (is_ref) .array_init_ref else .array_init;
1586	return try gz.addPlNodePayloadIndex(tag, node, payload_index);	1603	return try gz.addPlNodePayloadIndex(tag, node, payload_index);
1587	}	1604	}
1588		1605
1589	fn arrayInitExprRlPtr(	1606	/// An array initialization expression using element pointers.
		1607	fn arrayInitExprPtr(
1590	gz: *GenZir,	1608	gz: *GenZir,
1591	scope: *Scope,	1609	scope: *Scope,
1592	node: Ast.Node.Index,	1610	node: Ast.Node.Index,
1593	result_ptr: Zir.Inst.Ref,
1594	elements: []const Ast.Node.Index,	1611	elements: []const Ast.Node.Index,
1595	array_ty: Zir.Inst.Ref,	1612	ptr_inst: Zir.Inst.Ref,
1596	) InnerError!Zir.Inst.Ref {	1613	) InnerError!void {
1597	if (array_ty == .none) {
1598	const base_ptr = try gz.addUnNode(.array_base_ptr, result_ptr, node);
1599	return arrayInitExprRlPtrInner(gz, scope, node, base_ptr, elements);
1600	}
1601
1602	const casted_ptr = try gz.addPlNode(.coerce_result_ptr, node, Zir.Inst.Bin{ .lhs = array_ty, .rhs = result_ptr });
1603	return arrayInitExprRlPtrInner(gz, scope, node, casted_ptr, elements);
1604	}
1605
1606	fn arrayInitExprRlPtrInner(
1607	gz: *GenZir,
1608	scope: *Scope,
1609	node: Ast.Node.Index,
1610	result_ptr: Zir.Inst.Ref,
1611	elements: []const Ast.Node.Index,
1612	) InnerError!Zir.Inst.Ref {
1613	const astgen = gz.astgen;	1614	const astgen = gz.astgen;
1614		1615
		1616	const array_ptr_inst = try gz.addUnNode(.opt_eu_base_ptr_init, ptr_inst, node);
		1617
1615	const payload_index = try addExtra(astgen, Zir.Inst.Block{	1618	const payload_index = try addExtra(astgen, Zir.Inst.Block{
1616	.body_len = @intCast(elements.len),	1619	.body_len = @intCast(elements.len),
1617	});	1620	});
1618	var extra_index = try reserveExtra(astgen, elements.len);	1621	var extra_index = try reserveExtra(astgen, elements.len);
1619		1622
1620	for (elements, 0..) \|elem_init, i\| {	1623	for (elements, 0..) \|elem_init, i\| {
1621	const elem_ptr = try gz.addPlNode(.elem_ptr_imm, elem_init, Zir.Inst.ElemPtrImm{	1624	const elem_ptr_inst = try gz.addPlNode(.array_init_elem_ptr, elem_init, Zir.Inst.ElemPtrImm{
1622	.ptr = result_ptr,	1625	.ptr = array_ptr_inst,
1623	.index = @intCast(i),	1626	.index = @intCast(i),
1624	});	1627	});
1625	astgen.extra.items[extra_index] = refToIndex(elem_ptr).?;	1628	astgen.extra.items[extra_index] = refToIndex(elem_ptr_inst).?;
1626	extra_index += 1;	1629	extra_index += 1;
1627	_ = try expr(gz, scope, .{ .rl = .{ .ptr = .{ .inst = elem_ptr } } }, elem_init);	1630	_ = try expr(gz, scope, .{ .rl = .{ .ptr = .{ .inst = elem_ptr_inst } } }, elem_init);
1628	}	1631	}
1629		1632
1630	_ = try gz.addPlNodePayloadIndex(.validate_array_init, node, payload_index);	1633	_ = try gz.addPlNodePayloadIndex(.validate_ptr_array_init, node, payload_index);
1631	return .void_value;
1632	}	1634	}
1633		1635
1634	fn structInitExpr(	1636	fn structInitExpr(
...	@@ -1643,7 +1645,26 @@ fn structInitExpr(	...	@@ -1643,7 +1645,26 @@ fn structInitExpr(
1643		1645
1644	if (struct_init.ast.type_expr == 0) {	1646	if (struct_init.ast.type_expr == 0) {
1645	if (struct_init.ast.fields.len == 0) {	1647	if (struct_init.ast.fields.len == 0) {
1646	return rvalue(gz, ri, .empty_struct, node);	1648	// Anonymous init with no fields.
		1649	switch (ri.rl) {
		1650	.discard => return .void_value,
		1651	.ref_coerced_ty => \|ptr_ty_inst\| return gz.addUnNode(.struct_init_empty_ref_result, ptr_ty_inst, node),
		1652	.ty, .coerced_ty => \|ty_inst\| return gz.addUnNode(.struct_init_empty_result, ty_inst, node),
		1653	.ptr => {
		1654	// TODO: should we modify this to use RLS for the field stores here?
		1655	const ty_inst = (try ri.rl.resultType(gz, node)).?;
		1656	const val = try gz.addUnNode(.struct_init_empty_result, ty_inst, node);
		1657	return rvalue(gz, ri, val, node);
		1658	},
		1659	.none, .ref, .inferred_ptr => {
		1660	return rvalue(gz, ri, .empty_struct, node);
		1661	},
		1662	.destructure => \|destructure\| {
		1663	return astgen.failNodeNotes(node, "empty initializer cannot be destructured", .{}, &.{
		1664	try astgen.errNoteNode(destructure.src_node, "result destructured here", .{}),
		1665	});
		1666	},
		1667	}
1647	}	1668	}
1648	} else array: {	1669	} else array: {
1649	const node_tags = tree.nodes.items(.tag);	1670	const node_tags = tree.nodes.items(.tag);
...	@@ -1694,86 +1715,67 @@ fn structInitExpr(	...	@@ -1694,86 +1715,67 @@ fn structInitExpr(
1694	}	1715	}
1695	}	1716	}
1696		1717
		1718	if (struct_init.ast.type_expr != 0) {
		1719	// Typed inits do not use RLS for language simplicity.
		1720	const ty_inst = try typeExpr(gz, scope, struct_init.ast.type_expr);
		1721	_ = try gz.addUnNode(.validate_struct_init_ty, ty_inst, node);
		1722	switch (ri.rl) {
		1723	.ref => return structInitExprTyped(gz, scope, node, struct_init, ty_inst, true),
		1724	else => {
		1725	const struct_inst = try structInitExprTyped(gz, scope, node, struct_init, ty_inst, false);
		1726	return rvalue(gz, ri, struct_inst, node);
		1727	},
		1728	}
		1729	}
		1730
1697	switch (ri.rl) {	1731	switch (ri.rl) {
		1732	.none => return structInitExprAnon(gz, scope, node, struct_init),
1698	.discard => {	1733	.discard => {
1699	if (struct_init.ast.type_expr != 0) {	1734	// Even if discarding we must perform an anonymous init to check for duplicate field names.
1700	const ty_inst = try typeExpr(gz, scope, struct_init.ast.type_expr);	1735	// TODO: should duplicate field names be caught in AstGen?
1701	_ = try gz.addUnNode(.validate_struct_init_ty, ty_inst, node);	1736	_ = try structInitExprAnon(gz, scope, node, struct_init);
1702	_ = try structInitExprRlTy(gz, scope, node, struct_init, ty_inst, .struct_init);	1737	return .void_value;
1703	} else {
1704	_ = try structInitExprRlNone(gz, scope, node, struct_init, .none, .struct_init_anon);
1705	}
1706	return Zir.Inst.Ref.void_value;
1707	},	1738	},
1708	.ref => {	1739	.ref => {
1709	if (struct_init.ast.type_expr != 0) {	1740	const result = try structInitExprAnon(gz, scope, node, struct_init);
1710	const ty_inst = try typeExpr(gz, scope, struct_init.ast.type_expr);	1741	return gz.addUnTok(.ref, result, tree.firstToken(node));
1711	_ = try gz.addUnNode(.validate_struct_init_ty, ty_inst, node);
1712	return structInitExprRlTy(gz, scope, node, struct_init, ty_inst, .struct_init_ref);
1713	} else {
1714	return structInitExprRlNone(gz, scope, node, struct_init, .none, .struct_init_anon_ref);
1715	}
1716	},	1742	},
1717	.none => {	1743	.ref_coerced_ty => \|ptr_ty_inst\| {
1718	if (struct_init.ast.type_expr != 0) {	1744	const result_ty_inst = try gz.addUnNode(.elem_type, ptr_ty_inst, node);
1719	const ty_inst = try typeExpr(gz, scope, struct_init.ast.type_expr);	1745	_ = try gz.addUnNode(.validate_struct_init_result_ty, result_ty_inst, node);
1720	_ = try gz.addUnNode(.validate_struct_init_ty, ty_inst, node);	1746	return structInitExprTyped(gz, scope, node, struct_init, result_ty_inst, true);
1721	return structInitExprRlTy(gz, scope, node, struct_init, ty_inst, .struct_init);
1722	} else {
1723	return structInitExprRlNone(gz, scope, node, struct_init, .none, .struct_init_anon);
1724	}
1725	},	1747	},
1726	.ty, .coerced_ty => \|ty_inst\| {	1748	.ty, .coerced_ty => \|result_ty_inst\| {
1727	if (struct_init.ast.type_expr == 0) {	1749	_ = try gz.addUnNode(.validate_struct_init_result_ty, result_ty_inst, node);
1728	const struct_ty_inst = try gz.addUnNode(.opt_eu_base_ty, ty_inst, node);	1750	return structInitExprTyped(gz, scope, node, struct_init, result_ty_inst, false);
1729	_ = try gz.addUnNode(.validate_struct_init_ty, struct_ty_inst, node);
1730	const result = try structInitExprRlTy(gz, scope, node, struct_init, struct_ty_inst, .struct_init);
1731	return rvalue(gz, ri, result, node);
1732	}
1733	const inner_ty_inst = try typeExpr(gz, scope, struct_init.ast.type_expr);
1734	_ = try gz.addUnNode(.validate_struct_init_ty, inner_ty_inst, node);
1735	const result = try structInitExprRlTy(gz, scope, node, struct_init, inner_ty_inst, .struct_init);
1736	return rvalue(gz, ri, result, node);
1737	},	1751	},
1738	.ptr => \|ptr_res\| return structInitExprRlPtr(gz, scope, node, struct_init, ptr_res.inst),	1752	.ptr => \|ptr\| {
1739	.inferred_ptr => \|ptr_inst\| {	1753	try structInitExprPtr(gz, scope, node, struct_init, ptr.inst);
1740	if (struct_init.ast.type_expr == 0) {	1754	return .void_value;
1741	// We treat this case differently so that we don't get a crash when	1755	},
1742	// analyzing field_base_ptr against an alloc_inferred_mut.	1756	.inferred_ptr => {
1743	// See corresponding logic in arrayInitExpr.	1757	// We can't get field pointers of an untyped inferred alloc, so must perform a
1744	const result = try structInitExprRlNone(gz, scope, node, struct_init, .none, .struct_init_anon);	1758	// standard anonymous initialization followed by an rvalue store.
1745	return rvalue(gz, ri, result, node);	1759	// See corresponding logic in arrayInitExpr.
1746	} else {	1760	const struct_inst = try structInitExprAnon(gz, scope, node, struct_init);
1747	return structInitExprRlPtr(gz, scope, node, struct_init, ptr_inst);	1761	return rvalue(gz, ri, struct_inst, node);
1748	}
1749	},	1762	},
1750	.destructure => \|destructure\| {	1763	.destructure => \|destructure\| {
1751	if (struct_init.ast.type_expr == 0) {	1764	// This is an untyped init, so is an actual struct, which does
1752	// This is an untyped init, so is an actual struct, which does	1765	// not support destructuring.
1753	// not support destructuring.	1766	return astgen.failNodeNotes(node, "struct value cannot be destructured", .{}, &.{
1754	return astgen.failNodeNotes(node, "struct value cannot be destructured", .{}, &.{	1767	try astgen.errNoteNode(destructure.src_node, "result destructured here", .{}),
1755	try astgen.errNoteNode(destructure.src_node, "result destructured here", .{}),	1768	});
1756	});
1757	}
1758	// You can init tuples using struct init syntax and numeric field
1759	// names, but as with array inits, we could be bitten by default
1760	// fields. Therefore, we do a normal typed init then an rvalue
1761	// destructure.
1762	const ty_inst = try typeExpr(gz, scope, struct_init.ast.type_expr);
1763	_ = try gz.addUnNode(.validate_struct_init_ty, ty_inst, node);
1764	const result = try structInitExprRlTy(gz, scope, node, struct_init, ty_inst, .struct_init);
1765	return rvalue(gz, ri, result, node);
1766	},	1769	},
1767	}	1770	}
1768	}	1771	}
1769		1772
1770	fn structInitExprRlNone(	1773	/// A struct initialization expression using a `struct_init_anon` instruction.
		1774	fn structInitExprAnon(
1771	gz: *GenZir,	1775	gz: *GenZir,
1772	scope: *Scope,	1776	scope: *Scope,
1773	node: Ast.Node.Index,	1777	node: Ast.Node.Index,
1774	struct_init: Ast.full.StructInit,	1778	struct_init: Ast.full.StructInit,
1775	ty_inst: Zir.Inst.Ref,
1776	tag: Zir.Inst.Tag,
1777	) InnerError!Zir.Inst.Ref {	1779	) InnerError!Zir.Inst.Ref {
1778	const astgen = gz.astgen;	1780	const astgen = gz.astgen;
1779	const tree = astgen.tree;	1781	const tree = astgen.tree;
...	@@ -1787,104 +1789,83 @@ fn structInitExprRlNone(	...	@@ -1787,104 +1789,83 @@ fn structInitExprRlNone(
1787	for (struct_init.ast.fields) \|field_init\| {	1789	for (struct_init.ast.fields) \|field_init\| {
1788	const name_token = tree.firstToken(field_init) - 2;	1790	const name_token = tree.firstToken(field_init) - 2;
1789	const str_index = try astgen.identAsString(name_token);	1791	const str_index = try astgen.identAsString(name_token);
1790	const sub_ri: ResultInfo = if (ty_inst != .none)
1791	ResultInfo{ .rl = .{ .ty = try gz.addPlNode(.field_type, field_init, Zir.Inst.FieldType{
1792	.container_type = ty_inst,
1793	.name_start = str_index,
1794	}) } }
1795	else
1796	.{ .rl = .none };
1797	setExtra(astgen, extra_index, Zir.Inst.StructInitAnon.Item{	1792	setExtra(astgen, extra_index, Zir.Inst.StructInitAnon.Item{
1798	.field_name = str_index,	1793	.field_name = str_index,
1799	.init = try expr(gz, scope, sub_ri, field_init),	1794	.init = try expr(gz, scope, .{ .rl = .none }, field_init),
1800	});	1795	});
1801	extra_index += field_size;	1796	extra_index += field_size;
1802	}	1797	}
1803		1798
1804	return try gz.addPlNodePayloadIndex(tag, node, payload_index);	1799	return gz.addPlNodePayloadIndex(.struct_init_anon, node, payload_index);
1805	}
1806
1807	fn structInitExprRlPtr(
1808	gz: *GenZir,
1809	scope: *Scope,
1810	node: Ast.Node.Index,
1811	struct_init: Ast.full.StructInit,
1812	result_ptr: Zir.Inst.Ref,
1813	) InnerError!Zir.Inst.Ref {
1814	if (struct_init.ast.type_expr == 0) {
1815	const base_ptr = try gz.addUnNode(.field_base_ptr, result_ptr, node);
1816	return structInitExprRlPtrInner(gz, scope, node, struct_init, base_ptr);
1817	}
1818	const ty_inst = try typeExpr(gz, scope, struct_init.ast.type_expr);
1819	_ = try gz.addUnNode(.validate_struct_init_ty, ty_inst, node);
1820
1821	const casted_ptr = try gz.addPlNode(.coerce_result_ptr, node, Zir.Inst.Bin{ .lhs = ty_inst, .rhs = result_ptr });
1822	return structInitExprRlPtrInner(gz, scope, node, struct_init, casted_ptr);
1823	}	1800	}
1824		1801
1825	fn structInitExprRlPtrInner(	1802	/// A struct initialization expression using a `struct_init` or `struct_init_ref` instruction.
		1803	fn structInitExprTyped(
1826	gz: *GenZir,	1804	gz: *GenZir,
1827	scope: *Scope,	1805	scope: *Scope,
1828	node: Ast.Node.Index,	1806	node: Ast.Node.Index,
1829	struct_init: Ast.full.StructInit,	1807	struct_init: Ast.full.StructInit,
1830	result_ptr: Zir.Inst.Ref,	1808	ty_inst: Zir.Inst.Ref,
		1809	is_ref: bool,
1831	) InnerError!Zir.Inst.Ref {	1810	) InnerError!Zir.Inst.Ref {
1832	const astgen = gz.astgen;	1811	const astgen = gz.astgen;
1833	const tree = astgen.tree;	1812	const tree = astgen.tree;
1834		1813
1835	const payload_index = try addExtra(astgen, Zir.Inst.Block{	1814	const payload_index = try addExtra(astgen, Zir.Inst.StructInit{
1836	.body_len = @intCast(struct_init.ast.fields.len),	1815	.fields_len = @intCast(struct_init.ast.fields.len),
1837	});	1816	});
1838	var extra_index = try reserveExtra(astgen, struct_init.ast.fields.len);	1817	const field_size = @typeInfo(Zir.Inst.StructInit.Item).Struct.fields.len;
		1818	var extra_index: usize = try reserveExtra(astgen, struct_init.ast.fields.len * field_size);
1839		1819
1840	for (struct_init.ast.fields) \|field_init\| {	1820	for (struct_init.ast.fields) \|field_init\| {
1841	const name_token = tree.firstToken(field_init) - 2;	1821	const name_token = tree.firstToken(field_init) - 2;
1842	const str_index = try astgen.identAsString(name_token);	1822	const str_index = try astgen.identAsString(name_token);
1843	const field_ptr = try gz.addPlNode(.field_ptr_init, field_init, Zir.Inst.Field{	1823	const field_ty_inst = try gz.addPlNode(.struct_init_field_type, field_init, Zir.Inst.FieldType{
1844	.lhs = result_ptr,	1824	.container_type = ty_inst,
1845	.field_name_start = str_index,	1825	.name_start = str_index,
1846	});	1826	});
1847	astgen.extra.items[extra_index] = refToIndex(field_ptr).?;	1827	setExtra(astgen, extra_index, Zir.Inst.StructInit.Item{
1848	extra_index += 1;	1828	.field_type = refToIndex(field_ty_inst).?,
1849	_ = try expr(gz, scope, .{ .rl = .{ .ptr = .{ .inst = field_ptr } } }, field_init);	1829	.init = try expr(gz, scope, .{ .rl = .{ .coerced_ty = field_ty_inst } }, field_init),
		1830	});
		1831	extra_index += field_size;
1850	}	1832	}
1851		1833
1852	_ = try gz.addPlNodePayloadIndex(.validate_struct_init, node, payload_index);	1834	const tag: Zir.Inst.Tag = if (is_ref) .struct_init_ref else .struct_init;
1853	return Zir.Inst.Ref.void_value;	1835	return gz.addPlNodePayloadIndex(tag, node, payload_index);
1854	}	1836	}
1855		1837
1856	fn structInitExprRlTy(	1838	/// A struct initialization expression using field pointers.
		1839	fn structInitExprPtr(
1857	gz: *GenZir,	1840	gz: *GenZir,
1858	scope: *Scope,	1841	scope: *Scope,
1859	node: Ast.Node.Index,	1842	node: Ast.Node.Index,
1860	struct_init: Ast.full.StructInit,	1843	struct_init: Ast.full.StructInit,
1861	ty_inst: Zir.Inst.Ref,	1844	ptr_inst: Zir.Inst.Ref,
1862	tag: Zir.Inst.Tag,	1845	) InnerError!void {
1863	) InnerError!Zir.Inst.Ref {
1864	const astgen = gz.astgen;	1846	const astgen = gz.astgen;
1865	const tree = astgen.tree;	1847	const tree = astgen.tree;
1866		1848
1867	const payload_index = try addExtra(astgen, Zir.Inst.StructInit{	1849	const struct_ptr_inst = try gz.addUnNode(.opt_eu_base_ptr_init, ptr_inst, node);
1868	.fields_len = @intCast(struct_init.ast.fields.len),	1850
		1851	const payload_index = try addExtra(astgen, Zir.Inst.Block{
		1852	.body_len = @intCast(struct_init.ast.fields.len),
1869	});	1853	});
1870	const field_size = @typeInfo(Zir.Inst.StructInit.Item).Struct.fields.len;	1854	var extra_index = try reserveExtra(astgen, struct_init.ast.fields.len);
1871	var extra_index: usize = try reserveExtra(astgen, struct_init.ast.fields.len * field_size);
1872		1855
1873	for (struct_init.ast.fields) \|field_init\| {	1856	for (struct_init.ast.fields) \|field_init\| {
1874	const name_token = tree.firstToken(field_init) - 2;	1857	const name_token = tree.firstToken(field_init) - 2;
1875	const str_index = try astgen.identAsString(name_token);	1858	const str_index = try astgen.identAsString(name_token);
1876	const field_ty_inst = try gz.addPlNode(.field_type, field_init, Zir.Inst.FieldType{	1859	const field_ptr = try gz.addPlNode(.struct_init_field_ptr, field_init, Zir.Inst.Field{
1877	.container_type = ty_inst,	1860	.lhs = struct_ptr_inst,
1878	.name_start = str_index,	1861	.field_name_start = str_index,
1879	});
1880	setExtra(astgen, extra_index, Zir.Inst.StructInit.Item{
1881	.field_type = refToIndex(field_ty_inst).?,
1882	.init = try expr(gz, scope, .{ .rl = .{ .ty = field_ty_inst } }, field_init),
1883	});	1862	});
1884	extra_index += field_size;	1863	astgen.extra.items[extra_index] = refToIndex(field_ptr).?;
		1864	extra_index += 1;
		1865	_ = try expr(gz, scope, .{ .rl = .{ .ptr = .{ .inst = field_ptr } } }, field_init);
1885	}	1866	}
1886		1867
1887	return try gz.addPlNodePayloadIndex(tag, node, payload_index);	1868	_ = try gz.addPlNodePayloadIndex(.validate_ptr_struct_init, node, payload_index);
1888	}	1869	}
1889		1870
1890	/// This explicitly calls expr in a comptime scope by wrapping it in a `block_comptime` if	1871	/// This explicitly calls expr in a comptime scope by wrapping it in a `block_comptime` if
...	@@ -2314,7 +2295,7 @@ fn labeledBlockExpr(	...	@@ -2314,7 +2295,7 @@ fn labeledBlockExpr(
2314	const need_rl = astgen.nodes_need_rl.contains(block_node);	2295	const need_rl = astgen.nodes_need_rl.contains(block_node);
2315	const block_ri: ResultInfo = if (need_rl) ri else .{	2296	const block_ri: ResultInfo = if (need_rl) ri else .{
2316	.rl = switch (ri.rl) {	2297	.rl = switch (ri.rl) {
2317	.ptr => .{ .ty = try ri.rl.resultType(gz, block_node, undefined) },	2298	.ptr => .{ .ty = (try ri.rl.resultType(gz, block_node)).? },
2318	.inferred_ptr => .none,	2299	.inferred_ptr => .none,
2319	else => ri.rl,	2300	else => ri.rl,
2320	},	2301	},
...	@@ -2504,7 +2485,6 @@ fn addEnsureResult(gz: *GenZir, maybe_unused_result: Zir.Inst.Ref, statement: As	...	@@ -2504,7 +2485,6 @@ fn addEnsureResult(gz: *GenZir, maybe_unused_result: Zir.Inst.Ref, statement: As
2504	.array_mul,	2485	.array_mul,
2505	.array_type,	2486	.array_type,
2506	.array_type_sentinel,	2487	.array_type_sentinel,
2507	.elem_type_index,
2508	.elem_type,	2488	.elem_type,
2509	.indexable_ptr_elem_type,	2489	.indexable_ptr_elem_type,
2510	.vector_elem_type,	2490	.vector_elem_type,
...	@@ -2531,7 +2511,6 @@ fn addEnsureResult(gz: *GenZir, maybe_unused_result: Zir.Inst.Ref, statement: As	...	@@ -2531,7 +2511,6 @@ fn addEnsureResult(gz: *GenZir, maybe_unused_result: Zir.Inst.Ref, statement: As
2531	.cmp_gte,	2511	.cmp_gte,
2532	.cmp_gt,	2512	.cmp_gt,
2533	.cmp_neq,	2513	.cmp_neq,
2534	.coerce_result_ptr,
2535	.decl_ref,	2514	.decl_ref,
2536	.decl_val,	2515	.decl_val,
2537	.load,	2516	.load,
...	@@ -2539,11 +2518,9 @@ fn addEnsureResult(gz: *GenZir, maybe_unused_result: Zir.Inst.Ref, statement: As	...	@@ -2539,11 +2518,9 @@ fn addEnsureResult(gz: *GenZir, maybe_unused_result: Zir.Inst.Ref, statement: As
2539	.elem_ptr,	2518	.elem_ptr,
2540	.elem_val,	2519	.elem_val,
2541	.elem_ptr_node,	2520	.elem_ptr_node,
2542	.elem_ptr_imm,
2543	.elem_val_node,	2521	.elem_val_node,
2544	.elem_val_imm,	2522	.elem_val_imm,
2545	.field_ptr,	2523	.field_ptr,
2546	.field_ptr_init,
2547	.field_val,	2524	.field_val,
2548	.field_ptr_named,	2525	.field_ptr_named,
2549	.field_val_named,	2526	.field_val_named,
...	@@ -2599,17 +2576,7 @@ fn addEnsureResult(gz: *GenZir, maybe_unused_result: Zir.Inst.Ref, statement: As	...	@@ -2599,17 +2576,7 @@ fn addEnsureResult(gz: *GenZir, maybe_unused_result: Zir.Inst.Ref, statement: As
2599	.import,	2576	.import,
2600	.switch_block,	2577	.switch_block,
2601	.switch_block_ref,	2578	.switch_block_ref,
2602	.struct_init_empty,
2603	.struct_init,
2604	.struct_init_ref,
2605	.struct_init_anon,
2606	.struct_init_anon_ref,
2607	.array_init,
2608	.array_init_anon,
2609	.array_init_ref,
2610	.array_init_anon_ref,
2611	.union_init,	2579	.union_init,
2612	.field_type,
2613	.field_type_ref,	2580	.field_type_ref,
2614	.error_set_decl,	2581	.error_set_decl,
2615	.error_set_decl_anon,	2582	.error_set_decl_anon,
...	@@ -2680,14 +2647,27 @@ fn addEnsureResult(gz: *GenZir, maybe_unused_result: Zir.Inst.Ref, statement: As	...	@@ -2680,14 +2647,27 @@ fn addEnsureResult(gz: *GenZir, maybe_unused_result: Zir.Inst.Ref, statement: As
2680	.@"await",	2647	.@"await",
2681	.ret_err_value_code,	2648	.ret_err_value_code,
2682	.closure_get,	2649	.closure_get,
2683	.array_base_ptr,
2684	.field_base_ptr,
2685	.ret_ptr,	2650	.ret_ptr,
2686	.ret_type,	2651	.ret_type,
2687	.for_len,	2652	.for_len,
2688	.@"try",	2653	.@"try",
2689	.try_ptr,	2654	.try_ptr,
2690	.opt_eu_base_ty,	2655	.opt_eu_base_ptr_init,
		2656	.coerce_ptr_elem_ty,
		2657	.struct_init_empty,
		2658	.struct_init_empty_result,
		2659	.struct_init_empty_ref_result,
		2660	.struct_init_anon,
		2661	.struct_init,
		2662	.struct_init_ref,
		2663	.struct_init_field_type,
		2664	.struct_init_field_ptr,
		2665	.array_init_anon,
		2666	.array_init,
		2667	.array_init_ref,
		2668	.validate_array_init_ref_ty,
		2669	.array_init_elem_type,
		2670	.array_init_elem_ptr,
2691	=> break :b false,	2671	=> break :b false,
2692		2672
2693	.extended => switch (gz.astgen.instructions.items(.data)[inst].extended.opcode) {	2673	.extended => switch (gz.astgen.instructions.items(.data)[inst].extended.opcode) {
...	@@ -2738,18 +2718,21 @@ fn addEnsureResult(gz: *GenZir, maybe_unused_result: Zir.Inst.Ref, statement: As	...	@@ -2738,18 +2718,21 @@ fn addEnsureResult(gz: *GenZir, maybe_unused_result: Zir.Inst.Ref, statement: As
2738	.store_node,	2718	.store_node,
2739	.store_to_inferred_ptr,	2719	.store_to_inferred_ptr,
2740	.resolve_inferred_alloc,	2720	.resolve_inferred_alloc,
2741	.validate_struct_init,
2742	.validate_array_init,
2743	.set_runtime_safety,	2721	.set_runtime_safety,
2744	.closure_capture,	2722	.closure_capture,
2745	.memcpy,	2723	.memcpy,
2746	.memset,	2724	.memset,
2747	.validate_array_init_ty,
2748	.validate_struct_init_ty,
2749	.validate_deref,	2725	.validate_deref,
2750	.validate_destructure,	2726	.validate_destructure,
2751	.save_err_ret_index,	2727	.save_err_ret_index,
2752	.restore_err_ret_index,	2728	.restore_err_ret_index,
		2729	.validate_struct_init_ty,
		2730	.validate_struct_init_result_ty,
		2731	.validate_ptr_struct_init,
		2732	.validate_array_init_ty,
		2733	.validate_array_init_result_ty,
		2734	.validate_ptr_array_init,
		2735	.validate_ref_ty,
2753	=> break :b true,	2736	=> break :b true,
2754		2737
2755	.@"defer" => unreachable,	2738	.@"defer" => unreachable,
...	@@ -5635,7 +5618,7 @@ fn tryExpr(	...	@@ -5635,7 +5618,7 @@ fn tryExpr(
5635	const try_lc = LineColumn{ astgen.source_line - parent_gz.decl_line, astgen.source_column };	5618	const try_lc = LineColumn{ astgen.source_line - parent_gz.decl_line, astgen.source_column };
5636		5619
5637	const operand_ri: ResultInfo = switch (ri.rl) {	5620	const operand_ri: ResultInfo = switch (ri.rl) {
5638	.ref => .{ .rl = .ref, .ctx = .error_handling_expr },	5621	.ref, .ref_coerced_ty => .{ .rl = .ref, .ctx = .error_handling_expr },
5639	else => .{ .rl = .none, .ctx = .error_handling_expr },	5622	else => .{ .rl = .none, .ctx = .error_handling_expr },
5640	};	5623	};
5641	// This could be a pointer or value depending on the `ri` parameter.	5624	// This could be a pointer or value depending on the `ri` parameter.
...	@@ -5648,7 +5631,7 @@ fn tryExpr(	...	@@ -5648,7 +5631,7 @@ fn tryExpr(
5648	defer else_scope.unstack();	5631	defer else_scope.unstack();
5649		5632
5650	const err_tag = switch (ri.rl) {	5633	const err_tag = switch (ri.rl) {
5651	.ref => Zir.Inst.Tag.err_union_code_ptr,	5634	.ref, .ref_coerced_ty => Zir.Inst.Tag.err_union_code_ptr,
5652	else => Zir.Inst.Tag.err_union_code,	5635	else => Zir.Inst.Tag.err_union_code,
5653	};	5636	};
5654	const err_code = try else_scope.addUnNode(err_tag, operand, node);	5637	const err_code = try else_scope.addUnNode(err_tag, operand, node);
...	@@ -5659,7 +5642,7 @@ fn tryExpr(	...	@@ -5659,7 +5642,7 @@ fn tryExpr(
5659	try else_scope.setTryBody(try_inst, operand);	5642	try else_scope.setTryBody(try_inst, operand);
5660	const result = indexToRef(try_inst);	5643	const result = indexToRef(try_inst);
5661	switch (ri.rl) {	5644	switch (ri.rl) {
5662	.ref => return result,	5645	.ref, .ref_coerced_ty => return result,
5663	else => return rvalue(parent_gz, ri, result, node),	5646	else => return rvalue(parent_gz, ri, result, node),
5664	}	5647	}
5665	}	5648	}
...	@@ -5682,7 +5665,7 @@ fn orelseCatchExpr(	...	@@ -5682,7 +5665,7 @@ fn orelseCatchExpr(
5682	const need_rl = astgen.nodes_need_rl.contains(node);	5665	const need_rl = astgen.nodes_need_rl.contains(node);
5683	const block_ri: ResultInfo = if (need_rl) ri else .{	5666	const block_ri: ResultInfo = if (need_rl) ri else .{
5684	.rl = switch (ri.rl) {	5667	.rl = switch (ri.rl) {
5685	.ptr => .{ .ty = try ri.rl.resultType(parent_gz, node, undefined) },	5668	.ptr => .{ .ty = (try ri.rl.resultType(parent_gz, node)).? },
5686	.inferred_ptr => .none,	5669	.inferred_ptr => .none,
5687	else => ri.rl,	5670	else => ri.rl,
5688	},	5671	},
...	@@ -5700,7 +5683,7 @@ fn orelseCatchExpr(	...	@@ -5700,7 +5683,7 @@ fn orelseCatchExpr(
5700	defer block_scope.unstack();	5683	defer block_scope.unstack();
5701		5684
5702	const operand_ri: ResultInfo = switch (block_scope.break_result_info.rl) {	5685	const operand_ri: ResultInfo = switch (block_scope.break_result_info.rl) {
5703	.ref => .{ .rl = .ref, .ctx = if (do_err_trace) .error_handling_expr else .none },	5686	.ref, .ref_coerced_ty => .{ .rl = .ref, .ctx = if (do_err_trace) .error_handling_expr else .none },
5704	else => .{ .rl = .none, .ctx = if (do_err_trace) .error_handling_expr else .none },	5687	else => .{ .rl = .none, .ctx = if (do_err_trace) .error_handling_expr else .none },
5705	};	5688	};
5706	// This could be a pointer or value depending on the `operand_ri` parameter.	5689	// This could be a pointer or value depending on the `operand_ri` parameter.
...	@@ -5722,7 +5705,7 @@ fn orelseCatchExpr(	...	@@ -5722,7 +5705,7 @@ fn orelseCatchExpr(
5722	// This could be a pointer or value depending on `unwrap_op`.	5705	// This could be a pointer or value depending on `unwrap_op`.
5723	const unwrapped_payload = try then_scope.addUnNode(unwrap_op, operand, node);	5706	const unwrapped_payload = try then_scope.addUnNode(unwrap_op, operand, node);
5724	const then_result = switch (ri.rl) {	5707	const then_result = switch (ri.rl) {
5725	.ref => unwrapped_payload,	5708	.ref, .ref_coerced_ty => unwrapped_payload,
5726	else => try rvalue(&then_scope, block_scope.break_result_info, unwrapped_payload, node),	5709	else => try rvalue(&then_scope, block_scope.break_result_info, unwrapped_payload, node),
5727	};	5710	};
5728	_ = try then_scope.addBreakWithSrcNode(.@"break", block, then_result, node);	5711	_ = try then_scope.addBreakWithSrcNode(.@"break", block, then_result, node);
...	@@ -5793,7 +5776,7 @@ fn fieldAccess(	...	@@ -5793,7 +5776,7 @@ fn fieldAccess(
5793	node: Ast.Node.Index,	5776	node: Ast.Node.Index,
5794	) InnerError!Zir.Inst.Ref {	5777	) InnerError!Zir.Inst.Ref {
5795	switch (ri.rl) {	5778	switch (ri.rl) {
5796	.ref => return addFieldAccess(.field_ptr, gz, scope, .{ .rl = .ref }, node),	5779	.ref, .ref_coerced_ty => return addFieldAccess(.field_ptr, gz, scope, .{ .rl = .ref }, node),
5797	else => {	5780	else => {
5798	const access = try addFieldAccess(.field_val, gz, scope, .{ .rl = .none }, node);	5781	const access = try addFieldAccess(.field_val, gz, scope, .{ .rl = .none }, node);
5799	return rvalue(gz, ri, access, node);	5782	return rvalue(gz, ri, access, node);
...	@@ -5837,7 +5820,7 @@ fn arrayAccess(	...	@@ -5837,7 +5820,7 @@ fn arrayAccess(
5837	const tree = gz.astgen.tree;	5820	const tree = gz.astgen.tree;
5838	const node_datas = tree.nodes.items(.data);	5821	const node_datas = tree.nodes.items(.data);
5839	switch (ri.rl) {	5822	switch (ri.rl) {
5840	.ref => {	5823	.ref, .ref_coerced_ty => {
5841	const lhs = try expr(gz, scope, .{ .rl = .ref }, node_datas[node].lhs);	5824	const lhs = try expr(gz, scope, .{ .rl = .ref }, node_datas[node].lhs);
5842		5825
5843	const cursor = maybeAdvanceSourceCursorToMainToken(gz, node);	5826	const cursor = maybeAdvanceSourceCursorToMainToken(gz, node);
...	@@ -5951,7 +5934,7 @@ fn ifExpr(	...	@@ -5951,7 +5934,7 @@ fn ifExpr(
5951	const need_rl = astgen.nodes_need_rl.contains(node);	5934	const need_rl = astgen.nodes_need_rl.contains(node);
5952	const block_ri: ResultInfo = if (need_rl) ri else .{	5935	const block_ri: ResultInfo = if (need_rl) ri else .{
5953	.rl = switch (ri.rl) {	5936	.rl = switch (ri.rl) {
5954	.ptr => .{ .ty = try ri.rl.resultType(parent_gz, node, undefined) },	5937	.ptr => .{ .ty = (try ri.rl.resultType(parent_gz, node)).? },
5955	.inferred_ptr => .none,	5938	.inferred_ptr => .none,
5956	else => ri.rl,	5939	else => ri.rl,
5957	},	5940	},
...	@@ -6181,7 +6164,7 @@ fn whileExpr(	...	@@ -6181,7 +6164,7 @@ fn whileExpr(
6181	const need_rl = astgen.nodes_need_rl.contains(node);	6164	const need_rl = astgen.nodes_need_rl.contains(node);
6182	const block_ri: ResultInfo = if (need_rl) ri else .{	6165	const block_ri: ResultInfo = if (need_rl) ri else .{
6183	.rl = switch (ri.rl) {	6166	.rl = switch (ri.rl) {
6184	.ptr => .{ .ty = try ri.rl.resultType(parent_gz, node, undefined) },	6167	.ptr => .{ .ty = (try ri.rl.resultType(parent_gz, node)).? },
6185	.inferred_ptr => .none,	6168	.inferred_ptr => .none,
6186	else => ri.rl,	6169	else => ri.rl,
6187	},	6170	},
...	@@ -6455,7 +6438,7 @@ fn forExpr(	...	@@ -6455,7 +6438,7 @@ fn forExpr(
6455	const need_rl = astgen.nodes_need_rl.contains(node);	6438	const need_rl = astgen.nodes_need_rl.contains(node);
6456	const block_ri: ResultInfo = if (need_rl) ri else .{	6439	const block_ri: ResultInfo = if (need_rl) ri else .{
6457	.rl = switch (ri.rl) {	6440	.rl = switch (ri.rl) {
6458	.ptr => .{ .ty = try ri.rl.resultType(parent_gz, node, undefined) },	6441	.ptr => .{ .ty = (try ri.rl.resultType(parent_gz, node)).? },
6459	.inferred_ptr => .none,	6442	.inferred_ptr => .none,
6460	else => ri.rl,	6443	else => ri.rl,
6461	},	6444	},
...	@@ -6773,7 +6756,7 @@ fn switchExpr(	...	@@ -6773,7 +6756,7 @@ fn switchExpr(
6773	const need_rl = astgen.nodes_need_rl.contains(switch_node);	6756	const need_rl = astgen.nodes_need_rl.contains(switch_node);
6774	const block_ri: ResultInfo = if (need_rl) ri else .{	6757	const block_ri: ResultInfo = if (need_rl) ri else .{
6775	.rl = switch (ri.rl) {	6758	.rl = switch (ri.rl) {
6776	.ptr => .{ .ty = try ri.rl.resultType(parent_gz, switch_node, undefined) },	6759	.ptr => .{ .ty = (try ri.rl.resultType(parent_gz, switch_node)).? },
6777	.inferred_ptr => .none,	6760	.inferred_ptr => .none,
6778	else => ri.rl,	6761	else => ri.rl,
6779	},	6762	},
...	@@ -7465,7 +7448,7 @@ fn localVarRef(	...	@@ -7465,7 +7448,7 @@ fn localVarRef(
7465	gpa,	7448	gpa,
7466	);	7449	);
7467		7450
7468	return rvalue(gz, ri, value_inst, ident);	7451	return rvalueNoCoercePreRef(gz, ri, value_inst, ident);
7469	}	7452	}
7470	s = local_val.parent;	7453	s = local_val.parent;
7471	},	7454	},
...	@@ -7498,10 +7481,10 @@ fn localVarRef(	...	@@ -7498,10 +7481,10 @@ fn localVarRef(
7498	);	7481	);
7499		7482
7500	switch (ri.rl) {	7483	switch (ri.rl) {
7501	.ref => return ptr_inst,	7484	.ref, .ref_coerced_ty => return ptr_inst,
7502	else => {	7485	else => {
7503	const loaded = try gz.addUnNode(.load, ptr_inst, ident);	7486	const loaded = try gz.addUnNode(.load, ptr_inst, ident);
7504	return rvalue(gz, ri, loaded, ident);	7487	return rvalueNoCoercePreRef(gz, ri, loaded, ident);
7505	},	7488	},
7506	}	7489	}
7507	}	7490	}
...	@@ -7535,10 +7518,10 @@ fn localVarRef(	...	@@ -7535,10 +7518,10 @@ fn localVarRef(
7535	// Decl references happen by name rather than ZIR index so that when unrelated	7518	// Decl references happen by name rather than ZIR index so that when unrelated
7536	// decls are modified, ZIR code containing references to them can be unmodified.	7519	// decls are modified, ZIR code containing references to them can be unmodified.
7537	switch (ri.rl) {	7520	switch (ri.rl) {
7538	.ref => return gz.addStrTok(.decl_ref, name_str_index, ident_token),	7521	.ref, .ref_coerced_ty => return gz.addStrTok(.decl_ref, name_str_index, ident_token),
7539	else => {	7522	else => {
7540	const result = try gz.addStrTok(.decl_val, name_str_index, ident_token);	7523	const result = try gz.addStrTok(.decl_val, name_str_index, ident_token);
7541	return rvalue(gz, ri, result, ident);	7524	return rvalueNoCoercePreRef(gz, ri, result, ident);
7542	},	7525	},
7543	}	7526	}
7544	}	7527	}
...	@@ -7924,7 +7907,7 @@ fn bitCast(	...	@@ -7924,7 +7907,7 @@ fn bitCast(
7924	node: Ast.Node.Index,	7907	node: Ast.Node.Index,
7925	operand_node: Ast.Node.Index,	7908	operand_node: Ast.Node.Index,
7926	) InnerError!Zir.Inst.Ref {	7909	) InnerError!Zir.Inst.Ref {
7927	const dest_type = try ri.rl.resultType(gz, node, "@bitCast");	7910	const dest_type = try ri.rl.resultTypeForCast(gz, node, "@bitCast");
7928	const operand = try reachableExpr(gz, scope, .{ .rl = .none }, operand_node, node);	7911	const operand = try reachableExpr(gz, scope, .{ .rl = .none }, operand_node, node);
7929	const result = try gz.addPlNode(.bitcast, node, Zir.Inst.Bin{	7912	const result = try gz.addPlNode(.bitcast, node, Zir.Inst.Bin{
7930	.lhs = dest_type,	7913	.lhs = dest_type,
...	@@ -8024,7 +8007,7 @@ fn ptrCast(	...	@@ -8024,7 +8007,7 @@ fn ptrCast(
8024	// Full cast including result type	8007	// Full cast including result type
8025		8008
8026	const cursor = maybeAdvanceSourceCursorToMainToken(gz, root_node);	8009	const cursor = maybeAdvanceSourceCursorToMainToken(gz, root_node);
8027	const result_type = try ri.rl.resultType(gz, root_node, flags.needResultTypeBuiltinName());	8010	const result_type = try ri.rl.resultTypeForCast(gz, root_node, flags.needResultTypeBuiltinName());
8028	const operand = try expr(gz, scope, .{ .rl = .none }, node);	8011	const operand = try expr(gz, scope, .{ .rl = .none }, node);
8029	try emitDbgStmt(gz, cursor);	8012	try emitDbgStmt(gz, cursor);
8030	const result = try gz.addExtendedPayloadSmall(.ptr_cast_full, flags_i, Zir.Inst.BinNode{	8013	const result = try gz.addExtendedPayloadSmall(.ptr_cast_full, flags_i, Zir.Inst.BinNode{
...	@@ -8208,7 +8191,7 @@ fn builtinCall(	...	@@ -8208,7 +8191,7 @@ fn builtinCall(
8208	return rvalue(gz, ri, result, node);	8191	return rvalue(gz, ri, result, node);
8209	},	8192	},
8210	.field => {	8193	.field => {
8211	if (ri.rl == .ref) {	8194	if (ri.rl == .ref or ri.rl == .ref_coerced_ty) {
8212	return gz.addPlNode(.field_ptr_named, node, Zir.Inst.FieldNamed{	8195	return gz.addPlNode(.field_ptr_named, node, Zir.Inst.FieldNamed{
8213	.lhs = try expr(gz, scope, .{ .rl = .ref }, params[0]),	8196	.lhs = try expr(gz, scope, .{ .rl = .ref }, params[0]),
8214	.field_name = try comptimeExpr(gz, scope, .{ .rl = .{ .ty = .slice_const_u8_type } }, params[1]),	8197	.field_name = try comptimeExpr(gz, scope, .{ .rl = .{ .ty = .slice_const_u8_type } }, params[1]),
...	@@ -8475,7 +8458,7 @@ fn builtinCall(	...	@@ -8475,7 +8458,7 @@ fn builtinCall(
8475	try emitDbgNode(gz, node);	8458	try emitDbgNode(gz, node);
8476		8459
8477	const result = try gz.addExtendedPayload(.err_set_cast, Zir.Inst.BinNode{	8460	const result = try gz.addExtendedPayload(.err_set_cast, Zir.Inst.BinNode{
8478	.lhs = try ri.rl.resultType(gz, node, "@errSetCast"),	8461	.lhs = try ri.rl.resultTypeForCast(gz, node, "@errSetCast"),
8479	.rhs = try expr(gz, scope, .{ .rl = .none }, params[0]),	8462	.rhs = try expr(gz, scope, .{ .rl = .none }, params[0]),
8480	.node = gz.nodeIndexToRelative(node),	8463	.node = gz.nodeIndexToRelative(node),
8481	});	8464	});
...	@@ -8548,7 +8531,7 @@ fn builtinCall(	...	@@ -8548,7 +8531,7 @@ fn builtinCall(
8548	},	8531	},
8549		8532
8550	.splat => {	8533	.splat => {
8551	const result_type = try ri.rl.resultType(gz, node, "@splat");	8534	const result_type = try ri.rl.resultTypeForCast(gz, node, "@splat");
8552	const elem_type = try gz.addUnNode(.vector_elem_type, result_type, node);	8535	const elem_type = try gz.addUnNode(.vector_elem_type, result_type, node);
8553	const scalar = try expr(gz, scope, .{ .rl = .{ .ty = elem_type } }, params[0]);	8536	const scalar = try expr(gz, scope, .{ .rl = .{ .ty = elem_type } }, params[0]);
8554	const result = try gz.addPlNode(.splat, node, Zir.Inst.Bin{	8537	const result = try gz.addPlNode(.splat, node, Zir.Inst.Bin{
...	@@ -8810,7 +8793,7 @@ fn typeCast(	...	@@ -8810,7 +8793,7 @@ fn typeCast(
8810	builtin_name: []const u8,	8793	builtin_name: []const u8,
8811	) InnerError!Zir.Inst.Ref {	8794	) InnerError!Zir.Inst.Ref {
8812	const cursor = maybeAdvanceSourceCursorToMainToken(gz, node);	8795	const cursor = maybeAdvanceSourceCursorToMainToken(gz, node);
8813	const result_type = try ri.rl.resultType(gz, node, builtin_name);	8796	const result_type = try ri.rl.resultTypeForCast(gz, node, builtin_name);
8814	const operand = try expr(gz, scope, .{ .rl = .none }, operand_node);	8797	const operand = try expr(gz, scope, .{ .rl = .none }, operand_node);
8815		8798
8816	try emitDbgStmt(gz, cursor);	8799	try emitDbgStmt(gz, cursor);
...	@@ -10069,6 +10052,29 @@ fn rvalue(	...	@@ -10069,6 +10052,29 @@ fn rvalue(
10069	ri: ResultInfo,	10052	ri: ResultInfo,
10070	raw_result: Zir.Inst.Ref,	10053	raw_result: Zir.Inst.Ref,
10071	src_node: Ast.Node.Index,	10054	src_node: Ast.Node.Index,
		10055	) InnerError!Zir.Inst.Ref {
		10056	return rvalueInner(gz, ri, raw_result, src_node, true);
		10057	}
		10058
		10059	/// Like `rvalue`, but refuses to perform coercions before taking references for
		10060	/// the `ref_coerced_ty` result type. This is used for local variables which do
		10061	/// not have `alloc`s, because we want variables to have consistent addresses,
		10062	/// i.e. we want them to act like lvalues.
		10063	fn rvalueNoCoercePreRef(
		10064	gz: *GenZir,
		10065	ri: ResultInfo,
		10066	raw_result: Zir.Inst.Ref,
		10067	src_node: Ast.Node.Index,
		10068	) InnerError!Zir.Inst.Ref {
		10069	return rvalueInner(gz, ri, raw_result, src_node, false);
		10070	}
		10071
		10072	fn rvalueInner(
		10073	gz: *GenZir,
		10074	ri: ResultInfo,
		10075	raw_result: Zir.Inst.Ref,
		10076	src_node: Ast.Node.Index,
		10077	allow_coerce_pre_ref: bool,
10072	) InnerError!Zir.Inst.Ref {	10078	) InnerError!Zir.Inst.Ref {
10073	const result = r: {	10079	const result = r: {
10074	if (refToIndex(raw_result)) \|result_index\| {	10080	if (refToIndex(raw_result)) \|result_index\| {
...	@@ -10088,7 +10094,14 @@ fn rvalue(	...	@@ -10088,7 +10094,14 @@ fn rvalue(
10088	_ = try gz.addUnNode(.ensure_result_non_error, result, src_node);	10094	_ = try gz.addUnNode(.ensure_result_non_error, result, src_node);
10089	return .void_value;	10095	return .void_value;
10090	},	10096	},
10091	.ref => {	10097	.ref, .ref_coerced_ty => {
		10098	const coerced_result = if (allow_coerce_pre_ref and ri.rl == .ref_coerced_ty) res: {
		10099	const ptr_ty = ri.rl.ref_coerced_ty;
		10100	break :res try gz.addPlNode(.coerce_ptr_elem_ty, src_node, Zir.Inst.Bin{
		10101	.lhs = ptr_ty,
		10102	.rhs = result,
		10103	});
		10104	} else result;
10092	// We need a pointer but we have a value.	10105	// We need a pointer but we have a value.
10093	// Unfortunately it's not quite as simple as directly emitting a ref	10106	// Unfortunately it's not quite as simple as directly emitting a ref
10094	// instruction here because we need subsequent address-of operator on	10107	// instruction here because we need subsequent address-of operator on
...	@@ -10096,14 +10109,14 @@ fn rvalue(	...	@@ -10096,14 +10109,14 @@ fn rvalue(
10096	const astgen = gz.astgen;	10109	const astgen = gz.astgen;
10097	const tree = astgen.tree;	10110	const tree = astgen.tree;
10098	const src_token = tree.firstToken(src_node);	10111	const src_token = tree.firstToken(src_node);
10099	const result_index = refToIndex(result) orelse	10112	const result_index = refToIndex(coerced_result) orelse
10100	return gz.addUnTok(.ref, result, src_token);	10113	return gz.addUnTok(.ref, coerced_result, src_token);
10101	const zir_tags = gz.astgen.instructions.items(.tag);	10114	const zir_tags = gz.astgen.instructions.items(.tag);
10102	if (zir_tags[result_index].isParam() or astgen.isInferred(result))	10115	if (zir_tags[result_index].isParam() or astgen.isInferred(coerced_result))
10103	return gz.addUnTok(.ref, result, src_token);	10116	return gz.addUnTok(.ref, coerced_result, src_token);
10104	const gop = try astgen.ref_table.getOrPut(astgen.gpa, result_index);	10117	const gop = try astgen.ref_table.getOrPut(astgen.gpa, result_index);
10105	if (!gop.found_existing) {	10118	if (!gop.found_existing) {
10106	gop.value_ptr.* = try gz.makeUnTok(.ref, result, src_token);	10119	gop.value_ptr.* = try gz.makeUnTok(.ref, coerced_result, src_token);
10107	}	10120	}
10108	return indexToRef(gop.value_ptr.*);	10121	return indexToRef(gop.value_ptr.*);
10109	},	10122	},

src/AstRlAnnotate.zig+26-18

...	@@ -669,17 +669,21 @@ fn expr(astrl: AstRlAnnotate, node: Ast.Node.Index, block: ?Block, ri: ResultI	...	@@ -669,17 +669,21 @@ fn expr(astrl: AstRlAnnotate, node: Ast.Node.Index, block: ?Block, ri: ResultI
669	=> {	669	=> {
670	var buf: [2]Ast.Node.Index = undefined;	670	var buf: [2]Ast.Node.Index = undefined;
671	const full = tree.fullArrayInit(&buf, node).?;	671	const full = tree.fullArrayInit(&buf, node).?;
672	const have_type = if (full.ast.type_expr != 0) have_type: {	672
		673	if (full.ast.type_expr != 0) {
		674	// Explicitly typed init does not participate in RLS
673	_ = try astrl.expr(full.ast.type_expr, block, ResultInfo.none);	675	_ = try astrl.expr(full.ast.type_expr, block, ResultInfo.none);
674	break :have_type true;
675	} else ri.have_type;
676	if (have_type) {
677	const elem_ri: ResultInfo = .{
678	.have_type = true,
679	.have_ptr = ri.have_ptr,
680	};
681	for (full.ast.elements) \|elem_init\| {	676	for (full.ast.elements) \|elem_init\| {
682	_ = try astrl.expr(elem_init, block, elem_ri);	677	_ = try astrl.expr(elem_init, block, ResultInfo.type_only);
		678	}
		679	return false;
		680	}
		681
		682	if (ri.have_type) {
		683	// Always forward type information
		684	// If we have a result pointer, we use and forward it
		685	for (full.ast.elements) \|elem_init\| {
		686	_ = try astrl.expr(elem_init, block, ri);
683	}	687	}
684	return ri.have_ptr;	688	return ri.have_ptr;
685	} else {	689	} else {
...	@@ -702,17 +706,21 @@ fn expr(astrl: AstRlAnnotate, node: Ast.Node.Index, block: ?Block, ri: ResultI	...	@@ -702,17 +706,21 @@ fn expr(astrl: AstRlAnnotate, node: Ast.Node.Index, block: ?Block, ri: ResultI
702	=> {	706	=> {
703	var buf: [2]Ast.Node.Index = undefined;	707	var buf: [2]Ast.Node.Index = undefined;
704	const full = tree.fullStructInit(&buf, node).?;	708	const full = tree.fullStructInit(&buf, node).?;
705	const have_type = if (full.ast.type_expr != 0) have_type: {	709
		710	if (full.ast.type_expr != 0) {
		711	// Explicitly typed init does not participate in RLS
706	_ = try astrl.expr(full.ast.type_expr, block, ResultInfo.none);	712	_ = try astrl.expr(full.ast.type_expr, block, ResultInfo.none);
707	break :have_type true;
708	} else ri.have_type;
709	if (have_type) {
710	const elem_ri: ResultInfo = .{
711	.have_type = true,
712	.have_ptr = ri.have_ptr,
713	};
714	for (full.ast.fields) \|field_init\| {	713	for (full.ast.fields) \|field_init\| {
715	_ = try astrl.expr(field_init, block, elem_ri);	714	_ = try astrl.expr(field_init, block, ResultInfo.type_only);
		715	}
		716	return false;
		717	}
		718
		719	if (ri.have_type) {
		720	// Always forward type information
		721	// If we have a result pointer, we use and forward it
		722	for (full.ast.fields) \|field_init\| {
		723	_ = try astrl.expr(field_init, block, ri);
716	}	724	}
717	return ri.have_ptr;	725	return ri.have_ptr;
718	} else {	726	} else {

src/Autodoc.zig+3-34

...	@@ -2391,34 +2391,6 @@ fn walkInstruction(	...	@@ -2391,34 +2391,6 @@ fn walkInstruction(
2391	.expr = .{ .@"&" = expr_index },	2391	.expr = .{ .@"&" = expr_index },
2392	};	2392	};
2393	},	2393	},
2394	.array_init_anon_ref => {
2395	const pl_node = data[inst_index].pl_node;
2396	const extra = file.zir.extraData(Zir.Inst.MultiOp, pl_node.payload_index);
2397	const operands = file.zir.refSlice(extra.end, extra.data.operands_len);
2398	const array_data = try self.arena.alloc(usize, operands.len);
2399
2400	for (operands, 0..) \|op, idx\| {
2401	const wr = try self.walkRef(
2402	file,
2403	parent_scope,
2404	parent_src,
2405	op,
2406	false,
2407	call_ctx,
2408	);
2409	const expr_index = self.exprs.items.len;
2410	try self.exprs.append(self.arena, wr.expr);
2411	array_data[idx] = expr_index;
2412	}
2413
2414	const expr_index = self.exprs.items.len;
2415	try self.exprs.append(self.arena, .{ .array = array_data });
2416
2417	return DocData.WalkResult{
2418	.typeRef = null,
2419	.expr = .{ .@"&" = expr_index },
2420	};
2421	},
2422	.float => {	2394	.float => {
2423	const float = data[inst_index].float;	2395	const float = data[inst_index].float;
2424	return DocData.WalkResult{	2396	return DocData.WalkResult{
...	@@ -2709,9 +2681,7 @@ fn walkInstruction(	...	@@ -2709,9 +2681,7 @@ fn walkInstruction(
2709	.expr = .{ .declRef = decl_status },	2681	.expr = .{ .declRef = decl_status },
2710	};	2682	};
2711	},	2683	},
2712	.field_val, .field_ptr, .field_type => {	2684	.field_val, .field_ptr => {
2713	// TODO: field type uses Zir.Inst.FieldType, it just happens to have the
2714	// same layout as Zir.Inst.Field :^)
2715	const pl_node = data[inst_index].pl_node;	2685	const pl_node = data[inst_index].pl_node;
2716	const extra = file.zir.extraData(Zir.Inst.Field, pl_node.payload_index);	2686	const extra = file.zir.extraData(Zir.Inst.Field, pl_node.payload_index);
2717		2687
...	@@ -2730,8 +2700,7 @@ fn walkInstruction(	...	@@ -2730,8 +2700,7 @@ fn walkInstruction(
2730	};	2700	};
2731		2701
2732	if (tags[lhs] != .field_val and	2702	if (tags[lhs] != .field_val and
2733	tags[lhs] != .field_ptr and	2703	tags[lhs] != .field_ptr) break :blk lhs_extra.data.lhs;
2734	tags[lhs] != .field_type) break :blk lhs_extra.data.lhs;
2735		2704
2736	lhs_extra = file.zir.extraData(	2705	lhs_extra = file.zir.extraData(
2737	Zir.Inst.Field,	2706	Zir.Inst.Field,
...	@@ -2870,7 +2839,7 @@ fn walkInstruction(	...	@@ -2870,7 +2839,7 @@ fn walkInstruction(
2870		2839
2871	const field_name = blk: {	2840	const field_name = blk: {
2872	const field_inst_index = init_extra.data.field_type;	2841	const field_inst_index = init_extra.data.field_type;
2873	if (tags[field_inst_index] != .field_type) unreachable;	2842	if (tags[field_inst_index] != .struct_init_field_type) unreachable;
2874	const field_pl_node = data[field_inst_index].pl_node;	2843	const field_pl_node = data[field_inst_index].pl_node;
2875	const field_extra = file.zir.extraData(	2844	const field_extra = file.zir.extraData(
2876	Zir.Inst.FieldType,	2845	Zir.Inst.FieldType,

src/Sema.zig+478-447

 @@ -836,16 +836,11 @@ const LabeledBlock = struct {
 /// the items are contiguous in memory and thus can be passed to
 /// `Module.resolvePeerTypes`.
 const InferredAlloc = struct {
-    prongs: std.MultiArrayList(struct {
+    /// The placeholder `store` instructions used before the result pointer type
-        /// The dummy instruction used as a peer to resolve the type.
+    /// is known. These should be rewritten to perform any required coercions
-        /// Although this has a redundant type with placeholder, this is
+    /// when the type is resolved.
-        /// needed in addition because it may be a constant value, which
+    /// Allocated from `sema.arena`.
-        /// affects peer type resolution.
+    prongs: std.ArrayListUnmanaged(Air.Inst.Index) = .{},
-        stored_inst: Air.Inst.Ref,
-        /// The bitcast instruction used as a placeholder when the
-        /// new result pointer type is not yet known.
-        placeholder: Air.Inst.Index,
-    }) = .{},
 };
 const NeededComptimeReason = struct {
 @@ -1040,17 +1035,14 @@ fn analyzeBodyInner(
             .cmp_gte                      => try sema.zirCmp(block, inst, .gte),
             .cmp_gt                       => try sema.zirCmp(block, inst, .gt),
             .cmp_neq                      => try sema.zirCmpEq(block, inst, .neq, Air.Inst.Tag.fromCmpOp(.neq, block.float_mode == .Optimized)),
-            .coerce_result_ptr            => try sema.zirCoerceResultPtr(block, inst),
             .decl_ref                     => try sema.zirDeclRef(block, inst),
             .decl_val                     => try sema.zirDeclVal(block, inst),
             .load                         => try sema.zirLoad(block, inst),
             .elem_ptr                     => try sema.zirElemPtr(block, inst),
             .elem_ptr_node                => try sema.zirElemPtrNode(block, inst),
-            .elem_ptr_imm                 => try sema.zirElemPtrImm(block, inst),
             .elem_val                     => try sema.zirElemVal(block, inst),
             .elem_val_node                => try sema.zirElemValNode(block, inst),
             .elem_val_imm                 => try sema.zirElemValImm(block, inst),
-            .elem_type_index              => try sema.zirElemTypeIndex(block, inst),
             .elem_type                    => try sema.zirElemType(block, inst),
             .indexable_ptr_elem_type      => try sema.zirIndexablePtrElemType(block, inst),
             .vector_elem_type             => try sema.zirVectorElemType(block, inst),
 @@ -1063,8 +1055,7 @@ fn analyzeBodyInner(
             .err_union_payload_unsafe_ptr => try sema.zirErrUnionPayloadPtr(block, inst),
             .error_union_type             => try sema.zirErrorUnionType(block, inst),
             .error_value                  => try sema.zirErrorValue(block, inst),
-            .field_ptr                    => try sema.zirFieldPtr(block, inst, false),
+            .field_ptr                    => try sema.zirFieldPtr(block, inst),
-            .field_ptr_init               => try sema.zirFieldPtr(block, inst, true),
             .field_ptr_named              => try sema.zirFieldPtrNamed(block, inst),
             .field_val                    => try sema.zirFieldVal(block, inst),
             .field_val_named              => try sema.zirFieldValNamed(block, inst),
 @@ -1111,16 +1102,19 @@ fn analyzeBodyInner(
             .typeof_log2_int_type         => try sema.zirTypeofLog2IntType(block, inst),
             .xor                          => try sema.zirBitwise(block, inst, .xor),
             .struct_init_empty            => try sema.zirStructInitEmpty(block, inst),
+            .struct_init_empty_result     => try sema.zirStructInitEmptyResult(block, inst, false),
+            .struct_init_empty_ref_result => try sema.zirStructInitEmptyResult(block, inst, true),
+            .struct_init_anon             => try sema.zirStructInitAnon(block, inst),
             .struct_init                  => try sema.zirStructInit(block, inst, false),
             .struct_init_ref              => try sema.zirStructInit(block, inst, true),
-            .struct_init_anon             => try sema.zirStructInitAnon(block, inst, false),
+            .struct_init_field_type       => try sema.zirStructInitFieldType(block, inst),
-            .struct_init_anon_ref         => try sema.zirStructInitAnon(block, inst, true),
+            .struct_init_field_ptr        => try sema.zirStructInitFieldPtr(block, inst),
+            .array_init_anon              => try sema.zirArrayInitAnon(block, inst),
             .array_init                   => try sema.zirArrayInit(block, inst, false),
             .array_init_ref               => try sema.zirArrayInit(block, inst, true),
-            .array_init_anon              => try sema.zirArrayInitAnon(block, inst, false),
+            .array_init_elem_type         => try sema.zirArrayInitElemType(block, inst),
-            .array_init_anon_ref          => try sema.zirArrayInitAnon(block, inst, true),
+            .array_init_elem_ptr          => try sema.zirArrayInitElemPtr(block, inst),
             .union_init                   => try sema.zirUnionInit(block, inst),
-            .field_type                   => try sema.zirFieldType(block, inst),
             .field_type_ref               => try sema.zirFieldTypeRef(block, inst),
             .int_from_ptr                 => try sema.zirIntFromPtr(block, inst),
             .align_of                     => try sema.zirAlignOf(block, inst),
 @@ -1154,10 +1148,10 @@ fn analyzeBodyInner(
             .field_parent_ptr             => try sema.zirFieldParentPtr(block, inst),
             .@"resume"                    => try sema.zirResume(block, inst),
             .@"await"                     => try sema.zirAwait(block, inst),
-            .array_base_ptr               => try sema.zirArrayBasePtr(block, inst),
-            .field_base_ptr               => try sema.zirFieldBasePtr(block, inst),
             .for_len                      => try sema.zirForLen(block, inst),
-            .opt_eu_base_ty               => try sema.zirOptEuBaseTy(block, inst),
+            .validate_array_init_ref_ty   => try sema.zirValidateArrayInitRefTy(block, inst),
+            .opt_eu_base_ptr_init         => try sema.zirOptEuBasePtrInit(block, inst),
+            .coerce_ptr_elem_ty           => try sema.zirCoercePtrElemTy(block, inst),
             .clz       => try sema.zirBitCount(block, inst, .clz,      Value.clz),
             .ctz       => try sema.zirBitCount(block, inst, .ctz,      Value.ctz),
 @@ -1386,23 +1380,33 @@ fn analyzeBodyInner(
                 i += 1;
                 continue;
             },
+            .validate_struct_init_ty => {
+                try sema.zirValidateStructInitTy(block, inst, false);
+                i += 1;
+                continue;
+            },
+            .validate_struct_init_result_ty => {
+                try sema.zirValidateStructInitTy(block, inst, true);
+                i += 1;
+                continue;
+            },
             .validate_array_init_ty => {
-                try sema.zirValidateArrayInitTy(block, inst);
+                try sema.zirValidateArrayInitTy(block, inst, false);
                 i += 1;
                 continue;
             },
-            .validate_struct_init_ty => {
+            .validate_array_init_result_ty => {
-                try sema.zirValidateStructInitTy(block, inst);
+                try sema.zirValidateArrayInitTy(block, inst, true);
                 i += 1;
                 continue;
             },
-            .validate_struct_init => {
+            .validate_ptr_struct_init => {
-                try sema.zirValidateStructInit(block, inst);
+                try sema.zirValidatePtrStructInit(block, inst);
                 i += 1;
                 continue;
             },
-            .validate_array_init => {
+            .validate_ptr_array_init => {
-                try sema.zirValidateArrayInit(block, inst);
+                try sema.zirValidatePtrArrayInit(block, inst);
                 i += 1;
                 continue;
             },
 @@ -1416,6 +1420,11 @@ fn analyzeBodyInner(
                 i += 1;
                 continue;
             },
+            .validate_ref_ty => {
+                try sema.zirValidateRefTy(block, inst);
+                i += 1;
+                continue;
+            },
             .@"export" => {
                 try sema.zirExport(block, inst);
                 i += 1;
 @@ -1922,7 +1931,11 @@ fn resolveDestType(
             const msg = msg: {
                 const msg = try sema.errMsg(block, src, "{s} must have a known result type", .{builtin_name});
                 errdefer msg.destroy(sema.gpa);
-                try sema.errNote(block, src, msg, "result type is unknown due to anytype parameter", .{});
+                switch (sema.genericPoisonReason(zir_ref)) {
+                    .anytype_param => |call_src| try sema.errNote(block, call_src, msg, "result type is unknown due to anytype parameter", .{}),
+                    .anyopaque_ptr => |ptr_src| try sema.errNote(block, ptr_src, msg, "result type is unknown due to opaque pointer type", .{}),
+                    .unknown => {},
+                }
                 try sema.errNote(block, src, msg, "use @as to provide explicit result type", .{});
                 break :msg msg;
             };
 @@ -1944,6 +1957,65 @@ fn resolveDestType(
     return raw_ty;
 }
+const GenericPoisonReason = union(enum) {
+    anytype_param: LazySrcLoc,
+    anyopaque_ptr: LazySrcLoc,
+    unknown,
+};
+/// Backtracks through ZIR instructions to determine the reason a generic poison
+/// type was created. Used for error reporting.
+fn genericPoisonReason(sema: *Sema, ref: Zir.Inst.Ref) GenericPoisonReason {
+    var cur = ref;
+    while (true) {
+        const inst = Zir.refToIndex(cur) orelse return .unknown;
+        switch (sema.code.instructions.items(.tag)[inst]) {
+            .validate_array_init_ref_ty => {
+                const pl_node = sema.code.instructions.items(.data)[inst].pl_node;
+                const extra = sema.code.extraData(Zir.Inst.ArrayInitRefTy, pl_node.payload_index).data;
+                cur = extra.ptr_ty;
+            },
+            .array_init_elem_type => {
+                const bin = sema.code.instructions.items(.data)[inst].bin;
+                cur = bin.lhs;
+            },
+            .indexable_ptr_elem_type, .vector_elem_type => {
+                const un_node = sema.code.instructions.items(.data)[inst].un_node;
+                cur = un_node.operand;
+            },
+            .struct_init_field_type => {
+                const pl_node = sema.code.instructions.items(.data)[inst].pl_node;
+                const extra = sema.code.extraData(Zir.Inst.FieldType, pl_node.payload_index).data;
+                cur = extra.container_type;
+            },
+            .elem_type => {
+                // There are two cases here: the pointer type may already have been
+                // generic poison, or it may have been an anyopaque pointer.
+                const un_node = sema.code.instructions.items(.data)[inst].un_node;
+                const operand_ref = sema.resolveInst(un_node.operand) catch |err| switch (err) {
+                    error.GenericPoison => unreachable, // this is a type, not a value
+                };
+                const operand_val = Air.refToInterned(operand_ref) orelse return .unknown;
+                if (operand_val == .generic_poison_type) {
+                    // The pointer was generic poison - keep looking.
+                    cur = un_node.operand;
+                } else {
+                    // This must be an anyopaque pointer!
+                    return .{ .anyopaque_ptr = un_node.src() };
+                }
+            },
+            .call, .field_call => {
+                // A function call can never return generic poison, so we must be
+                // evaluating an `anytype` function parameter.
+                // TODO: better source location - function decl rather than call
+                const pl_node = sema.code.instructions.items(.data)[inst].pl_node;
+                return .{ .anytype_param = pl_node.src() };
+            },
+            else => return .unknown,
+        }
+    }
+}
 fn analyzeAsType(
     sema: *Sema,
     block: *Block,
 @@ -2634,217 +2706,6 @@ pub fn resolveInstValue(
     };
 }
-fn zirCoerceResultPtr(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
-    const tracy = trace(@src());
-    defer tracy.end();
-    const mod = sema.mod;
-    const inst_data = sema.code.instructions.items(.data)[inst].pl_node;
-    const src = inst_data.src();
-    const extra = sema.code.extraData(Zir.Inst.Bin, inst_data.payload_index).data;
-    const pointee_ty = try sema.resolveType(block, src, extra.lhs);
-    const ptr = try sema.resolveInst(extra.rhs);
-    const target = mod.getTarget();
-    const addr_space = target_util.defaultAddressSpace(target, .local);
-    if (Air.refToIndex(ptr)) |ptr_inst| {
-        switch (sema.air_instructions.items(.tag)[ptr_inst]) {
-            .inferred_alloc => {
-                const ia1 = sema.air_instructions.items(.data)[ptr_inst].inferred_alloc;
-                const ia2 = sema.unresolved_inferred_allocs.getPtr(ptr_inst).?;
-                // Add the stored instruction to the set we will use to resolve peer types
-                // for the inferred allocation.
-                // This instruction will not make it to codegen; it is only to participate
-                // in the `stored_inst_list` of the `inferred_alloc`.
-                var trash_block = block.makeSubBlock();
-                defer trash_block.instructions.deinit(sema.gpa);
-                const operand = try trash_block.addBitCast(pointee_ty, .void_value);
-                const ptr_ty = try sema.ptrType(.{
-                    .child = pointee_ty.toIntern(),
-                    .flags = .{
-                        .alignment = ia1.alignment,
-                        .address_space = addr_space,
-                    },
-                });
-                const bitcasted_ptr = try block.addBitCast(ptr_ty, ptr);
-                try ia2.prongs.append(sema.arena, .{
-                    .stored_inst = operand,
-                    .placeholder = Air.refToIndex(bitcasted_ptr).?,
-                });
-                try sema.checkKnownAllocPtr(ptr, bitcasted_ptr);
-                return bitcasted_ptr;
-            },
-            .inferred_alloc_comptime => {
-                const alignment = sema.air_instructions.items(.data)[ptr_inst].inferred_alloc_comptime.alignment;
-                // There will be only one coerce_result_ptr because we are running at comptime.
-                // The alloc will turn into a Decl.
-                var anon_decl = try block.startAnonDecl();
-                defer anon_decl.deinit();
-                const decl_index = try anon_decl.finish(
-                    pointee_ty,
-                    (try mod.intern(.{ .undef = pointee_ty.toIntern() })).toValue(),
-                    alignment,
-                );
-                sema.air_instructions.items(.data)[ptr_inst].inferred_alloc_comptime.decl_index = decl_index;
-                if (alignment != .none) {
-                    try sema.resolveTypeLayout(pointee_ty);
-                }
-                const ptr_ty = try sema.ptrType(.{
-                    .child = pointee_ty.toIntern(),
-                    .flags = .{
-                        .alignment = alignment,
-                        .address_space = addr_space,
-                    },
-                });
-                try sema.maybeQueueFuncBodyAnalysis(decl_index);
-                try sema.comptime_mutable_decls.append(decl_index);
-                return Air.internedToRef((try mod.intern(.{ .ptr = .{
-                    .ty = ptr_ty.toIntern(),
-                    .addr = .{ .mut_decl = .{
-                        .decl = decl_index,
-                        .runtime_index = block.runtime_index,
-                    } },
-                } })));
-            },
-            else => {},
-        }
-    }
-    // Make a dummy store through the pointer to test the coercion.
-    // We will then use the generated instructions to decide what
-    // kind of transformations to make on the result pointer.
-    var trash_block = block.makeSubBlock();
-    trash_block.is_comptime = false;
-    defer trash_block.instructions.deinit(sema.gpa);
-    const dummy_ptr = try trash_block.addTy(.alloc, sema.typeOf(ptr));
-    const dummy_operand = try trash_block.addBitCast(pointee_ty, .void_value);
-    const new_ptr = try sema.coerceResultPtr(block, src, ptr, dummy_ptr, dummy_operand, &trash_block);
-    try sema.checkKnownAllocPtr(ptr, new_ptr);
-    return new_ptr;
-}
-fn coerceResultPtr(
-    sema: *Sema,
-    block: *Block,
-    src: LazySrcLoc,
-    ptr: Air.Inst.Ref,
-    dummy_ptr: Air.Inst.Ref,
-    dummy_operand: Air.Inst.Ref,
-    trash_block: *Block,
-) CompileError!Air.Inst.Ref {
-    const mod = sema.mod;
-    const target = sema.mod.getTarget();
-    const addr_space = target_util.defaultAddressSpace(target, .local);
-    const pointee_ty = sema.typeOf(dummy_operand);
-    const prev_trash_len = trash_block.instructions.items.len;
-    try sema.storePtr2(trash_block, src, dummy_ptr, src, dummy_operand, src, .bitcast);
-    {
-        const air_tags = sema.air_instructions.items(.tag);
-        //std.debug.print("dummy storePtr instructions:\n", .{});
-        //for (trash_block.instructions.items) |item| {
-        //    std.debug.print("  {s}\n", .{@tagName(air_tags[item])});
-        //}
-        // The last one is always `store`.
-        const trash_inst = trash_block.instructions.items[trash_block.instructions.items.len - 1];
-        if (air_tags[trash_inst] != .store and air_tags[trash_inst] != .store_safe) {
-            // no store instruction is generated for zero sized types
-            assert((try sema.typeHasOnePossibleValue(pointee_ty)) != null);
-        } else {
-            trash_block.instructions.items.len -= 1;
-            assert(trash_inst == sema.air_instructions.len - 1);
-            sema.air_instructions.len -= 1;
-        }
-    }
-    const ptr_ty = try sema.ptrType(.{
-        .child = pointee_ty.toIntern(),
-        .flags = .{ .address_space = addr_space },
-    });
-    var new_ptr = ptr;
-    while (true) {
-        const air_tags = sema.air_instructions.items(.tag);
-        const air_datas = sema.air_instructions.items(.data);
-        if (trash_block.instructions.items.len == prev_trash_len) {
-            if (try sema.resolveDefinedValue(block, src, new_ptr)) |ptr_val| {
-                return Air.internedToRef(ptr_val.toIntern());
-            }
-            if (pointee_ty.eql(Type.null, sema.mod)) {
-                const null_inst = Air.internedToRef(Value.null.toIntern());
-                _ = try block.addBinOp(.store, new_ptr, null_inst);
-                return .void_value;
-            }
-            return sema.bitCast(block, ptr_ty, new_ptr, src, null);
-        }
-        const trash_inst = trash_block.instructions.pop();
-        switch (air_tags[trash_inst]) {
-            // Array coerced to Vector where element size is not equal but coercible.
-            .aggregate_init => {
-                const ty_pl = air_datas[trash_inst].ty_pl;
-                const ptr_operand_ty = try sema.ptrType(.{
-                    .child = (try sema.analyzeAsType(block, src, ty_pl.ty)).toIntern(),
-                    .flags = .{ .address_space = addr_space },
-                });
-                if (try sema.resolveDefinedValue(block, src, new_ptr)) |ptr_val| {
-                    return Air.internedToRef(ptr_val.toIntern());
-                } else {
-                    return sema.bitCast(block, ptr_operand_ty, new_ptr, src, null);
-                }
-            },
-            .bitcast => {
-                const ty_op = air_datas[trash_inst].ty_op;
-                const operand_ty = sema.typeOf(ty_op.operand);
-                const ptr_operand_ty = try sema.ptrType(.{
-                    .child = operand_ty.toIntern(),
-                    .flags = .{ .address_space = addr_space },
-                });
-                if (try sema.resolveDefinedValue(block, src, new_ptr)) |ptr_val| {
-                    new_ptr = Air.internedToRef((try mod.getCoerced(ptr_val, ptr_operand_ty)).toIntern());
-                } else {
-                    new_ptr = try sema.bitCast(block, ptr_operand_ty, new_ptr, src, null);
-                }
-            },
-            .wrap_optional => {
-                new_ptr = try sema.analyzeOptionalPayloadPtr(block, src, new_ptr, false, true);
-            },
-            .wrap_errunion_err => {
-                return sema.fail(block, src, "TODO coerce_result_ptr wrap_errunion_err", .{});
-            },
-            .wrap_errunion_payload => {
-                new_ptr = try sema.analyzeErrUnionPayloadPtr(block, src, new_ptr, false, true);
-            },
-            .array_to_slice => {
-                return sema.fail(block, src, "TODO coerce_result_ptr array_to_slice", .{});
-            },
-            .get_union_tag => {
-                return sema.fail(block, src, "TODO coerce_result_ptr get_union_tag", .{});
-            },
-            else => {
-                if (std.debug.runtime_safety) {
-                    std.debug.panic("unexpected AIR tag for coerce_result_ptr: {}", .{
-                        air_tags[trash_inst],
-                    });
-                } else {
-                    unreachable;
-                }
-            },
-        }
-    }
-}
 pub fn getStructType(
     sema: *Sema,
     decl: Module.Decl.Index,
 @@ -4220,8 +4081,13 @@ fn zirResolveInferredAlloc(sema: *Sema, block: *Block, inst: Zir.Inst.Index) Com
         .inferred_alloc => {
             const ia1 = sema.air_instructions.items(.data)[ptr_inst].inferred_alloc;
             const ia2 = sema.unresolved_inferred_allocs.fetchRemove(ptr_inst).?.value;
-            const peer_inst_list = ia2.prongs.items(.stored_inst);
+            const peer_vals = try sema.arena.alloc(Air.Inst.Ref, ia2.prongs.items.len);
-            const final_elem_ty = try sema.resolvePeerTypes(block, ty_src, peer_inst_list, .none);
+            for (peer_vals, ia2.prongs.items) |*peer_val, store_inst| {
+                assert(sema.air_instructions.items(.tag)[store_inst] == .store);
+                const bin_op = sema.air_instructions.items(.data)[store_inst].bin_op;
+                peer_val.* = bin_op.rhs;
+            }
+            const final_elem_ty = try sema.resolvePeerTypes(block, ty_src, peer_vals, .none);
             const final_ptr_ty = try sema.ptrType(.{
                 .child = final_elem_ty.toIntern(),
 @@ -4259,55 +4125,19 @@ fn zirResolveInferredAlloc(sema: *Sema, block: *Block, inst: Zir.Inst.Index) Com
                 .data = .{ .ty = final_ptr_ty },
             });
-            // Now we need to go back over all the coerce_result_ptr instructions, which
+            // Now we need to go back over all the store instructions, and do the logic as if
-            // previously inserted a bitcast as a placeholder, and do the logic as if
             // the new result ptr type was available.
-            const placeholders = ia2.prongs.items(.placeholder);
             const gpa = sema.gpa;
-            var trash_block = block.makeSubBlock();
+            for (ia2.prongs.items) |placeholder_inst| {
-            trash_block.is_comptime = false;
-            defer trash_block.instructions.deinit(gpa);
-            const mut_final_ptr_ty = try sema.ptrType(.{
-                .child = final_elem_ty.toIntern(),
-                .flags = .{
-                    .alignment = ia1.alignment,
-                    .address_space = target_util.defaultAddressSpace(target, .local),
-                },
-            });
-            const dummy_ptr = try trash_block.addTy(.alloc, mut_final_ptr_ty);
-            const empty_trash_count = trash_block.instructions.items.len;
-            for (peer_inst_list, placeholders) |peer_inst, placeholder_inst| {
-                const sub_ptr_ty = sema.typeOf(Air.indexToRef(placeholder_inst));
-                if (mut_final_ptr_ty.eql(sub_ptr_ty, mod)) {
-                    // New result location type is the same as the old one; nothing
-                    // to do here.
-                    continue;
-                }
                 var replacement_block = block.makeSubBlock();
                 defer replacement_block.instructions.deinit(gpa);
-                const result = switch (sema.air_instructions.items(.tag)[placeholder_inst]) {
+                assert(sema.air_instructions.items(.tag)[placeholder_inst] == .store);
-                    .bitcast => result: {
+                const bin_op = sema.air_instructions.items(.data)[placeholder_inst].bin_op;
-                        trash_block.instructions.shrinkRetainingCapacity(empty_trash_count);
+                try sema.storePtr2(&replacement_block, src, bin_op.lhs, src, bin_op.rhs, src, .store);
-                        const sub_ptr = try sema.coerceResultPtr(&replacement_block, src, ptr, dummy_ptr, peer_inst, &trash_block);
-                        assert(replacement_block.instructions.items.len > 0);
+                // If only one instruction is produced then we can replace the store
-                        break :result sub_ptr;
-                    },
-                    .store, .store_safe => result: {
-                        const bin_op = sema.air_instructions.items(.data)[placeholder_inst].bin_op;
-                        try sema.storePtr2(&replacement_block, src, bin_op.lhs, src, bin_op.rhs, src, .bitcast);
-                        break :result .void_value;
-                    },
-                    else => unreachable,
-                };
-                // If only one instruction is produced then we can replace the bitcast
                 // placeholder instruction with this instruction; no need for an entire block.
                 if (replacement_block.instructions.items.len == 1) {
                     const only_inst = replacement_block.instructions.items[0];
 @@ -4315,13 +4145,9 @@ fn zirResolveInferredAlloc(sema: *Sema, block: *Block, inst: Zir.Inst.Index) Com
                     continue;
                 }
-                // Here we replace the placeholder bitcast instruction with a block
+                // Here we replace the placeholder store instruction with a block
-                // that does the coerce_result_ptr logic.
+                // that does the actual store logic.
-                _ = try replacement_block.addBr(placeholder_inst, result);
+                _ = try replacement_block.addBr(placeholder_inst, .void_value);
-                const ty_inst = if (result == .void_value)
-                    .void_type
-                else
-                    sema.air_instructions.items(.data)[placeholder_inst].ty_op.ty;
                 try sema.air_extra.ensureUnusedCapacity(
                     gpa,
                     @typeInfo(Air.Block).Struct.fields.len + replacement_block.instructions.items.len,
 @@ -4329,7 +4155,7 @@ fn zirResolveInferredAlloc(sema: *Sema, block: *Block, inst: Zir.Inst.Index) Com
                 sema.air_instructions.set(placeholder_inst, .{
                     .tag = .block,
                     .data = .{ .ty_pl = .{
-                        .ty = ty_inst,
+                        .ty = .void_type,
                         .payload = sema.addExtraAssumeCapacity(Air.Block{
                             .body_len = @intCast(replacement_block.instructions.items.len),
                         }),
 @@ -4342,64 +4168,6 @@ fn zirResolveInferredAlloc(sema: *Sema, block: *Block, inst: Zir.Inst.Index) Com
     }
 }
-fn zirArrayBasePtr(
-    sema: *Sema,
-    block: *Block,
-    inst: Zir.Inst.Index,
-) CompileError!Air.Inst.Ref {
-    const mod = sema.mod;
-    const inst_data = sema.code.instructions.items(.data)[inst].un_node;
-    const src = inst_data.src();
-    const start_ptr = try sema.resolveInst(inst_data.operand);
-    var base_ptr = start_ptr;
-    while (true) switch (sema.typeOf(base_ptr).childType(mod).zigTypeTag(mod)) {
-        .ErrorUnion => base_ptr = try sema.analyzeErrUnionPayloadPtr(block, src, base_ptr, false, true),
-        .Optional => base_ptr = try sema.analyzeOptionalPayloadPtr(block, src, base_ptr, false, true),
-        else => break,
-    };
-    const elem_ty = sema.typeOf(base_ptr).childType(mod);
-    switch (elem_ty.zigTypeTag(mod)) {
-        .Array, .Vector => return base_ptr,
-        .Struct => if (elem_ty.isTuple(mod)) {
-            // TODO validate element count
-            try sema.checkKnownAllocPtr(start_ptr, base_ptr);
-            return base_ptr;
-        },
-        else => {},
-    }
-    return sema.failWithArrayInitNotSupported(block, src, sema.typeOf(start_ptr).childType(mod));
-}
-fn zirFieldBasePtr(
-    sema: *Sema,
-    block: *Block,
-    inst: Zir.Inst.Index,
-) CompileError!Air.Inst.Ref {
-    const mod = sema.mod;
-    const inst_data = sema.code.instructions.items(.data)[inst].un_node;
-    const src = inst_data.src();
-    const start_ptr = try sema.resolveInst(inst_data.operand);
-    var base_ptr = start_ptr;
-    while (true) switch (sema.typeOf(base_ptr).childType(mod).zigTypeTag(mod)) {
-        .ErrorUnion => base_ptr = try sema.analyzeErrUnionPayloadPtr(block, src, base_ptr, false, true),
-        .Optional => base_ptr = try sema.analyzeOptionalPayloadPtr(block, src, base_ptr, false, true),
-        else => break,
-    };
-    const elem_ty = sema.typeOf(base_ptr).childType(mod);
-    switch (elem_ty.zigTypeTag(mod)) {
-        .Struct, .Union => {
-            try sema.checkKnownAllocPtr(start_ptr, base_ptr);
-            return base_ptr;
-        },
-        else => {},
-    }
-    return sema.failWithStructInitNotSupported(block, src, sema.typeOf(start_ptr).childType(mod));
-}
 fn zirForLen(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
     const mod = sema.mod;
     const gpa = sema.gpa;
 @@ -4526,34 +4294,140 @@ fn zirForLen(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.
     return len;
 }
-fn zirOptEuBaseTy(
+/// Given any single pointer, retrieve a pointer to the payload of any optional
+/// or error union pointed to, initializing these pointers along the way.
+/// Given a `*E!?T`, returns a (valid) `*T`.
+/// May invalidate already-stored payload data.
+fn optEuBasePtrInit(sema: *Sema, block: *Block, ptr: Air.Inst.Ref, src: LazySrcLoc) CompileError!Air.Inst.Ref {
+    const mod = sema.mod;
+    var base_ptr = ptr;
+    while (true) switch (sema.typeOf(base_ptr).childType(mod).zigTypeTag(mod)) {
+        .ErrorUnion => base_ptr = try sema.analyzeErrUnionPayloadPtr(block, src, base_ptr, false, true),
+        .Optional => base_ptr = try sema.analyzeOptionalPayloadPtr(block, src, base_ptr, false, true),
+        else => break,
+    };
+    try sema.checkKnownAllocPtr(ptr, base_ptr);
+    return base_ptr;
+}
+fn zirOptEuBasePtrInit(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
+    const un_node = sema.code.instructions.items(.data)[inst].un_node;
+    const ptr = try sema.resolveInst(un_node.operand);
+    return sema.optEuBasePtrInit(block, ptr, un_node.src());
+}
+fn zirCoercePtrElemTy(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
+    const mod = sema.mod;
+    const pl_node = sema.code.instructions.items(.data)[inst].pl_node;
+    const src = pl_node.src();
+    const extra = sema.code.extraData(Zir.Inst.Bin, pl_node.payload_index).data;
+    const uncoerced_val = try sema.resolveInst(extra.rhs);
+    const maybe_wrapped_ptr_ty = sema.resolveType(block, .unneeded, extra.lhs) catch |err| switch (err) {
+        error.GenericPoison => return uncoerced_val,
+        else => |e| return e,
+    };
+    const ptr_ty = maybe_wrapped_ptr_ty.optEuBaseType(mod);
+    assert(ptr_ty.zigTypeTag(mod) == .Pointer); // validated by a previous instruction
+    const elem_ty = ptr_ty.childType(mod);
+    switch (ptr_ty.ptrSize(mod)) {
+        .One => {
+            const uncoerced_ty = sema.typeOf(uncoerced_val);
+            if (elem_ty.zigTypeTag(mod) == .Array and elem_ty.childType(mod).toIntern() == uncoerced_ty.toIntern()) {
+                // We're trying to initialize a *[1]T with a reference to a T - don't perform any coercion.
+                return uncoerced_val;
+            }
+            // If the destination type is anyopaque, don't coerce - the pointer will coerce instead.
+            if (elem_ty.toIntern() == .anyopaque_type) {
+                return uncoerced_val;
+            } else {
+                return sema.coerce(block, elem_ty, uncoerced_val, src);
+            }
+        },
+        .Slice, .Many => {
+            // Our goal is to coerce `uncoerced_val` to an array of `elem_ty`.
+            const val_ty = sema.typeOf(uncoerced_val);
+            switch (val_ty.zigTypeTag(mod)) {
+                .Array, .Vector => {},
+                else => if (!val_ty.isTuple(mod)) {
+                    return sema.fail(block, src, "expected array of '{}', found '{}'", .{ elem_ty.fmt(mod), val_ty.fmt(mod) });
+                },
+            }
+            const want_ty = try mod.arrayType(.{
+                .len = val_ty.arrayLen(mod),
+                .child = elem_ty.toIntern(),
+                .sentinel = if (ptr_ty.sentinel(mod)) |s| s.toIntern() else .none,
+            });
+            return sema.coerce(block, want_ty, uncoerced_val, src);
+        },
+        .C => {
+            // There's nothing meaningful to do here, because we don't know if this is meant to be a
+            // single-pointer or a many-pointer.
+            return uncoerced_val;
+        },
+    }
+}
+fn zirValidateRefTy(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!void {
+    const mod = sema.mod;
+    const un_tok = sema.code.instructions.items(.data)[inst].un_tok;
+    const src = un_tok.src();
+    const ty_operand = sema.resolveType(block, src, un_tok.operand) catch |err| switch (err) {
+        error.GenericPoison => {
+            // We don't actually have a type, so this will be treated as an untyped address-of operator.
+            return;
+        },
+        else => |e| return e,
+    };
+    if (ty_operand.optEuBaseType(mod).zigTypeTag(mod) != .Pointer) {
+        return sema.failWithOwnedErrorMsg(block, msg: {
+            const msg = try sema.errMsg(block, src, "expected type '{}', found pointer", .{ty_operand.fmt(mod)});
+            errdefer msg.destroy(sema.gpa);
+            try sema.errNote(block, src, msg, "address-of operator always returns a pointer", .{});
+            break :msg msg;
+        });
+    }
+}
+fn zirValidateArrayInitRefTy(
     sema: *Sema,
     block: *Block,
     inst: Zir.Inst.Index,
 ) CompileError!Air.Inst.Ref {
     const mod = sema.mod;
-    const inst_data = sema.code.instructions.items(.data)[inst].un_node;
+    const pl_node = sema.code.instructions.items(.data)[inst].pl_node;
-    var ty = sema.resolveType(block, .unneeded, inst_data.operand) catch |err| switch (err) {
+    const src = pl_node.src();
-        // Since this is a ZIR instruction that returns a type, encountering
+    const extra = sema.code.extraData(Zir.Inst.ArrayInitRefTy, pl_node.payload_index).data;
-        // generic poison should not result in a failed compilation, but the
+    const maybe_wrapped_ptr_ty = sema.resolveType(block, .unneeded, extra.ptr_ty) catch |err| switch (err) {
-        // generic poison type. This prevents unnecessary failures when
-        // constructing types at compile-time.
         error.GenericPoison => return .generic_poison_type,
         else => |e| return e,
     };
-    while (true) {
+    const ptr_ty = maybe_wrapped_ptr_ty.optEuBaseType(mod);
-        switch (ty.zigTypeTag(mod)) {
+    assert(ptr_ty.zigTypeTag(mod) == .Pointer); // validated by a previous instruction
-            .Optional => ty = ty.optionalChild(mod),
+    if (ptr_ty.isSlice(mod)) {
-            .ErrorUnion => ty = ty.errorUnionPayload(mod),
+        // Use array of correct length
-            else => return Air.internedToRef(ty.toIntern()),
+        const arr_ty = try mod.arrayType(.{
-        }
+            .len = extra.elem_count,
+            .child = ptr_ty.childType(mod).toIntern(),
+            .sentinel = if (ptr_ty.sentinel(mod)) |s| s.toIntern() else .none,
+        });
+        return Air.internedToRef(arr_ty.toIntern());
     }
+    // Otherwise, we just want the pointer child type
+    const ret_ty = ptr_ty.childType(mod);
+    if (ret_ty.toIntern() == .anyopaque_type) {
+        // The actual array type is unknown, which we represent with a generic poison.
+        return .generic_poison_type;
+    }
+    const arr_ty = ret_ty.optEuBaseType(mod);
+    try sema.validateArrayInitTy(block, src, src, extra.elem_count, arr_ty);
+    return Air.internedToRef(ret_ty.toIntern());
 }
 fn zirValidateArrayInitTy(
     sema: *Sema,
     block: *Block,
     inst: Zir.Inst.Index,
+    is_result_ty: bool,
 ) CompileError!void {
     const mod = sema.mod;
     const inst_data = sema.code.instructions.items(.data)[inst].pl_node;
 @@ -4565,22 +4439,34 @@ fn zirValidateArrayInitTy(
         error.GenericPoison => return,
         else => |e| return e,
     };
+    const arr_ty = if (is_result_ty) ty.optEuBaseType(mod) else ty;
+    return sema.validateArrayInitTy(block, src, ty_src, extra.init_count, arr_ty);
+}
+fn validateArrayInitTy(
+    sema: *Sema,
+    block: *Block,
+    src: LazySrcLoc,
+    ty_src: LazySrcLoc,
+    init_count: u32,
+    ty: Type,
+) CompileError!void {
+    const mod = sema.mod;
     switch (ty.zigTypeTag(mod)) {
         .Array => {
             const array_len = ty.arrayLen(mod);
-            if (extra.init_count != array_len) {
+            if (init_count != array_len) {
                 return sema.fail(block, src, "expected {d} array elements; found {d}", .{
-                    array_len, extra.init_count,
+                    array_len, init_count,
                 });
             }
             return;
         },
         .Vector => {
             const array_len = ty.arrayLen(mod);
-            if (extra.init_count != array_len) {
+            if (init_count != array_len) {
                 return sema.fail(block, src, "expected {d} vector elements; found {d}", .{
-                    array_len, extra.init_count,
+                    array_len, init_count,
                 });
             }
             return;
 @@ -4588,9 +4474,9 @@ fn zirValidateArrayInitTy(
         .Struct => if (ty.isTuple(mod)) {
             try sema.resolveTypeFields(ty);
             const array_len = ty.arrayLen(mod);
-            if (extra.init_count > array_len) {
+            if (init_count > array_len) {
                 return sema.fail(block, src, "expected at most {d} tuple fields; found {d}", .{
-                    array_len, extra.init_count,
+                    array_len, init_count,
                 });
             }
             return;
 @@ -4604,6 +4490,7 @@ fn zirValidateStructInitTy(
     sema: *Sema,
     block: *Block,
     inst: Zir.Inst.Index,
+    is_result_ty: bool,
 ) CompileError!void {
     const mod = sema.mod;
     const inst_data = sema.code.instructions.items(.data)[inst].un_node;
 @@ -4613,15 +4500,16 @@ fn zirValidateStructInitTy(
         error.GenericPoison => return,
         else => |e| return e,
     };
+    const struct_ty = if (is_result_ty) ty.optEuBaseType(mod) else ty;
-    switch (ty.zigTypeTag(mod)) {
+    switch (struct_ty.zigTypeTag(mod)) {
         .Struct, .Union => return,
         else => {},
     }
-    return sema.failWithStructInitNotSupported(block, src, ty);
+    return sema.failWithStructInitNotSupported(block, src, struct_ty);
 }
-fn zirValidateStructInit(
+fn zirValidatePtrStructInit(
     sema: *Sema,
     block: *Block,
     inst: Zir.Inst.Index,
 @@ -4637,7 +4525,7 @@ fn zirValidateStructInit(
     const field_ptr_data = sema.code.instructions.items(.data)[instrs[0]].pl_node;
     const field_ptr_extra = sema.code.extraData(Zir.Inst.Field, field_ptr_data.payload_index).data;
     const object_ptr = try sema.resolveInst(field_ptr_extra.lhs);
-    const agg_ty = sema.typeOf(object_ptr).childType(mod);
+    const agg_ty = sema.typeOf(object_ptr).childType(mod).optEuBaseType(mod);
     switch (agg_ty.zigTypeTag(mod)) {
         .Struct => return sema.validateStructInit(
             block,
 @@ -4723,10 +4611,6 @@ fn validateUnionInit(
     // based only on the store instructions.
     // `first_block_index` needs to point to the `field_ptr` if it exists;
     // the `store` otherwise.
-    //
-    // It's also possible for there to be no store instruction, in the case
-    // of nested `coerce_result_ptr` instructions. If we see the `field_ptr`
-    // but we have not found a `store`, treat as a runtime-known field.
     var first_block_index = block.instructions.items.len;
     var block_index = block.instructions.items.len - 1;
     var init_val: ?Value = null;
 @@ -4963,10 +4847,6 @@ fn validateStructInit(
             // based only on the store instructions.
             // `first_block_index` needs to point to the `field_ptr` if it exists;
             // the `store` otherwise.
-            //
-            // It's also possible for there to be no store instruction, in the case
-            // of nested `coerce_result_ptr` instructions. If we see the `field_ptr`
-            // but we have not found a `store`, treat as a runtime-known field.
             // Possible performance enhancement: save the `block_index` between iterations
             // of the for loop.
 @@ -5115,7 +4995,7 @@ fn validateStructInit(
     }
 }
-fn zirValidateArrayInit(
+fn zirValidatePtrArrayInit(
     sema: *Sema,
     block: *Block,
     inst: Zir.Inst.Index,
 @@ -5128,7 +5008,7 @@ fn zirValidateArrayInit(
     const first_elem_ptr_data = sema.code.instructions.items(.data)[instrs[0]].pl_node;
     const elem_ptr_extra = sema.code.extraData(Zir.Inst.ElemPtrImm, first_elem_ptr_data.payload_index).data;
     const array_ptr = try sema.resolveInst(elem_ptr_extra.ptr);
-    const array_ty = sema.typeOf(array_ptr).childType(mod);
+    const array_ty = sema.typeOf(array_ptr).childType(mod).optEuBaseType(mod);
     const array_len = array_ty.arrayLen(mod);
     if (instrs.len != array_len) switch (array_ty.zigTypeTag(mod)) {
 @@ -5227,10 +5107,6 @@ fn zirValidateArrayInit(
         // `first_block_index` needs to point to the `elem_ptr` if it exists;
         // the `store` otherwise.
         //
-        // It's also possible for there to be no store instruction, in the case
-        // of nested `coerce_result_ptr` instructions. If we see the `elem_ptr`
-        // but we have not found a `store`, treat as a runtime-known element.
-        //
         // This is nearly identical to similar logic in `validateStructInit`.
         // Possible performance enhancement: save the `block_index` between iterations
 @@ -5540,10 +5416,7 @@ fn storeToInferredAlloc(
     try sema.checkComptimeKnownStore(block, dummy_store);
     // Add the stored instruction to the set we will use to resolve peer types
     // for the inferred allocation.
-    try inferred_alloc.prongs.append(sema.arena, .{
+    try inferred_alloc.prongs.append(sema.arena, Air.refToIndex(dummy_store).?);
-        .stored_inst = operand,
-        .placeholder = Air.refToIndex(dummy_store).?,
-    });
 }
 fn storeToInferredAllocComptime(
 @@ -8314,10 +8187,10 @@ fn zirOptionalType(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileErro
     return Air.internedToRef(opt_type.toIntern());
 }
-fn zirElemTypeIndex(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
+fn zirArrayInitElemType(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
     const mod = sema.mod;
     const bin = sema.code.instructions.items(.data)[inst].bin;
-    const indexable_ty = sema.resolveType(block, .unneeded, bin.lhs) catch |err| switch (err) {
+    const maybe_wrapped_indexable_ty = sema.resolveType(block, .unneeded, bin.lhs) catch |err| switch (err) {
         // Since this is a ZIR instruction that returns a type, encountering
         // generic poison should not result in a failed compilation, but the
         // generic poison type. This prevents unnecessary failures when
 @@ -8325,6 +8198,7 @@ fn zirElemTypeIndex(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileErr
         error.GenericPoison => return .generic_poison_type,
         else => |e| return e,
     };
+    const indexable_ty = maybe_wrapped_indexable_ty.optEuBaseType(mod);
     try sema.resolveTypeFields(indexable_ty);
     assert(indexable_ty.isIndexable(mod)); // validated by a previous instruction
     if (indexable_ty.zigTypeTag(mod) == .Struct) {
 @@ -8339,8 +8213,18 @@ fn zirElemTypeIndex(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileErr
 fn zirElemType(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
     const mod = sema.mod;
     const un_node = sema.code.instructions.items(.data)[inst].un_node;
-    const ptr_ty = try sema.resolveType(block, .unneeded, un_node.operand);
+    const maybe_wrapped_ptr_ty = sema.resolveType(block, .unneeded, un_node.operand) catch |err| switch (err) {
+        error.GenericPoison => return .generic_poison_type,
+        else => |e| return e,
+    };
+    const ptr_ty = maybe_wrapped_ptr_ty.optEuBaseType(mod);
     assert(ptr_ty.zigTypeTag(mod) == .Pointer); // validated by a previous instruction
+    const elem_ty = ptr_ty.childType(mod);
+    if (elem_ty.toIntern() == .anyopaque_type) {
+        // The pointer's actual child type is effectively unknown, so it makes
+        // sense to represent it with a generic poison.
+        return .generic_poison_type;
+    }
     return Air.internedToRef(ptr_ty.childType(mod).toIntern());
 }
 @@ -10083,7 +9967,21 @@ fn zirFieldVal(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
     return sema.fieldVal(block, src, object, field_name, field_name_src);
 }
-fn zirFieldPtr(sema: *Sema, block: *Block, inst: Zir.Inst.Index, initializing: bool) CompileError!Air.Inst.Ref {
+fn zirFieldPtr(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
+    const tracy = trace(@src());
+    defer tracy.end();
+    const mod = sema.mod;
+    const inst_data = sema.code.instructions.items(.data)[inst].pl_node;
+    const src = inst_data.src();
+    const field_name_src: LazySrcLoc = .{ .node_offset_field_name = inst_data.src_node };
+    const extra = sema.code.extraData(Zir.Inst.Field, inst_data.payload_index).data;
+    const field_name = try mod.intern_pool.getOrPutString(sema.gpa, sema.code.nullTerminatedString(extra.field_name_start));
+    const object_ptr = try sema.resolveInst(extra.lhs);
+    return sema.fieldPtr(block, src, object_ptr, field_name, field_name_src, false);
+}
+fn zirStructInitFieldPtr(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
     const tracy = trace(@src());
     defer tracy.end();
 @@ -10094,7 +9992,15 @@ fn zirFieldPtr(sema: *Sema, block: *Block, inst: Zir.Inst.Index, initializing: b
     const extra = sema.code.extraData(Zir.Inst.Field, inst_data.payload_index).data;
     const field_name = try mod.intern_pool.getOrPutString(sema.gpa, sema.code.nullTerminatedString(extra.field_name_start));
     const object_ptr = try sema.resolveInst(extra.lhs);
-    return sema.fieldPtr(block, src, object_ptr, field_name, field_name_src, initializing);
+    const struct_ty = sema.typeOf(object_ptr).childType(mod);
+    switch (struct_ty.zigTypeTag(mod)) {
+        .Struct, .Union => {
+            return sema.fieldPtr(block, src, object_ptr, field_name, field_name_src, true);
+        },
+        else => {
+            return sema.failWithStructInitNotSupported(block, src, struct_ty);
+        },
+    }
 }
 fn zirFieldValNamed(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
 @@ -10587,15 +10493,23 @@ fn zirElemPtrNode(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError
     return sema.elemPtr(block, src, array_ptr, elem_index, elem_index_src, false, true);
 }
-fn zirElemPtrImm(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
+fn zirArrayInitElemPtr(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
     const tracy = trace(@src());
     defer tracy.end();
+    const mod = sema.mod;
     const inst_data = sema.code.instructions.items(.data)[inst].pl_node;
     const src = inst_data.src();
     const extra = sema.code.extraData(Zir.Inst.ElemPtrImm, inst_data.payload_index).data;
     const array_ptr = try sema.resolveInst(extra.ptr);
     const elem_index = try sema.mod.intRef(Type.usize, extra.index);
+    const array_ty = sema.typeOf(array_ptr).childType(mod);
+    switch (array_ty.zigTypeTag(mod)) {
+        .Array, .Vector => {},
+        else => if (!array_ty.isTuple(mod)) {
+            return sema.failWithArrayInitNotSupported(block, src, array_ty);
+        },
+    }
     return sema.elemPtr(block, src, array_ptr, elem_index, src, true, true);
 }
 @@ -19213,6 +19127,52 @@ fn zirStructInitEmpty(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileE
     }
 }
+fn zirStructInitEmptyResult(sema: *Sema, block: *Block, inst: Zir.Inst.Index, is_byref: bool) CompileError!Air.Inst.Ref {
+    const tracy = trace(@src());
+    defer tracy.end();
+    const mod = sema.mod;
+    const inst_data = sema.code.instructions.items(.data)[inst].un_node;
+    const src = inst_data.src();
+    const ty_operand = sema.resolveType(block, src, inst_data.operand) catch |err| switch (err) {
+        // Generic poison means this is an untyped anonymous empty struct init
+        error.GenericPoison => return .empty_struct,
+        else => |e| return e,
+    };
+    const init_ty = if (is_byref) ty: {
+        const ptr_ty = ty_operand.optEuBaseType(mod);
+        assert(ptr_ty.zigTypeTag(mod) == .Pointer); // validated by a previous instruction
+        if (!ptr_ty.isSlice(mod)) {
+            break :ty ptr_ty.childType(mod);
+        }
+        // To make `&.{}` a `[:s]T`, the init should be a `[0:s]T`.
+        break :ty try mod.arrayType(.{
+            .len = 0,
+            .sentinel = if (ptr_ty.sentinel(mod)) |s| s.toIntern() else .none,
+            .child = ptr_ty.childType(mod).toIntern(),
+        });
+    } else ty_operand;
+    const obj_ty = init_ty.optEuBaseType(mod);
+    const empty_ref = switch (obj_ty.zigTypeTag(mod)) {
+        .Struct => try sema.structInitEmpty(block, obj_ty, src, src),
+        .Array, .Vector => try sema.arrayInitEmpty(block, src, obj_ty),
+        .Union => return sema.fail(block, src, "union initializer must initialize one field", .{}),
+        else => return sema.failWithArrayInitNotSupported(block, src, obj_ty),
+    };
+    const init_ref = try sema.coerce(block, init_ty, empty_ref, src);
+    if (is_byref) {
+        const init_val = (try sema.resolveMaybeUndefVal(init_ref)).?;
+        var anon_decl = try block.startAnonDecl();
+        defer anon_decl.deinit();
+        const decl = try anon_decl.finish(init_ty, init_val, .none);
+        return sema.analyzeDeclRef(decl);
+    } else {
+        return init_ref;
+    }
+}
 fn structInitEmpty(
     sema: *Sema,
     block: *Block,
 @@ -19230,7 +19190,7 @@ fn structInitEmpty(
     defer gpa.free(field_inits);
     @memset(field_inits, .none);
-    return sema.finishStructInit(block, init_src, dest_src, field_inits, struct_ty, false);
+    return sema.finishStructInit(block, init_src, dest_src, field_inits, struct_ty, struct_ty, false);
 }
 fn arrayInitEmpty(sema: *Sema, block: *Block, src: LazySrcLoc, obj_ty: Type) CompileError!Air.Inst.Ref {
 @@ -19321,13 +19281,14 @@ fn zirStructInit(
     const first_item = sema.code.extraData(Zir.Inst.StructInit.Item, extra.end).data;
     const first_field_type_data = zir_datas[first_item.field_type].pl_node;
     const first_field_type_extra = sema.code.extraData(Zir.Inst.FieldType, first_field_type_data.payload_index).data;
-    const resolved_ty = sema.resolveType(block, src, first_field_type_extra.container_type) catch |err| switch (err) {
+    const result_ty = sema.resolveType(block, src, first_field_type_extra.container_type) catch |err| switch (err) {
         error.GenericPoison => {
             // The type wasn't actually known, so treat this as an anon struct init.
             return sema.structInitAnon(block, src, .typed_init, extra.data, extra.end, is_ref);
         },
         else => |e| return e,
     };
+    const resolved_ty = result_ty.optEuBaseType(mod);
     try sema.resolveTypeLayout(resolved_ty);
     if (resolved_ty.zigTypeTag(mod) == .Struct) {
 @@ -19372,7 +19333,9 @@ fn zirStructInit(
                 return sema.failWithOwnedErrorMsg(block, msg);
             }
             found_fields[field_index] = item.data.field_type;
-            field_inits[field_index] = try sema.resolveInst(item.data.init);
+            const uncoerced_init = try sema.resolveInst(item.data.init);
+            const field_ty = resolved_ty.structFieldType(field_index, mod);
+            field_inits[field_index] = try sema.coerce(block, field_ty, uncoerced_init, field_src);
             if (!is_packed) if (try resolved_ty.structFieldValueComptime(mod, field_index)) |default_value| {
                 const init_val = (try sema.resolveMaybeUndefVal(field_inits[field_index])) orelse {
                     return sema.failWithNeededComptime(block, field_src, .{
 @@ -19386,7 +19349,7 @@ fn zirStructInit(
             };
         }
-        return sema.finishStructInit(block, src, src, field_inits, resolved_ty, is_ref);
+        return sema.finishStructInit(block, src, src, field_inits, resolved_ty, result_ty, is_ref);
     } else if (resolved_ty.zigTypeTag(mod) == .Union) {
         if (extra.data.fields_len != 1) {
             return sema.fail(block, src, "union initialization expects exactly one field", .{});
 @@ -19401,36 +19364,60 @@ fn zirStructInit(
         const field_index = try sema.unionFieldIndex(block, resolved_ty, field_name, field_src);
         const tag_ty = resolved_ty.unionTagTypeHypothetical(mod);
         const tag_val = try mod.enumValueFieldIndex(tag_ty, field_index);
+        const field_ty = mod.typeToUnion(resolved_ty).?.field_types.get(ip)[field_index].toType();
+        if (field_ty.zigTypeTag(mod) == .NoReturn) {
+            return sema.failWithOwnedErrorMsg(block, msg: {
+                const msg = try sema.errMsg(block, src, "cannot initialize 'noreturn' field of union", .{});
+                errdefer msg.destroy(sema.gpa);
+                try sema.addFieldErrNote(resolved_ty, field_index, msg, "field '{}' declared here", .{
+                    field_name.fmt(ip),
+                });
+                try sema.addDeclaredHereNote(msg, resolved_ty);
+                break :msg msg;
+            });
+        }
+        const uncoerced_init_inst = try sema.resolveInst(item.data.init);
+        const init_inst = try sema.coerce(block, field_ty, uncoerced_init_inst, field_src);
-        const init_inst = try sema.resolveInst(item.data.init);
         if (try sema.resolveMaybeUndefVal(init_inst)) |val| {
-            const field_ty = mod.typeToUnion(resolved_ty).?.field_types.get(ip)[field_index].toType();
+            const struct_val = (try mod.intern(.{ .un = .{
-            return sema.addConstantMaybeRef(block, resolved_ty, (try mod.intern(.{ .un = .{
                 .ty = resolved_ty.toIntern(),
                 .tag = try tag_val.intern(tag_ty, mod),
                 .val = try val.intern(field_ty, mod),
-            } })).toValue(), is_ref);
+            } })).toValue();
+            const final_val_inst = try sema.coerce(block, result_ty, Air.internedToRef(struct_val.toIntern()), src);
+            const final_val = (try sema.resolveMaybeUndefVal(final_val_inst)).?;
+            return sema.addConstantMaybeRef(block, resolved_ty, final_val, is_ref);
+        }
+        if (try sema.typeRequiresComptime(resolved_ty)) {
+            return sema.failWithNeededComptime(block, field_src, .{
+                .needed_comptime_reason = "initializer of comptime only union must be comptime-known",
+            });
         }
         if (is_ref) {
             const target = mod.getTarget();
             const alloc_ty = try sema.ptrType(.{
-                .child = resolved_ty.toIntern(),
+                .child = result_ty.toIntern(),
                 .flags = .{ .address_space = target_util.defaultAddressSpace(target, .local) },
             });
             const alloc = try block.addTy(.alloc, alloc_ty);
-            const field_ptr = try sema.unionFieldPtr(block, field_src, alloc, field_name, field_src, resolved_ty, true);
+            const base_ptr = try sema.optEuBasePtrInit(block, alloc, src);
+            const field_ptr = try sema.unionFieldPtr(block, field_src, base_ptr, field_name, field_src, resolved_ty, true);
             try sema.storePtr(block, src, field_ptr, init_inst);
             const new_tag = Air.internedToRef(tag_val.toIntern());
-            _ = try block.addBinOp(.set_union_tag, alloc, new_tag);
+            _ = try block.addBinOp(.set_union_tag, base_ptr, new_tag);
             return sema.makePtrConst(block, alloc);
         }
         try sema.requireRuntimeBlock(block, src, null);
         try sema.queueFullTypeResolution(resolved_ty);
-        return block.addUnionInit(resolved_ty, field_index, init_inst);
+        const union_val = try block.addUnionInit(resolved_ty, field_index, init_inst);
-    } else if (resolved_ty.isAnonStruct(mod)) {
+        return sema.coerce(block, result_ty, union_val, src);
-        return sema.fail(block, src, "TODO anon struct init validation", .{});
     }
     unreachable;
 }
 @@ -19442,6 +19429,7 @@ fn finishStructInit(
     dest_src: LazySrcLoc,
     field_inits: []Air.Inst.Ref,
     struct_ty: Type,
+    result_ty: Type,
     is_ref: bool,
 ) CompileError!Air.Inst.Ref {
     const mod = sema.mod;
 @@ -19452,8 +19440,24 @@ fn finishStructInit(
     switch (ip.indexToKey(struct_ty.toIntern())) {
         .anon_struct_type => |anon_struct| {
-            for (anon_struct.values.get(ip), 0..) |default_val, i| {
+            // We can't get the slices, as the coercion may invalidate them.
-                if (field_inits[i] != .none) continue;
+            for (0..anon_struct.types.len) |i| {
+                if (field_inits[i] != .none) {
+                    // Coerce the init value to the field type.
+                    const field_ty = anon_struct.types.get(ip)[i].toType();
+                    field_inits[i] = sema.coerce(block, field_ty, field_inits[i], .unneeded) catch |err| switch (err) {
+                        error.NeededSourceLocation => {
+                            const decl = mod.declPtr(block.src_decl);
+                            const field_src = mod.initSrc(init_src.node_offset.x, decl, i);
+                            _ = try sema.coerce(block, field_ty, field_inits[i], field_src);
+                            unreachable;
+                        },
+                        else => |e| return e,
+                    };
+                    continue;
+                }
+                const default_val = anon_struct.values.get(ip)[i];
                 if (default_val == .none) {
                     if (anon_struct.names.len == 0) {
 @@ -19480,7 +19484,20 @@ fn finishStructInit(
         },
         .struct_type => |struct_type| {
             for (0..struct_type.field_types.len) |i| {
-                if (field_inits[i] != .none) continue;
+                if (field_inits[i] != .none) {
+                    // Coerce the init value to the field type.
+                    const field_ty = struct_type.field_types.get(ip)[i].toType();
+                    field_inits[i] = sema.coerce(block, field_ty, field_inits[i], init_src) catch |err| switch (err) {
+                        error.NeededSourceLocation => {
+                            const decl = mod.declPtr(block.src_decl);
+                            const field_src = mod.initSrc(init_src.node_offset.x, decl, i);
+                            _ = try sema.coerce(block, field_ty, field_inits[i], field_src);
+                            unreachable;
+                        },
+                        else => |e| return e,
+                    };
+                    continue;
+                }
                 const field_init = struct_type.fieldInit(ip, i);
                 if (field_init == .none) {
 @@ -19524,29 +19541,39 @@ fn finishStructInit(
     const runtime_index = opt_runtime_index orelse {
         const elems = try sema.arena.alloc(InternPool.Index, field_inits.len);
-        for (elems, field_inits, 0..) |*elem, field_init, field_i| {
+        for (elems, field_inits) |*elem, field_init| {
-            elem.* = try (sema.resolveMaybeUndefVal(field_init) catch unreachable).?
+            elem.* = (sema.resolveMaybeUndefVal(field_init) catch unreachable).?.toIntern();
-                .intern(struct_ty.structFieldType(field_i, mod), mod);
         }
         const struct_val = try mod.intern(.{ .aggregate = .{
             .ty = struct_ty.toIntern(),
             .storage = .{ .elems = elems },
         } });
-        return sema.addConstantMaybeRef(block, struct_ty, struct_val.toValue(), is_ref);
+        const final_val_inst = try sema.coerce(block, result_ty, Air.internedToRef(struct_val), init_src);
+        const final_val = (try sema.resolveMaybeUndefVal(final_val_inst)).?;
+        return sema.addConstantMaybeRef(block, result_ty, final_val, is_ref);
     };
+    if (try sema.typeRequiresComptime(struct_ty)) {
+        const decl = mod.declPtr(block.src_decl);
+        const field_src = mod.initSrc(init_src.node_offset.x, decl, runtime_index);
+        return sema.failWithNeededComptime(block, field_src, .{
+            .needed_comptime_reason = "initializer of comptime only struct must be comptime-known",
+        });
+    }
     if (is_ref) {
         try sema.resolveStructLayout(struct_ty);
         const target = sema.mod.getTarget();
         const alloc_ty = try sema.ptrType(.{
-            .child = struct_ty.toIntern(),
+            .child = result_ty.toIntern(),
             .flags = .{ .address_space = target_util.defaultAddressSpace(target, .local) },
         });
         const alloc = try block.addTy(.alloc, alloc_ty);
+        const base_ptr = try sema.optEuBasePtrInit(block, alloc, init_src);
         for (field_inits, 0..) |field_init, i_usize| {
             const i: u32 = @intCast(i_usize);
             const field_src = dest_src;
-            const field_ptr = try sema.structFieldPtrByIndex(block, dest_src, alloc, i, field_src, struct_ty, true);
+            const field_ptr = try sema.structFieldPtrByIndex(block, dest_src, base_ptr, i, field_src, struct_ty, true);
             try sema.storePtr(block, dest_src, field_ptr, field_init);
         }
 @@ -19563,19 +19590,19 @@ fn finishStructInit(
         else => |e| return e,
     };
     try sema.queueFullTypeResolution(struct_ty);
-    return block.addAggregateInit(struct_ty, field_inits);
+    const struct_val = try block.addAggregateInit(struct_ty, field_inits);
+    return sema.coerce(block, result_ty, struct_val, init_src);
 }
 fn zirStructInitAnon(
     sema: *Sema,
     block: *Block,
     inst: Zir.Inst.Index,
-    is_ref: bool,
 ) CompileError!Air.Inst.Ref {
     const inst_data = sema.code.instructions.items(.data)[inst].pl_node;
     const src = inst_data.src();
     const extra = sema.code.extraData(Zir.Inst.StructInitAnon, inst_data.payload_index);
-    return sema.structInitAnon(block, src, .anon_init, extra.data, extra.end, is_ref);
+    return sema.structInitAnon(block, src, .anon_init, extra.data, extra.end, false);
 }
 fn structInitAnon(
 @@ -19748,13 +19775,14 @@ fn zirArrayInit(
     const args = sema.code.refSlice(extra.end, extra.data.operands_len);
     assert(args.len >= 2); // array_ty + at least one element
-    const array_ty = sema.resolveType(block, src, args[0]) catch |err| switch (err) {
+    const result_ty = sema.resolveType(block, src, args[0]) catch |err| switch (err) {
         error.GenericPoison => {
             // The type wasn't actually known, so treat this as an anon array init.
             return sema.arrayInitAnon(block, src, args[1..], is_ref);
         },
         else => |e| return e,
     };
+    const array_ty = result_ty.optEuBaseType(mod);
     const is_tuple = array_ty.zigTypeTag(mod) == .Struct;
     const sentinel_val = array_ty.sentinel(mod);
 @@ -19810,10 +19838,12 @@ fn zirArrayInit(
             // We checked that all args are comptime above.
             val.* = try ((sema.resolveMaybeUndefVal(arg) catch unreachable).?).intern(elem_ty, mod);
         }
-        return sema.addConstantMaybeRef(block, array_ty, (try mod.intern(.{ .aggregate = .{
+        const arr_val = try mod.intern(.{ .aggregate = .{
             .ty = array_ty.toIntern(),
             .storage = .{ .elems = elem_vals },
-        } })).toValue(), is_ref);
+        } });
+        const result_ref = try sema.coerce(block, result_ty, Air.internedToRef(arr_val), src);
+        return sema.addConstantMaybeRef(block, result_ty, (try sema.resolveMaybeUndefVal(result_ref)).?, is_ref);
     };
     sema.requireRuntimeBlock(block, .unneeded, null) catch |err| switch (err) {
 @@ -19830,10 +19860,11 @@ fn zirArrayInit(
     if (is_ref) {
         const target = mod.getTarget();
         const alloc_ty = try sema.ptrType(.{
-            .child = array_ty.toIntern(),
+            .child = result_ty.toIntern(),
             .flags = .{ .address_space = target_util.defaultAddressSpace(target, .local) },
         });
         const alloc = try block.addTy(.alloc, alloc_ty);
+        const base_ptr = try sema.optEuBasePtrInit(block, alloc, src);
         if (array_ty.isTuple(mod)) {
             for (resolved_args, 0..) |arg, i| {
 @@ -19844,7 +19875,7 @@ fn zirArrayInit(
                 const elem_ptr_ty_ref = Air.internedToRef(elem_ptr_ty.toIntern());
                 const index = try mod.intRef(Type.usize, i);
-                const elem_ptr = try block.addPtrElemPtrTypeRef(alloc, index, elem_ptr_ty_ref);
+                const elem_ptr = try block.addPtrElemPtrTypeRef(base_ptr, index, elem_ptr_ty_ref);
                 _ = try block.addBinOp(.store, elem_ptr, arg);
             }
             return sema.makePtrConst(block, alloc);
 @@ -19858,26 +19889,26 @@ fn zirArrayInit(
         for (resolved_args, 0..) |arg, i| {
             const index = try mod.intRef(Type.usize, i);
-            const elem_ptr = try block.addPtrElemPtrTypeRef(alloc, index, elem_ptr_ty_ref);
+            const elem_ptr = try block.addPtrElemPtrTypeRef(base_ptr, index, elem_ptr_ty_ref);
             _ = try block.addBinOp(.store, elem_ptr, arg);
         }
         return sema.makePtrConst(block, alloc);
     }
-    return block.addAggregateInit(array_ty, resolved_args);
+    const arr_ref = try block.addAggregateInit(array_ty, resolved_args);
+    return sema.coerce(block, result_ty, arr_ref, src);
 }
 fn zirArrayInitAnon(
     sema: *Sema,
     block: *Block,
     inst: Zir.Inst.Index,
-    is_ref: bool,
 ) CompileError!Air.Inst.Ref {
     const inst_data = sema.code.instructions.items(.data)[inst].pl_node;
     const src = inst_data.src();
     const extra = sema.code.extraData(Zir.Inst.MultiOp, inst_data.payload_index);
     const operands = sema.code.refSlice(extra.end, extra.data.operands_len);
-    return sema.arrayInitAnon(block, src, operands, is_ref);
+    return sema.arrayInitAnon(block, src, operands, false);
 }
 fn arrayInitAnon(
 @@ -19997,14 +20028,14 @@ fn zirFieldTypeRef(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileErro
     return sema.fieldType(block, aggregate_ty, field_name, field_src, ty_src);
 }
-fn zirFieldType(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
+fn zirStructInitFieldType(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
     const mod = sema.mod;
     const ip = &mod.intern_pool;
     const inst_data = sema.code.instructions.items(.data)[inst].pl_node;
     const extra = sema.code.extraData(Zir.Inst.FieldType, inst_data.payload_index).data;
     const ty_src = inst_data.src();
     const field_name_src: LazySrcLoc = .{ .node_offset_field_name = inst_data.src_node };
-    const aggregate_ty = sema.resolveType(block, ty_src, extra.container_type) catch |err| switch (err) {
+    const wrapped_aggregate_ty = sema.resolveType(block, ty_src, extra.container_type) catch |err| switch (err) {
         // Since this is a ZIR instruction that returns a type, encountering
         // generic poison should not result in a failed compilation, but the
         // generic poison type. This prevents unnecessary failures when
 @@ -20012,6 +20043,7 @@ fn zirFieldType(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!A
         error.GenericPoison => return .generic_poison_type,
         else => |e| return e,
     };
+    const aggregate_ty = wrapped_aggregate_ty.optEuBaseType(mod);
     const zir_field_name = sema.code.nullTerminatedString(extra.name_start);
     const field_name = try ip.getOrPutString(sema.gpa, zir_field_name);
     return sema.fieldType(block, aggregate_ty, field_name, field_name_src, ty_src);
 @@ -20033,7 +20065,10 @@ fn fieldType(
         switch (cur_ty.zigTypeTag(mod)) {
             .Struct => switch (ip.indexToKey(cur_ty.toIntern())) {
                 .anon_struct_type => |anon_struct| {
-                    const field_index = try sema.anonStructFieldIndex(block, cur_ty, field_name, field_src);
+                    const field_index = if (anon_struct.names.len == 0)
+                        try sema.tupleFieldIndex(block, cur_ty, field_name, field_src)
+                    else
+                        try sema.anonStructFieldIndex(block, cur_ty, field_name, field_src);
                     return Air.internedToRef(anon_struct.types.get(ip)[field_index]);
                 },
                 .struct_type => |struct_type| {
 @@ -21620,7 +21655,8 @@ fn zirPtrFromInt(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!
     const operand_coerced = try sema.coerce(block, operand_ty, operand_res, operand_src);
     const ptr_ty = dest_ty.scalarType(mod);
-    try sema.checkPtrType(block, src, ptr_ty);
+    try sema.checkPtrType(block, src, ptr_ty, true);
     const elem_ty = ptr_ty.elemType2(mod);
     const ptr_align = try ptr_ty.ptrAlignmentAdvanced(mod, sema);
 @@ -21860,7 +21896,7 @@ fn ptrCastFull(
     const mod = sema.mod;
     const operand_ty = sema.typeOf(operand);
-    try sema.checkPtrType(block, src, dest_ty);
+    try sema.checkPtrType(block, src, dest_ty, true);
     try sema.checkPtrOperand(block, operand_src, operand_ty);
     const src_info = operand_ty.ptrInfo(mod);
 @@ -22668,10 +22704,11 @@ fn checkPtrType(
     block: *Block,
     ty_src: LazySrcLoc,
     ty: Type,
+    allow_slice: bool,
 ) CompileError!void {
     const mod = sema.mod;
     switch (ty.zigTypeTag(mod)) {
-        .Pointer => return,
+        .Pointer => if (allow_slice or !ty.isSlice(mod)) return,
         .Fn => {
             const msg = msg: {
                 const msg = try sema.errMsg(
 @@ -29577,13 +29614,6 @@ fn storePtr2(
         return;
     }
-    if (air_tag == .bitcast) {
-        // `air_tag == .bitcast` is used as a special case for `zirCoerceResultPtr`
-        // to avoid calling `requireRuntimeBlock` for the dummy block.
-        _ = try block.addBinOp(.store, ptr, operand);
-        return;
-    }
     try sema.requireRuntimeBlock(block, src, runtime_src);
     try sema.queueFullTypeResolution(elem_ty);
 @@ -29719,6 +29749,7 @@ fn storePtrVal(
     switch (mut_kit.pointee) {
         .direct => |val_ptr| {
             if (mut_kit.mut_decl.runtime_index == .comptime_field_ptr) {
+                val_ptr.* = (try val_ptr.intern(operand_ty, mod)).toValue();
                 if (!operand_val.eql(val_ptr.*, operand_ty, mod)) {
                     // TODO use failWithInvalidComptimeFieldStore
                     return sema.fail(block, src, "value stored in comptime field does not match the default value of the field", .{});

src/Zir.zig+181-144

 @@ -242,10 +242,9 @@ pub const Inst = struct {
         /// Uses the `pl_node` union field with `Bin` payload.
         /// lhs is length, rhs is element type.
         vector_type,
-        /// Given an indexable type, returns the type of the element at given index.
+        /// Given a pointer type, returns its element type. Reaches through any optional or error
-        /// Uses the `bin` union field. lhs is the indexable type, rhs is the index.
+        /// union types wrapping the pointer. Asserts that the underlying type is a pointer type.
-        elem_type_index,
+        /// Returns generic poison if the element type is `anyopaque`.
-        /// Given a pointer type, returns its element type.
         /// Uses the `un_node` field.
         elem_type,
         /// Given an indexable pointer (slice, many-ptr, single-ptr-to-array), returns its
 @@ -353,11 +352,6 @@ pub const Inst = struct {
         /// `!=`
         /// Uses the `pl_node` union field. Payload is `Bin`.
         cmp_neq,
-        /// Coerces a result location pointer to a new element type. It is evaluated "backwards"-
-        /// as type coercion from the new element type to the old element type.
-        /// Uses the `pl_node` union field. Payload is `Bin`.
-        /// LHS is destination element type, RHS is result pointer.
-        coerce_result_ptr,
         /// Conditional branch. Splits control flow based on a boolean condition value.
         /// Uses the `pl_node` union field. AST node is an if, while, for, etc.
         /// Payload is `CondBr`.
 @@ -419,13 +413,6 @@ pub const Inst = struct {
         /// Payload is `Bin`.
         /// No OOB safety check is emitted.
         elem_ptr,
-        /// Same as `elem_ptr_node` except the index is stored immediately rather than
-        /// as a reference to another ZIR instruction.
-        /// Uses the `pl_node` union field. AST node is an element inside array initialization
-        /// syntax. Payload is `ElemPtrImm`.
-        /// This instruction has a way to set the result type to be a
-        /// single-pointer or a many-pointer.
-        elem_ptr_imm,
         /// Given an array, slice, or pointer, returns the element at the provided index.
         /// Uses the `pl_node` union field. AST node is a[b] syntax. Payload is `Bin`.
         elem_val_node,
 @@ -463,8 +450,6 @@ pub const Inst = struct {
         /// to the named field. The field name is stored in string_bytes. Used by a.b syntax.
         /// Uses `pl_node` field. The AST node is the a.b syntax. Payload is Field.
         field_ptr,
-        /// Same as `field_ptr` but used for struct init.
-        field_ptr_init,
         /// Given a struct or object that contains virtual fields, returns the named field.
         /// The field name is stored in string_bytes. Used by a.b syntax.
         /// This instruction also accepts a pointer.
 @@ -688,84 +673,123 @@ pub const Inst = struct {
         /// A switch expression. Uses the `pl_node` union field.
         /// AST node is the switch, payload is `SwitchBlock`. Operand is a pointer.
         switch_block_ref,
-        /// Given a
-        ///   *A returns *A
-        ///   *E!A returns *A
-        ///   *?A returns *A
-        /// Uses the `un_node` field.
-        array_base_ptr,
-        /// Given a
-        ///   *S returns *S
-        ///   *E!S returns *S
-        ///   *?S returns *S
-        /// Uses the `un_node` field.
-        field_base_ptr,
-        /// Given a type, strips all optional and error union types wrapping it.
-        /// e.g. `E!?u32` becomes `u32`, `[]u8` becomes `[]u8`.
-        /// Uses the `un_node` field.
-        opt_eu_base_ty,
-        /// Checks that the type supports array init syntax.
-        /// Returns the underlying indexable type (since the given type may be e.g. an optional).
-        /// Uses the `un_node` field.
-        validate_array_init_ty,
-        /// Checks that the type supports struct init syntax.
-        /// Returns the underlying struct type (since the given type may be e.g. an optional).
-        /// Uses the `un_node` field.
-        validate_struct_init_ty,
-        /// Given a set of `field_ptr` instructions, assumes they are all part of a struct
-        /// initialization expression, and emits compile errors for duplicate fields
-        /// as well as missing fields, if applicable.
-        /// This instruction asserts that there is at least one field_ptr instruction,
-        /// because it must use one of them to find out the struct type.
-        /// Uses the `pl_node` field. Payload is `Block`.
-        validate_struct_init,
-        /// Given a set of `elem_ptr_imm` instructions, assumes they are all part of an
-        /// array initialization expression, and emits a compile error if the number of
-        /// elements does not match the array type.
-        /// This instruction asserts that there is at least one `elem_ptr_imm` instruction,
-        /// because it must use one of them to find out the array type.
-        /// Uses the `pl_node` field. Payload is `Block`.
-        validate_array_init,
         /// Check that operand type supports the dereference operand (.*).
         /// Uses the `un_node` field.
         validate_deref,
         /// Check that the operand's type is an array or tuple with the given number of elements.
         /// Uses the `pl_node` field. Payload is `ValidateDestructure`.
         validate_destructure,
-        /// A struct literal with a specified type, with no fields.
-        /// Uses the `un_node` field.
-        struct_init_empty,
-        /// Given a struct or union, and a field name as a string index,
-        /// returns the field type. Uses the `pl_node` field. Payload is `FieldType`.
-        field_type,
         /// Given a struct or union, and a field name as a Ref,
         /// returns the field type. Uses the `pl_node` field. Payload is `FieldTypeRef`.
         field_type_ref,
+        /// Given a pointer, initializes all error unions and optionals in the pointee to payloads,
+        /// returning the base payload pointer. For instance, converts *E!?T into a valid *T
+        /// (clobbering any existing error or null value).
+        /// Uses the `un_node` field.
+        opt_eu_base_ptr_init,
+        /// Coerce a given value such that when a reference is taken, the resulting pointer will be
+        /// coercible to the given type. For instance, given a value of type 'u32' and the pointer
+        /// type '*u64', coerces the value to a 'u64'. Asserts that the type is a pointer type.
+        /// Uses the `pl_node` field. Payload is `Bin`.
+        /// LHS is the pointer type, RHS is the value.
+        coerce_ptr_elem_ty,
+        /// Given a type, validate that it is a pointer type suitable for return from the address-of
+        /// operator. Emit a compile error if not.
+        /// Uses the `un_tok` union field. Token is the `&` operator. Operand is the type.
+        validate_ref_ty,
+        // The following tags all relate to struct initialization expressions.
+        /// A struct literal with a specified explicit type, with no fields.
+        /// Uses the `un_node` field.
+        struct_init_empty,
+        /// An anonymous struct literal with a known result type, with no fields.
+        /// Uses the `un_node` field.
+        struct_init_empty_result,
+        /// An anonymous struct literal with no fields, returned by reference, with a known result
+        /// type for the pointer. Asserts that the type is a pointer.
+        /// Uses the `un_node` field.
+        struct_init_empty_ref_result,
+        /// Struct initialization without a type. Creates a value of an anonymous struct type.
+        /// Uses the `pl_node` field. Payload is `StructInitAnon`.
+        struct_init_anon,
         /// Finalizes a typed struct or union initialization, performs validation, and returns the
-        /// struct or union value.
+        /// struct or union value. The given type must be validated prior to this instruction, using
+        /// `validate_struct_init_ty` or `validate_struct_init_result_ty`. If the given type is
+        /// generic poison, this is downgraded to an anonymous initialization.
         /// Uses the `pl_node` field. Payload is `StructInit`.
         struct_init,
-        /// Struct initialization syntax, make the result a pointer.
+        /// Struct initialization syntax, make the result a pointer. Equivalent to `struct_init`
+        /// followed by `ref` - this ZIR tag exists as an optimization for a common pattern.
         /// Uses the `pl_node` field. Payload is `StructInit`.
         struct_init_ref,
-        /// Struct initialization without a type.
+        /// Checks that the type supports struct init syntax. Always returns void.
-        /// Uses the `pl_node` field. Payload is `StructInitAnon`.
+        /// Uses the `un_node` field.
-        struct_init_anon,
+        validate_struct_init_ty,
-        /// Anonymous struct initialization syntax, make the result a pointer.
+        /// Like `validate_struct_init_ty`, but additionally accepts types which structs coerce to.
-        /// Uses the `pl_node` field. Payload is `StructInitAnon`.
+        /// Used on the known result type of a struct init expression. Always returns void.
-        struct_init_anon_ref,
+        /// Uses the `un_node` field.
-        /// Array initialization syntax.
+        validate_struct_init_result_ty,
-        /// Uses the `pl_node` field. Payload is `MultiOp`.
+        /// Given a set of `struct_init_field_ptr` instructions, assumes they are all part of a
-        array_init,
+        /// struct initialization expression, and emits compile errors for duplicate fields as well
-        /// Anonymous array initialization syntax.
+        /// as missing fields, if applicable.
+        /// This instruction asserts that there is at least one struct_init_field_ptr instruction,
+        /// because it must use one of them to find out the struct type.
+        /// Uses the `pl_node` field. Payload is `Block`.
+        validate_ptr_struct_init,
+        /// Given a type being used for a struct initialization expression, returns the type of the
+        /// field with the given name.
+        /// Uses the `pl_node` field. Payload is `FieldType`.
+        struct_init_field_type,
+        /// Given a pointer being used as the result pointer of a struct initialization expression,
+        /// return a pointer to the field of the given name.
+        /// Uses the `pl_node` field. The AST node is the field initializer. Payload is Field.
+        struct_init_field_ptr,
+        // The following tags all relate to array initialization expressions.
+        /// Array initialization without a type. Creates a value of a tuple type.
         /// Uses the `pl_node` field. Payload is `MultiOp`.
         array_init_anon,
-        /// Array initialization syntax, make the result a pointer.
+        /// Array initialization syntax with a known type. The given type must be validated prior to
-        /// Uses the `pl_node` field. Payload is `MultiOp`.
+        /// this instruction, using some `validate_array_init_*_ty` instruction.
+        /// Uses the `pl_node` field. Payload is `MultiOp`, where the first operand is the type.
+        array_init,
+        /// Array initialization syntax, make the result a pointer. Equivalent to `array_init`
+        /// followed by `ref`- this ZIR tag exists as an optimization for a common pattern.
+        /// Uses the `pl_node` field. Payload is `MultiOp`, where the first operand is the type.
         array_init_ref,
-        /// Anonymous array initialization syntax, make the result a pointer.
+        /// Checks that the type supports array init syntax. Always returns void.
-        /// Uses the `pl_node` field. Payload is `MultiOp`.
+        /// Uses the `pl_node` field. Payload is `ArrayInit`.
-        array_init_anon_ref,
+        validate_array_init_ty,
+        /// Like `validate_array_init_ty`, but additionally accepts types which arrays coerce to.
+        /// Used on the known result type of an array init expression. Always returns void.
+        /// Uses the `pl_node` field. Payload is `ArrayInit`.
+        validate_array_init_result_ty,
+        /// Given a pointer or slice type and an element count, return the expected type of an array
+        /// initializer such that a pointer to the initializer has the given pointer type, checking
+        /// that this type supports array init syntax and emitting a compile error if not. Preserves
+        /// error union and optional wrappers on the array type, if any.
+        /// Asserts that the given type is a pointer or slice type.
+        /// Uses the `pl_node` field. Payload is `ArrayInitRefTy`.
+        validate_array_init_ref_ty,
+        /// Given a set of `array_init_elem_ptr` instructions, assumes they are all part of an array
+        /// initialization expression, and emits a compile error if the number of elements does not
+        /// match the array type.
+        /// This instruction asserts that there is at least one `array_init_elem_ptr` instruction,
+        /// because it must use one of them to find out the array type.
+        /// Uses the `pl_node` field. Payload is `Block`.
+        validate_ptr_array_init,
+        /// Given a type being used for an array initialization expression, returns the type of the
+        /// element at the given index.
+        /// Uses the `bin` union field. lhs is the indexable type, rhs is the index.
+        array_init_elem_type,
+        /// Given a pointer being used as the result pointer of an array initialization expression,
+        /// return a pointer to the element at the given index.
+        /// Uses the `pl_node` union field. AST node is an element inside array initialization
+        /// syntax. Payload is `ElemPtrImm`.
+        array_init_elem_ptr,
         /// Implements the `@unionInit` builtin.
         /// Uses the `pl_node` field. Payload is `UnionInit`.
         union_init,
 @@ -1038,7 +1062,6 @@ pub const Inst = struct {
                 .array_type,
                 .array_type_sentinel,
                 .vector_type,
-                .elem_type_index,
                 .elem_type,
                 .indexable_ptr_elem_type,
                 .vector_elem_type,
 @@ -1066,7 +1089,6 @@ pub const Inst = struct {
                 .cmp_gte,
                 .cmp_gt,
                 .cmp_neq,
-                .coerce_result_ptr,
                 .error_set_decl,
                 .error_set_decl_anon,
                 .error_set_decl_func,
 @@ -1082,7 +1104,6 @@ pub const Inst = struct {
                 .elem_ptr,
                 .elem_val,
                 .elem_ptr_node,
-                .elem_ptr_imm,
                 .elem_val_node,
                 .elem_val_imm,
                 .ensure_result_used,
 @@ -1091,7 +1112,6 @@ pub const Inst = struct {
                 .@"export",
                 .export_value,
                 .field_ptr,
-                .field_ptr_init,
                 .field_val,
                 .field_ptr_named,
                 .field_val_named,
 @@ -1154,25 +1174,9 @@ pub const Inst = struct {
                 .set_eval_branch_quota,
                 .switch_block,
                 .switch_block_ref,
-                .array_base_ptr,
-                .field_base_ptr,
-                .validate_array_init_ty,
-                .validate_struct_init_ty,
-                .validate_struct_init,
-                .validate_array_init,
                 .validate_deref,
                 .validate_destructure,
-                .struct_init_empty,
-                .struct_init,
-                .struct_init_ref,
-                .struct_init_anon,
-                .struct_init_anon_ref,
-                .array_init,
-                .array_init_anon,
-                .array_init_ref,
-                .array_init_anon_ref,
                 .union_init,
-                .field_type,
                 .field_type_ref,
                 .enum_from_int,
                 .int_from_enum,
 @@ -1254,7 +1258,29 @@ pub const Inst = struct {
                 .save_err_ret_index,
                 .restore_err_ret_index,
                 .for_len,
-                .opt_eu_base_ty,
+                .opt_eu_base_ptr_init,
+                .coerce_ptr_elem_ty,
+                .struct_init_empty,
+                .struct_init_empty_result,
+                .struct_init_empty_ref_result,
+                .struct_init_anon,
+                .struct_init,
+                .struct_init_ref,
+                .validate_struct_init_ty,
+                .validate_struct_init_result_ty,
+                .validate_ptr_struct_init,
+                .struct_init_field_type,
+                .struct_init_field_ptr,
+                .array_init_anon,
+                .array_init,
+                .array_init_ref,
+                .validate_array_init_ty,
+                .validate_array_init_result_ty,
+                .validate_array_init_ref_ty,
+                .validate_ptr_array_init,
+                .array_init_elem_type,
+                .array_init_elem_ptr,
+                .validate_ref_ty,
                 => false,
                 .@"break",
 @@ -1307,10 +1333,6 @@ pub const Inst = struct {
                 .store_node,
                 .store_to_inferred_ptr,
                 .resolve_inferred_alloc,
-                .validate_array_init_ty,
-                .validate_struct_init_ty,
-                .validate_struct_init,
-                .validate_array_init,
                 .validate_deref,
                 .validate_destructure,
                 .@"export",
 @@ -1323,6 +1345,13 @@ pub const Inst = struct {
                 .defer_err_code,
                 .restore_err_ret_index,
                 .save_err_ret_index,
+                .validate_struct_init_ty,
+                .validate_struct_init_result_ty,
+                .validate_ptr_struct_init,
+                .validate_array_init_ty,
+                .validate_array_init_result_ty,
+                .validate_ptr_array_init,
+                .validate_ref_ty,
                 => true,
                 .param,
 @@ -1346,7 +1375,6 @@ pub const Inst = struct {
                 .array_type,
                 .array_type_sentinel,
                 .vector_type,
-                .elem_type_index,
                 .elem_type,
                 .indexable_ptr_elem_type,
                 .vector_elem_type,
 @@ -1374,7 +1402,6 @@ pub const Inst = struct {
                 .cmp_gte,
                 .cmp_gt,
                 .cmp_neq,
-                .coerce_result_ptr,
                 .error_set_decl,
                 .error_set_decl_anon,
                 .error_set_decl_func,
 @@ -1385,11 +1412,9 @@ pub const Inst = struct {
                 .elem_ptr,
                 .elem_val,
                 .elem_ptr_node,
-                .elem_ptr_imm,
                 .elem_val_node,
                 .elem_val_imm,
                 .field_ptr,
-                .field_ptr_init,
                 .field_val,
                 .field_ptr_named,
                 .field_val_named,
 @@ -1447,19 +1472,7 @@ pub const Inst = struct {
                 .typeof_log2_int_type,
                 .switch_block,
                 .switch_block_ref,
-                .array_base_ptr,
-                .field_base_ptr,
-                .struct_init_empty,
-                .struct_init,
-                .struct_init_ref,
-                .struct_init_anon,
-                .struct_init_anon_ref,
-                .array_init,
-                .array_init_anon,
-                .array_init_ref,
-                .array_init_anon_ref,
                 .union_init,
-                .field_type,
                 .field_type_ref,
                 .enum_from_int,
                 .int_from_enum,
 @@ -1546,7 +1559,22 @@ pub const Inst = struct {
                 .for_len,
                 .@"try",
                 .try_ptr,
-                .opt_eu_base_ty,
+                .opt_eu_base_ptr_init,
+                .coerce_ptr_elem_ty,
+                .struct_init_empty,
+                .struct_init_empty_result,
+                .struct_init_empty_ref_result,
+                .struct_init_anon,
+                .struct_init,
+                .struct_init_ref,
+                .struct_init_field_type,
+                .struct_init_field_ptr,
+                .array_init_anon,
+                .array_init,
+                .array_init_ref,
+                .validate_array_init_ref_ty,
+                .array_init_elem_type,
+                .array_init_elem_ptr,
                 => false,
                 .extended => switch (data.extended.opcode) {
 @@ -1580,7 +1608,6 @@ pub const Inst = struct {
                 .array_type = .pl_node,
                 .array_type_sentinel = .pl_node,
                 .vector_type = .pl_node,
-                .elem_type_index = .bin,
                 .elem_type = .un_node,
                 .indexable_ptr_elem_type = .un_node,
                 .vector_elem_type = .un_node,
 @@ -1612,7 +1639,6 @@ pub const Inst = struct {
                 .cmp_gte = .pl_node,
                 .cmp_gt = .pl_node,
                 .cmp_neq = .pl_node,
-                .coerce_result_ptr = .pl_node,
                 .condbr = .pl_node,
                 .condbr_inline = .pl_node,
                 .@"try" = .pl_node,
 @@ -1631,7 +1657,6 @@ pub const Inst = struct {
                 .div = .pl_node,
                 .elem_ptr = .pl_node,
                 .elem_ptr_node = .pl_node,
-                .elem_ptr_imm = .pl_node,
                 .elem_val = .pl_node,
                 .elem_val_node = .pl_node,
                 .elem_val_imm = .elem_val_imm,
 @@ -1643,7 +1668,6 @@ pub const Inst = struct {
                 .@"export" = .pl_node,
                 .export_value = .pl_node,
                 .field_ptr = .pl_node,
-                .field_ptr_init = .pl_node,
                 .field_val = .pl_node,
                 .field_ptr_named = .pl_node,
                 .field_val_named = .pl_node,
 @@ -1701,30 +1725,16 @@ pub const Inst = struct {
                 .enum_literal = .str_tok,
                 .switch_block = .pl_node,
                 .switch_block_ref = .pl_node,
-                .array_base_ptr = .un_node,
-                .field_base_ptr = .un_node,
-                .opt_eu_base_ty = .un_node,
-                .validate_array_init_ty = .pl_node,
-                .validate_struct_init_ty = .un_node,
-                .validate_struct_init = .pl_node,
-                .validate_array_init = .pl_node,
                 .validate_deref = .un_node,
                 .validate_destructure = .pl_node,
-                .struct_init_empty = .un_node,
-                .field_type = .pl_node,
                 .field_type_ref = .pl_node,
-                .struct_init = .pl_node,
-                .struct_init_ref = .pl_node,
-                .struct_init_anon = .pl_node,
-                .struct_init_anon_ref = .pl_node,
-                .array_init = .pl_node,
-                .array_init_anon = .pl_node,
-                .array_init_ref = .pl_node,
-                .array_init_anon_ref = .pl_node,
                 .union_init = .pl_node,
                 .type_info = .un_node,
                 .size_of = .un_node,
                 .bit_size_of = .un_node,
+                .opt_eu_base_ptr_init = .un_node,
+                .coerce_ptr_elem_ty = .pl_node,
+                .validate_ref_ty = .un_tok,
                 .int_from_ptr = .un_node,
                 .compile_error = .un_node,
 @@ -1826,6 +1836,27 @@ pub const Inst = struct {
                 .save_err_ret_index = .save_err_ret_index,
                 .restore_err_ret_index = .restore_err_ret_index,
+                .struct_init_empty = .un_node,
+                .struct_init_empty_result = .un_node,
+                .struct_init_empty_ref_result = .un_node,
+                .struct_init_anon = .pl_node,
+                .struct_init = .pl_node,
+                .struct_init_ref = .pl_node,
+                .validate_struct_init_ty = .un_node,
+                .validate_struct_init_result_ty = .un_node,
+                .validate_ptr_struct_init = .pl_node,
+                .struct_init_field_type = .pl_node,
+                .struct_init_field_ptr = .pl_node,
+                .array_init_anon = .pl_node,
+                .array_init = .pl_node,
+                .array_init_ref = .pl_node,
+                .validate_array_init_ty = .pl_node,
+                .validate_array_init_result_ty = .pl_node,
+                .validate_array_init_ref_ty = .pl_node,
+                .validate_ptr_array_init = .pl_node,
+                .array_init_elem_type = .bin,
+                .array_init_elem_ptr = .pl_node,
                 .extended = .extended,
             });
         };
 @@ -2771,6 +2802,11 @@ pub const Inst = struct {
         };
     };
+    pub const ArrayInitRefTy = struct {
+        ptr_ty: Ref,
+        elem_count: u32,
+    };
     pub const Field = struct {
         lhs: Ref,
         /// Offset into `string_bytes`.
 @@ -3064,9 +3100,10 @@ pub const Inst = struct {
         fields_len: u32,
         pub const Item = struct {
-            /// The `field_type` ZIR instruction for this field init.
+            /// The `struct_init_field_type` ZIR instruction for this field init.
             field_type: Index,
-            /// The field init expression to be used as the field value.
+            /// The field init expression to be used as the field value. This value will be coerced
+            /// to the field type if not already.
             init: Ref,
         };
     };

src/print_zir.zig+51-29

 @@ -205,8 +205,6 @@ const Writer = struct {
             .store_to_inferred_ptr,
             => try self.writeBin(stream, inst),
-            .elem_type_index => try self.writeElemTypeIndex(stream, inst),
             .alloc,
             .alloc_mut,
             .alloc_comptime_mut,
 @@ -241,7 +239,6 @@ const Writer = struct {
             .is_non_err_ptr,
             .ret_is_non_err,
             .typeof,
-            .struct_init_empty,
             .type_info,
             .size_of,
             .bit_size_of,
 @@ -281,18 +278,16 @@ const Writer = struct {
             .bit_reverse,
             .@"resume",
             .@"await",
-            .array_base_ptr,
-            .field_base_ptr,
-            .validate_struct_init_ty,
             .make_ptr_const,
             .validate_deref,
             .check_comptime_control_flow,
-            .opt_eu_base_ty,
+            .opt_eu_base_ptr_init,
             => try self.writeUnNode(stream, inst),
             .ref,
             .ret_implicit,
             .closure_capture,
+            .validate_ref_ty,
             => try self.writeUnTok(stream, inst),
             .bool_br_and,
 @@ -300,7 +295,6 @@ const Writer = struct {
             => try self.writeBoolBr(stream, inst),
             .validate_destructure => try self.writeValidateDestructure(stream, inst),
-            .validate_array_init_ty => try self.writeValidateArrayInitTy(stream, inst),
             .array_type_sentinel => try self.writeArrayTypeSentinel(stream, inst),
             .ptr_type => try self.writePtrType(stream, inst),
             .int => try self.writeInt(stream, inst),
 @@ -316,12 +310,6 @@ const Writer = struct {
             .@"break",
             .break_inline,
             => try self.writeBreak(stream, inst),
-            .array_init,
-            .array_init_ref,
-            => try self.writeArrayInit(stream, inst),
-            .array_init_anon,
-            .array_init_anon_ref,
-            => try self.writeArrayInitAnon(stream, inst),
             .slice_start => try self.writeSliceStart(stream, inst),
             .slice_end => try self.writeSliceEnd(stream, inst),
 @@ -330,10 +318,44 @@ const Writer = struct {
             .union_init => try self.writeUnionInit(stream, inst),
+            // Struct inits
+            .struct_init_empty,
+            .struct_init_empty_result,
+            .struct_init_empty_ref_result,
+            => try self.writeUnNode(stream, inst),
+            .struct_init_anon => try self.writeStructInitAnon(stream, inst),
             .struct_init,
             .struct_init_ref,
             => try self.writeStructInit(stream, inst),
+            .validate_struct_init_ty,
+            .validate_struct_init_result_ty,
+            => try self.writeUnNode(stream, inst),
+            .validate_ptr_struct_init => try self.writeBlock(stream, inst),
+            .struct_init_field_type => try self.writeStructInitFieldType(stream, inst),
+            .struct_init_field_ptr => try self.writePlNodeField(stream, inst),
+            // Array inits
+            .array_init_anon => try self.writeArrayInitAnon(stream, inst),
+            .array_init,
+            .array_init_ref,
+            => try self.writeArrayInit(stream, inst),
+            .validate_array_init_ty,
+            .validate_array_init_result_ty,
+            => try self.writeValidateArrayInitTy(stream, inst),
+            .validate_array_init_ref_ty => try self.writeValidateArrayInitRefTy(stream, inst),
+            .validate_ptr_array_init => try self.writeBlock(stream, inst),
+            .array_init_elem_type => try self.writeArrayInitElemType(stream, inst),
+            .array_init_elem_ptr => try self.writeArrayInitElemPtr(stream, inst),
             .atomic_load => try self.writeAtomicLoad(stream, inst),
             .atomic_store => try self.writeAtomicStore(stream, inst),
             .atomic_rmw => try self.writeAtomicRmw(stream, inst),
 @@ -342,11 +364,6 @@ const Writer = struct {
             .field_parent_ptr => try self.writeFieldParentPtr(stream, inst),
             .builtin_call => try self.writeBuiltinCall(stream, inst),
-            .struct_init_anon,
-            .struct_init_anon_ref,
-            => try self.writeStructInitAnon(stream, inst),
-            .field_type => try self.writeFieldType(stream, inst),
             .field_type_ref => try self.writeFieldTypeRef(stream, inst),
             .add,
 @@ -409,16 +426,14 @@ const Writer = struct {
             .elem_val_node,
             .elem_ptr,
             .elem_val,
-            .coerce_result_ptr,
             .array_type,
+            .coerce_ptr_elem_ty,
             => try self.writePlNodeBin(stream, inst),
             .for_len => try self.writePlNodeMultiOp(stream, inst),
             .elem_val_imm => try self.writeElemValImm(stream, inst),
-            .elem_ptr_imm => try self.writeElemPtrImm(stream, inst),
             .@"export" => try self.writePlNodeExport(stream, inst),
             .export_value => try self.writePlNodeExportValue(stream, inst),
 @@ -430,8 +445,6 @@ const Writer = struct {
             .block_inline,
             .suspend_block,
             .loop,
-            .validate_struct_init,
-            .validate_array_init,
             .c_import,
             .typeof_builtin,
             => try self.writeBlock(stream, inst),
 @@ -452,9 +465,8 @@ const Writer = struct {
             .switch_block_ref,
             => try self.writeSwitchBlock(stream, inst),
-            .field_ptr,
-            .field_ptr_init,
             .field_val,
+            .field_ptr,
             => try self.writePlNodeField(stream, inst),
             .field_ptr_named,
 @@ -617,7 +629,7 @@ const Writer = struct {
         try stream.writeByte(')');
     }
-    fn writeElemTypeIndex(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {
+    fn writeArrayInitElemType(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {
         const inst_data = self.code.instructions.items(.data)[inst].bin;
         try self.writeInstRef(stream, inst_data.lhs);
         try stream.print(", {d})", .{@intFromEnum(inst_data.rhs)});
 @@ -972,7 +984,7 @@ const Writer = struct {
         try stream.print(", {d})", .{inst_data.idx});
     }
-    fn writeElemPtrImm(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {
+    fn writeArrayInitElemPtr(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {
         const inst_data = self.code.instructions.items(.data)[inst].pl_node;
         const extra = self.code.extraData(Zir.Inst.ElemPtrImm, inst_data.payload_index).data;
 @@ -1004,6 +1016,16 @@ const Writer = struct {
         try self.writeSrc(stream, inst_data.src());
     }
+    fn writeValidateArrayInitRefTy(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {
+        const inst_data = self.code.instructions.items(.data)[inst].pl_node;
+        const extra = self.code.extraData(Zir.Inst.ArrayInitRefTy, inst_data.payload_index).data;
+        try self.writeInstRef(stream, extra.ptr_ty);
+        try stream.writeAll(", ");
+        try stream.print(", {}) ", .{extra.elem_count});
+        try self.writeSrc(stream, inst_data.src());
+    }
     fn writeStructInit(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {
         const inst_data = self.code.instructions.items(.data)[inst].pl_node;
         const extra = self.code.extraData(Zir.Inst.StructInit, inst_data.payload_index);
 @@ -1134,7 +1156,7 @@ const Writer = struct {
         try self.writeSrc(stream, inst_data.src());
     }
-    fn writeFieldType(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {
+    fn writeStructInitFieldType(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {
         const inst_data = self.code.instructions.items(.data)[inst].pl_node;
         const extra = self.code.extraData(Zir.Inst.FieldType, inst_data.payload_index).data;
         try self.writeInstRef(stream, extra.container_type);

src/type.zig+11

...	@@ -3182,6 +3182,17 @@ pub const Type = struct {	...	@@ -3182,6 +3182,17 @@ pub const Type = struct {
3182	};	3182	};
3183	}	3183	}
3184		3184
		3185	/// Traverses optional child types and error union payloads until the type
		3186	/// is not a pointer. For `E!?u32`, returns `u32`; for `u8`, returns `u8`.
		3187	pub fn optEuBaseType(ty: Type, mod: *Module) Type {
		3188	var cur = ty;
		3189	while (true) switch (cur.zigTypeTag(mod)) {
		3190	.Optional => cur = cur.optionalChild(mod),
		3191	.ErrorUnion => cur = cur.errorUnionPayload(mod),
		3192	else => return cur,
		3193	};
		3194	}
		3195
3185	pub const @"u1": Type = .{ .ip_index = .u1_type };	3196	pub const @"u1": Type = .{ .ip_index = .u1_type };
3186	pub const @"u8": Type = .{ .ip_index = .u8_type };	3197	pub const @"u8": Type = .{ .ip_index = .u8_type };
3187	pub const @"u16": Type = .{ .ip_index = .u16_type };	3198	pub const @"u16": Type = .{ .ip_index = .u16_type };

test/behavior/array.zig+34

...	@@ -780,3 +780,37 @@ test "runtime side-effects in comptime-known array init" {	...	@@ -780,3 +780,37 @@ test "runtime side-effects in comptime-known array init" {
780	try expectEqual([4]u4{ 1, 2, 4, 8 }, init);	780	try expectEqual([4]u4{ 1, 2, 4, 8 }, init);
781	try expectEqual(@as(u4, std.math.maxInt(u4)), side_effects);	781	try expectEqual(@as(u4, std.math.maxInt(u4)), side_effects);
782	}	782	}
		783
		784	test "slice initialized through reference to anonymous array init provides result types" {
		785	var my_u32: u32 = 123;
		786	var my_u64: u64 = 456;
		787	const foo: []const u16 = &.{
		788	@intCast(my_u32),
		789	@intCast(my_u64),
		790	@truncate(my_u32),
		791	@truncate(my_u64),
		792	};
		793	try std.testing.expectEqualSlices(u16, &.{ 123, 456, 123, 456 }, foo);
		794	}
		795
		796	test "pointer to array initialized through reference to anonymous array init provides result types" {
		797	var my_u32: u32 = 123;
		798	var my_u64: u64 = 456;
		799	const foo: *const [4]u16 = &.{
		800	@intCast(my_u32),
		801	@intCast(my_u64),
		802	@truncate(my_u32),
		803	@truncate(my_u64),
		804	};
		805	try std.testing.expectEqualSlices(u16, &.{ 123, 456, 123, 456 }, foo);
		806	}
		807
		808	test "tuple initialized through reference to anonymous array init provides result types" {
		809	const Tuple = struct { u64, *const u32 };
		810	const foo: *const Tuple = &.{
		811	@intCast(12345),
		812	@ptrFromInt(0x1000),
		813	};
		814	try expect(foo[0] == 12345);
		815	try expect(@intFromPtr(foo[1]) == 0x1000);
		816	}

test/behavior/cast.zig+26

...	@@ -2493,3 +2493,29 @@ test "@as does not corrupt values with incompatible representations" {	...	@@ -2493,3 +2493,29 @@ test "@as does not corrupt values with incompatible representations" {
2493	});	2493	});
2494	try std.testing.expectApproxEqAbs(@as(f32, 1.23), x, 0.001);	2494	try std.testing.expectApproxEqAbs(@as(f32, 1.23), x, 0.001);
2495	}	2495	}
		2496
		2497	test "result information is preserved through many nested structures" {
		2498	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
		2499	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
		2500	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
		2501	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
		2502	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		2503	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		2504
		2505	const S = struct {
		2506	fn doTheTest() !void {
		2507	const E = error{Foo};
		2508	const T = const ?E!struct { x: ?const E!?u8 };
		2509
		2510	var val: T = &.{ .x = &@truncate(0x1234) };
		2511
		2512	const struct_val = val.*.? catch unreachable;
		2513	const int_val = (struct_val.x.?.* catch unreachable).?;
		2514
		2515	try expect(int_val == 0x34);
		2516	}
		2517	};
		2518
		2519	try S.doTheTest();
		2520	try comptime S.doTheTest();
		2521	}

test/behavior/pointers.zig+18

...	@@ -548,3 +548,21 @@ test "pointer to array has explicit alignment" {	...	@@ -548,3 +548,21 @@ test "pointer to array has explicit alignment" {
548	const casted = S.func(&bases);	548	const casted = S.func(&bases);
549	try expect(casted[0].a == 2);	549	try expect(casted[0].a == 2);
550	}	550	}
		551
		552	test "result type preserved through multiple references" {
		553	const S = struct { x: u32 };
		554	var my_u64: u64 = 12345;
		555	const foo: const const *const S = &&&.{
		556	.x = @intCast(my_u64),
		557	};
		558	try expect(foo...*.x == 12345);
		559	}
		560
		561	test "result type found through optional pointer" {
		562	const ptr1: ?*const u32 = &@intCast(123);
		563	const ptr2: ?[]const u8 = &.{ @intCast(123), @truncate(0xABCD) };
		564	try expect(ptr1.?.* == 123);
		565	try expect(ptr2.?.len == 2);
		566	try expect(ptr2.?[0] == 123);
		567	try expect(ptr2.?[1] == 0xCD);
		568	}

test/behavior/struct.zig+15

...	@@ -1760,3 +1760,18 @@ test "runtime side-effects in comptime-known struct init" {	...	@@ -1760,3 +1760,18 @@ test "runtime side-effects in comptime-known struct init" {
1760	try expectEqual(S{ .a = 1, .b = 2, .c = 4, .d = 8 }, init);	1760	try expectEqual(S{ .a = 1, .b = 2, .c = 4, .d = 8 }, init);
1761	try expectEqual(@as(u4, std.math.maxInt(u4)), side_effects);	1761	try expectEqual(@as(u4, std.math.maxInt(u4)), side_effects);
1762	}	1762	}
		1763
		1764	test "pointer to struct initialized through reference to anonymous initializer provides result types" {
		1765	const S = struct { a: u8, b: u16, c: *const anyopaque };
		1766	var my_u16: u16 = 0xABCD;
		1767	const s: *const S = &.{
		1768	// intentionally out of order
		1769	.c = @ptrCast("hello"),
		1770	.b = my_u16,
		1771	.a = @truncate(my_u16),
		1772	};
		1773	try expect(s.a == 0xCD);
		1774	try expect(s.b == 0xABCD);
		1775	const str: *const [5]u8 = @ptrCast(s.c);
		1776	try std.testing.expectEqualSlices(u8, "hello", str);
		1777	}

test/cases/compile_errors/anytype_param_requires_comptime.zig+2-4

...	@@ -16,7 +16,5 @@ pub export fn entry() void {	...	@@ -16,7 +16,5 @@ pub export fn entry() void {
16	// backend=stage2	16	// backend=stage2
17	// target=native	17	// target=native
18	//	18	//
19	// :7:14: error: runtime-known argument passed to parameter of comptime-only type	19	// :7:25: error: unable to resolve comptime value
20	// :9:12: note: declared here	20	// :7:25: note: initializer of comptime only struct must be comptime-known
21	// :4:16: note: struct requires comptime because of this field
22	// :4:16: note: types are not available at runtime

test/cases/compile_errors/assigning_to_struct_or_union_fields_that_are_not_optionals_with_a_function_that_returns_an_optional.zig

+3-3

...	@@ -18,6 +18,6 @@ export fn entry() void {	...	@@ -18,6 +18,6 @@ export fn entry() void {
18	// backend=stage2	18	// backend=stage2
19	// target=native	19	// target=native
20	//	20	//
21	// :11:27: error: expected type 'u8', found '?u8'	21	// :11:20: error: expected type 'u8', found '?u8'
22	// :11:27: note: cannot convert optional to payload type	22	// :11:20: note: cannot convert optional to payload type
23	// :11:27: note: consider using '.?', 'orelse', or 'if'	23	// :11:20: note: consider using '.?', 'orelse', or 'if'

test/cases/compile_errors/cast_without_result_type_due_to_anyopaque_pointer.zig created+21

...	@@ -0,0 +1,21 @@
1	export fn foo() void {
2	const x: *const anyopaque = &@intCast(123);
3	_ = x;
4	}
5	export fn bar() void {
6	const x: *const anyopaque = &.{
7	.x = @intCast(123),
8	};
9	_ = x;
10	}
11
12	// error
13	// backend=stage2
14	// target=native
15	//
16	// :2:34: error: @intCast must have a known result type
17	// :2:34: note: result type is unknown due to opaque pointer type
18	// :2:34: note: use @as to provide explicit result type
19	// :7:14: error: @intCast must have a known result type
20	// :6:35: note: result type is unknown due to opaque pointer type
21	// :7:14: note: use @as to provide explicit result type

test/cases/compile_errors/cast_without_result_type_due_to_generic_parameter.zig+12-4

 @@ -10,6 +10,11 @@ export fn c() void {
 export fn d() void {
     bar(@floatFromInt(123));
 }
+export fn f() void {
+    bar(.{
+        .x = @intCast(123),
+    });
+}
 fn bar(_: anytype) void {}
 @@ -18,14 +23,17 @@ fn bar(_: anytype) void {}
 // target=native
 //
 // :2:9: error: @ptrFromInt must have a known result type
-// :2:9: note: result type is unknown due to anytype parameter
+// :2:8: note: result type is unknown due to anytype parameter
 // :2:9: note: use @as to provide explicit result type
 // :5:9: error: @ptrCast must have a known result type
-// :5:9: note: result type is unknown due to anytype parameter
+// :5:8: note: result type is unknown due to anytype parameter
 // :5:9: note: use @as to provide explicit result type
 // :8:9: error: @intCast must have a known result type
-// :8:9: note: result type is unknown due to anytype parameter
+// :8:8: note: result type is unknown due to anytype parameter
 // :8:9: note: use @as to provide explicit result type
 // :11:9: error: @floatFromInt must have a known result type
-// :11:9: note: result type is unknown due to anytype parameter
+// :11:8: note: result type is unknown due to anytype parameter
 // :11:9: note: use @as to provide explicit result type
+// :15:14: error: @intCast must have a known result type
+// :14:8: note: result type is unknown due to anytype parameter
+// :15:14: note: use @as to provide explicit result type

test/cases/compile_errors/for_invalid_ranges.zig+2-1

...	@@ -31,5 +31,6 @@ export fn e() void {	...	@@ -31,5 +31,6 @@ export fn e() void {
31	// :2:13: error: expected type 'usize', found '*const [5:0]u8'	31	// :2:13: error: expected type 'usize', found '*const [5:0]u8'
32	// :7:10: error: type 'usize' cannot represent integer value '-1'	32	// :7:10: error: type 'usize' cannot represent integer value '-1'
33	// :12:10: error: expected type 'usize', found '*const [5:0]u8'	33	// :12:10: error: expected type 'usize', found '*const [5:0]u8'
34	// :17:13: error: expected type 'usize', found '*const struct{comptime comptime_int = 97, comptime comptime_int = 98, comptime comptime_int = 99}'	34	// :17:13: error: expected type 'usize', found pointer
		35	// :17:13: note: address-of operator always returns a pointer
35	// :22:20: error: overflow of integer type 'usize' with value '-1'	36	// :22:20: error: overflow of integer type 'usize' with value '-1'

test/cases/compile_errors/invalid_store_to_comptime_field.zig+5-4

test/cases/compile_errors/missing_const_in_slice_with_nested_array_type.zig+1-1

...	@@ -15,4 +15,4 @@ export fn entry() void {	...	@@ -15,4 +15,4 @@ export fn entry() void {
15	// backend=llvm	15	// backend=llvm
16	// target=native	16	// target=native
17	//	17	//
18	// :4:30: error: array literal requires address-of operator (&) to coerce to slice type '[][2]f32'	18	// :4:26: error: array literal requires address-of operator (&) to coerce to slice type '[][2]f32'

test/cases/compile_errors/missing_else_clause.zig+3-1

...	@@ -39,4 +39,6 @@ export fn entry() void {	...	@@ -39,4 +39,6 @@ export fn entry() void {
39	// :8:25: note: type 'i32' here	39	// :8:25: note: type 'i32' here
40	// :16:16: error: expected type 'tmp.h.T', found 'void'	40	// :16:16: error: expected type 'tmp.h.T', found 'void'
41	// :15:15: note: struct declared here	41	// :15:15: note: struct declared here
42	// :22:9: error: incompatible types: 'void' and 'tmp.k.T'	42	// :22:13: error: incompatible types: 'void' and 'tmp.k.T'
		43	// :22:25: note: type 'void' here
		44	// :24:13: note: type 'tmp.k.T' here

test/cases/compile_errors/pointer_attributes_checked_when_coercing_pointer_to_anon_literal.zig+3-3

...	@@ -16,9 +16,9 @@ comptime {	...	@@ -16,9 +16,9 @@ comptime {
16	// backend=stage2	16	// backend=stage2
17	// target=native	17	// target=native
18	//	18	//
19	// :2:29: error: expected type '[][]const u8', found 'const struct{comptime const [5:0]u8 = "hello", comptime *const [5:0]u8 = "world"}'	19	// :2:29: error: expected type '[][]const u8', found '*const [2][]const u8'
20	// :2:29: note: cast discards const qualifier	20	// :2:29: note: cast discards const qualifier
21	// :6:31: error: expected type '[2][]const u8', found 'const struct{comptime const [5:0]u8 = "hello", comptime const [5:0]u8 = "world"}'	21	// :6:31: error: expected type '[2][]const u8', found 'const [2][]const u8'
22	// :6:31: note: cast discards const qualifier	22	// :6:31: note: cast discards const qualifier
23	// :11:19: error: expected type 'tmp.S', found 'const struct{comptime a: comptime_int = 2}'	23	// :11:19: error: expected type 'tmp.S', found 'const tmp.S'
24	// :11:19: note: cast discards const qualifier	24	// :11:19: note: cast discards const qualifier

test/cases/compile_errors/reassign_to_array_parameter.zig+1-1

...	@@ -9,4 +9,4 @@ export fn entry() void {	...	@@ -9,4 +9,4 @@ export fn entry() void {
9	// backend=llvm	9	// backend=llvm
10	// target=native	10	// target=native
11	//	11	//
12	// :2:15: error: cannot assign to constant	12	// :2:5: error: cannot assign to constant

test/cases/compile_errors/reassign_to_struct_parameter.zig+1-1

...	@@ -12,4 +12,4 @@ export fn entry() void {	...	@@ -12,4 +12,4 @@ export fn entry() void {
12	// backend=stage2	12	// backend=stage2
13	// target=native	13	// target=native
14	//	14	//
15	// :5:10: error: cannot assign to constant	15	// :5:5: error: cannot assign to constant

test/cases/compile_errors/regression_test_2980_base_type_u32_is_not_type_checked_properly_when_assigning_a_value_within_a_struct.zig

+3-3

...	@@ -18,6 +18,6 @@ export fn entry() void {	...	@@ -18,6 +18,6 @@ export fn entry() void {
18	// backend=stage2	18	// backend=stage2
19	// target=native	19	// target=native
20	//	20	//
21	// :12:25: error: expected type 'u32', found '@typeInfo(@typeInfo(@TypeOf(tmp.get_uval)).Fn.return_type.?).ErrorUnion.error_set!u32'	21	// :12:15: error: expected type 'u32', found '@typeInfo(@typeInfo(@TypeOf(tmp.get_uval)).Fn.return_type.?).ErrorUnion.error_set!u32'
22	// :12:25: note: cannot convert error union to payload type	22	// :12:15: note: cannot convert error union to payload type
23	// :12:25: note: consider using 'try', 'catch', or 'if'	23	// :12:15: note: consider using 'try', 'catch', or 'if'

test/cases/compile_errors/result_location_incompatibility_mismatching_handle_is_ptr.zig+3-3

...	@@ -15,6 +15,6 @@ pub const Container = struct {	...	@@ -15,6 +15,6 @@ pub const Container = struct {
15	// backend=stage2	15	// backend=stage2
16	// target=native	16	// target=native
17	//	17	//
18	// :3:36: error: expected type 'i32', found '?i32'	18	// :3:23: error: expected type 'i32', found '?i32'
19	// :3:36: note: cannot convert optional to payload type	19	// :3:23: note: cannot convert optional to payload type
20	// :3:36: note: consider using '.?', 'orelse', or 'if'	20	// :3:23: note: consider using '.?', 'orelse', or 'if'

test/cases/compile_errors/result_location_incompatibility_mismatching_handle_is_ptr_generic_call.zig+3-3

...	@@ -15,6 +15,6 @@ pub const Container = struct {	...	@@ -15,6 +15,6 @@ pub const Container = struct {
15	// backend=stage2	15	// backend=stage2
16	// target=native	16	// target=native
17	//	17	//
18	// :3:36: error: expected type 'i32', found '?i32'	18	// :3:23: error: expected type 'i32', found '?i32'
19	// :3:36: note: cannot convert optional to payload type	19	// :3:23: note: cannot convert optional to payload type
20	// :3:36: note: consider using '.?', 'orelse', or 'if'	20	// :3:23: note: consider using '.?', 'orelse', or 'if'

test/cases/compile_errors/return_incompatible_generic_struct.zig+1

...	@@ -18,3 +18,4 @@ export fn entry() void {	...	@@ -18,3 +18,4 @@ export fn entry() void {
18	// :8:18: error: expected type 'tmp.A(u32)', found 'tmp.B(u32)'	18	// :8:18: error: expected type 'tmp.A(u32)', found 'tmp.B(u32)'
19	// :5:12: note: struct declared here	19	// :5:12: note: struct declared here
20	// :2:12: note: struct declared here	20	// :2:12: note: struct declared here
		21	// :7:11: note: function return type declared here

test/cases/compile_errors/runtime_assignment_to_comptime_struct_type.zig+2-2

...	@@ -12,5 +12,5 @@ export fn f() void {	...	@@ -12,5 +12,5 @@ export fn f() void {
12	// backend=stage2	12	// backend=stage2
13	// target=native	13	// target=native
14	//	14	//
15	// :7:29: error: unable to resolve comptime value	15	// :7:23: error: unable to resolve comptime value
16	// :7:29: note: initializer of comptime only struct must be comptime-known	16	// :7:23: note: initializer of comptime only struct must be comptime-known

test/cases/compile_errors/runtime_assignment_to_comptime_union_type.zig+2-2

...	@@ -12,5 +12,5 @@ export fn f() void {	...	@@ -12,5 +12,5 @@ export fn f() void {
12	// backend=stage2	12	// backend=stage2
13	// target=native	13	// target=native
14	//	14	//
15	// :7:29: error: unable to resolve comptime value	15	// :7:23: error: unable to resolve comptime value
16	// :7:29: note: initializer of comptime only union must be comptime-known	16	// :7:23: note: initializer of comptime only union must be comptime-known

test/cases/compile_errors/shift_amount_has_to_be_an_integer_type.zig+2-1

...	@@ -7,4 +7,5 @@ export fn entry() void {	...	@@ -7,4 +7,5 @@ export fn entry() void {
7	// backend=stage2	7	// backend=stage2
8	// target=native	8	// target=native
9	//	9	//
10	// :2:20: error: expected type 'comptime_int', found '*const u8'	10	// :2:20: error: expected type 'comptime_int', found pointer
		11	// :2:20: note: address-of operator always returns a pointer

test/cases/compile_errors/slice_sentinel_mismatch-1.zig+10-3

 @@ -1,11 +1,18 @@
-export fn entry() void {
+export fn entry1() void {
     const y: [:1]const u8 = &[_:2]u8{ 1, 2 };
     _ = y;
 }
+export fn entry2() void {
+    const x: [:2]const u8 = &.{ 1, 2 };
+    const y: [:1]const u8 = x;
+    _ = y;
+}
 // error
 // backend=stage2
 // target=native
 //
-// :2:29: error: expected type '[:1]const u8', found '*const [2:2]u8'
+// :2:37: error: expected type '[2:1]u8', found '[2:2]u8'
-// :2:29: note: pointer sentinel '2' cannot cast into pointer sentinel '1'
+// :2:37: note: array sentinel '2' cannot cast into array sentinel '1'
+// :7:29: error: expected type '[:1]const u8', found '[:2]const u8'
+// :7:29: note: pointer sentinel '2' cannot cast into pointer sentinel '1'

test/cases/compile_errors/union_init_with_none_or_multiple_fields.zig-1

...	@@ -28,7 +28,6 @@ export fn u2m() void {	...	@@ -28,7 +28,6 @@ export fn u2m() void {
28	// target=native	28	// target=native
29	//	29	//
30	// :10:20: error: union initializer must initialize one field	30	// :10:20: error: union initializer must initialize one field
31	// :1:12: note: union declared here
32	// :14:20: error: cannot initialize multiple union fields at once; unions can only have one active field	31	// :14:20: error: cannot initialize multiple union fields at once; unions can only have one active field
33	// :14:31: note: additional initializer here	32	// :14:31: note: additional initializer here
34	// :1:12: note: union declared here	33	// :1:12: note: union declared here

test/cases/compile_errors/union_noreturn_field_initialized.zig+1-1

...	@@ -32,7 +32,7 @@ pub export fn entry3() void {	...	@@ -32,7 +32,7 @@ pub export fn entry3() void {
32	// backend=stage2	32	// backend=stage2
33	// target=native	33	// target=native
34	//	34	//
35	// :11:21: error: cannot initialize 'noreturn' field of union	35	// :11:14: error: cannot initialize 'noreturn' field of union
36	// :4:9: note: field 'b' declared here	36	// :4:9: note: field 'b' declared here
37	// :2:15: note: union declared here	37	// :2:15: note: union declared here
38	// :19:10: error: cannot initialize 'noreturn' field of union	38	// :19:10: error: cannot initialize 'noreturn' field of union

test/cases/compile_errors/wrong_types_given_to_export.zig+1-1

...	@@ -7,5 +7,5 @@ comptime {	...	@@ -7,5 +7,5 @@ comptime {
7	// backend=stage2	7	// backend=stage2
8	// target=native	8	// target=native
9	//	9	//
10	// :3:51: error: expected type 'builtin.GlobalLinkage', found 'u32'	10	// :3:41: error: expected type 'builtin.GlobalLinkage', found 'u32'
11	// :?:?: note: enum declared here	11	// :?:?: note: enum declared here

test/compile_errors.zig+2-4

 @@ -207,10 +207,8 @@ pub fn addCases(ctx: *Cases) !void {
             ":1:38: note: declared comptime here",
             ":8:36: error: runtime-known argument passed to comptime parameter",
             ":2:41: note: declared comptime here",
-            ":13:29: error: runtime-known argument passed to parameter of comptime-only type",
+            ":13:32: error: unable to resolve comptime value",
-            ":3:24: note: declared here",
+            ":13:32: note: initializer of comptime only struct must be comptime-known",
-            ":12:35: note: struct requires comptime because of this field",
-            ":12:35: note: types are not available at runtime",
         });
         case.addSourceFile("import.zig",

...	@@ -71,8 +71,8 @@ pub export fn entry8() void {	...	@@ -71,8 +71,8 @@ pub export fn entry8() void {
71	// target=native	71	// target=native
72	// backend=stage2	72	// backend=stage2
73	//	73	//
74	// :6:19: error: value stored in comptime field does not match the default value of the field	74	// :6:9: error: value stored in comptime field does not match the default value of the field
75	// :14:19: error: value stored in comptime field does not match the default value of the field	75	// :14:9: error: value stored in comptime field does not match the default value of the field
76	// :19:38: error: value stored in comptime field does not match the default value of the field	76	// :19:38: error: value stored in comptime field does not match the default value of the field
77	// :31:19: error: value stored in comptime field does not match the default value of the field	77	// :31:19: error: value stored in comptime field does not match the default value of the field
78	// :25:29: note: default value set here	78	// :25:29: note: default value set here
...	@@ -80,5 +80,6 @@ pub export fn entry8() void {	...	@@ -80,5 +80,6 @@ pub export fn entry8() void {
80	// :35:29: note: default value set here	80	// :35:29: note: default value set here
81	// :45:12: error: value stored in comptime field does not match the default value of the field	81	// :45:12: error: value stored in comptime field does not match the default value of the field
82	// :53:25: error: value stored in comptime field does not match the default value of the field	82	// :53:25: error: value stored in comptime field does not match the default value of the field
83	// :66:43: error: value stored in comptime field does not match the default value of the field	83	// :66:36: error: value stored in comptime field does not match the default value of the field
84	// :59:35: error: value stored in comptime field does not match the default value of the field	84	// :59:30: error: value stored in comptime field does not match the default value of the field
		85	// :57:29: note: default value set here