Commit df5f0517b33b5f7bc2a508cf6a0ee62246f02d21 | zig

author	Andrew Kelley <andrew@ziglang.org> 2023-09-24 15:19:48-07:00
committer	GitHub <noreply@github.com> 2023-09-24 15:19:48-07:00
log	df5f0517b33b5f7bc2a508cf6a0ee62246f02d21
tree	64d664b74afd6d100be328b7225b87753bf62fd7
parent	a9f25c7d642ec0ed047ae9be6ad87d102f3f75c8
parent	9ff872c9829c20cb16d233534248c5cf371a8bd9
signature	Signed by PGP key 4AEE18F83AFDEB23

Merge pull request #17205 from mlugg/rls-ref

compiler: preserve result type information through address-of operator

39 files changed, 1335 insertions(+), 1029 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+19-34

 @@ -45,6 +45,14 @@ ref_paths_pending_on_types: std.AutoHashMapUnmanaged(
     std.ArrayListUnmanaged(RefPathResumeInfo),
 ) = .{},
+/// A set of ZIR instruction refs which have a meaning other than the
+/// instruction they refer to. For instance, during analysis of the arguments to
+/// a `call`, the index of the `call` itself is repurposed to refer to the
+/// parameter type.
+/// TODO: there should be some kind of proper handling for these instructions;
+/// currently we just ignore them!
+repurposed_insts: std.AutoHashMapUnmanaged(Zir.Inst.Index, void) = .{},
 const RefPathResumeInfo = struct {
     file: *File,
     ref_path: []DocData.Expr,
 @@ -954,6 +962,11 @@ fn walkInstruction(
     const tags = file.zir.instructions.items(.tag);
     const data = file.zir.instructions.items(.data);
+    if (self.repurposed_insts.contains(@intCast(inst_index))) {
+        // TODO: better handling here
+        return .{ .expr = .{ .comptimeExpr = 0 } };
+    }
     // We assume that the topmost ast_node entry corresponds to our decl
     const self_ast_node_index = self.ast_nodes.items.len - 1;
 @@ -2378,34 +2391,6 @@ fn walkInstruction(
                 .expr = .{ .@"&" = expr_index },
             };
         },
-        .array_init_anon_ref => {
-            const pl_node = data[inst_index].pl_node;
-            const extra = file.zir.extraData(Zir.Inst.MultiOp, pl_node.payload_index);
-            const operands = file.zir.refSlice(extra.end, extra.data.operands_len);
-            const array_data = try self.arena.alloc(usize, operands.len);
-            for (operands, 0..) |op, idx| {
-                const wr = try self.walkRef(
-                    file,
-                    parent_scope,
-                    parent_src,
-                    op,
-                    false,
-                    call_ctx,
-                );
-                const expr_index = self.exprs.items.len;
-                try self.exprs.append(self.arena, wr.expr);
-                array_data[idx] = expr_index;
-            }
-            const expr_index = self.exprs.items.len;
-            try self.exprs.append(self.arena, .{ .array = array_data });
-            return DocData.WalkResult{
-                .typeRef = null,
-                .expr = .{ .@"&" = expr_index },
-            };
-        },
         .float => {
             const float = data[inst_index].float;
             return DocData.WalkResult{
 @@ -2696,9 +2681,7 @@ fn walkInstruction(
                 .expr = .{ .declRef = decl_status },
             };
         },
-        .field_val, .field_ptr, .field_type => {
+        .field_val, .field_ptr => {
-            // TODO: field type uses Zir.Inst.FieldType, it just happens to have the
-            // same layout as Zir.Inst.Field :^)
             const pl_node = data[inst_index].pl_node;
             const extra = file.zir.extraData(Zir.Inst.Field, pl_node.payload_index);
 @@ -2717,8 +2700,7 @@ fn walkInstruction(
                     };
                     if (tags[lhs] != .field_val and
-                        tags[lhs] != .field_ptr and
+                        tags[lhs] != .field_ptr) break :blk lhs_extra.data.lhs;
-                        tags[lhs] != .field_type) break :blk lhs_extra.data.lhs;
                     lhs_extra = file.zir.extraData(
                         Zir.Inst.Field,
 @@ -2857,7 +2839,7 @@ fn walkInstruction(
                 const field_name = blk: {
                     const field_inst_index = init_extra.data.field_type;
-                    if (tags[field_inst_index] != .field_type) unreachable;
+                    if (tags[field_inst_index] != .struct_init_field_type) unreachable;
                     const field_pl_node = data[field_inst_index].pl_node;
                     const field_extra = file.zir.extraData(
                         Zir.Inst.FieldType,
 @@ -3022,6 +3004,9 @@ fn walkInstruction(
             var args = try self.arena.alloc(DocData.Expr, args_len);
             const body = file.zir.extra[extra.end..];
+            try self.repurposed_insts.put(self.arena, @intCast(inst_index), {});
+            defer _ = self.repurposed_insts.remove(@intCast(inst_index));
             var i: usize = 0;
             while (i < args_len) : (i += 1) {
                 const arg_end = file.zir.extra[extra.end + i];

src/InternPool.zig+2-2

...	@@ -5075,8 +5075,8 @@ pub fn get(ip: *InternPool, gpa: Allocator, key: Key) Allocator.Error!Index {	...	@@ -5075,8 +5075,8 @@ pub fn get(ip: *InternPool, gpa: Allocator, key: Key) Allocator.Error!Index {
5075	try ip.string_bytes.ensureUnusedCapacity(gpa, @as(usize, @intCast(len_including_sentinel + 1)));	5075	try ip.string_bytes.ensureUnusedCapacity(gpa, @as(usize, @intCast(len_including_sentinel + 1)));
5076	try ip.extra.ensureUnusedCapacity(gpa, @typeInfo(Bytes).Struct.fields.len);	5076	try ip.extra.ensureUnusedCapacity(gpa, @typeInfo(Bytes).Struct.fields.len);
5077	switch (aggregate.storage) {	5077	switch (aggregate.storage) {
5078	.bytes => \|bytes\| ip.string_bytes.appendSliceAssumeCapacity(bytes),	5078	.bytes => \|bytes\| ip.string_bytes.appendSliceAssumeCapacity(bytes[0..@intCast(len)]),
5079	.elems => \|elems\| for (elems) \|elem\| switch (ip.indexToKey(elem)) {	5079	.elems => \|elems\| for (elems[0..@intCast(len)]) \|elem\| switch (ip.indexToKey(elem)) {
5080	.undef => {	5080	.undef => {
5081	ip.string_bytes.shrinkRetainingCapacity(string_bytes_index);	5081	ip.string_bytes.shrinkRetainingCapacity(string_bytes_index);
5082	break :bytes;	5082	break :bytes;

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+110-31

 @@ -130,6 +130,63 @@ const Writer = struct {
     recurse_decls: bool,
     recurse_blocks: bool,
+    /// Using `std.zig.findLineColumn` whenever we need to resolve a source location makes ZIR
+    /// printing O(N^2), which can have drastic effects - taking a ZIR dump from a few seconds to
+    /// many minutes. Since we're usually resolving source locations close to one another,
+    /// preserving state across source location resolutions speeds things up a lot.
+    line_col_cursor: struct {
+        line: usize = 0,
+        column: usize = 0,
+        line_start: usize = 0,
+        off: usize = 0,
+        fn find(cur: *@This(), source: []const u8, want_offset: usize) std.zig.Loc {
+            if (want_offset < cur.off) {
+                // Go back to the start of this line
+                cur.off = cur.line_start;
+                cur.column = 0;
+                while (want_offset < cur.off) {
+                    // Go back to the newline
+                    cur.off -= 1;
+                    // Seek to the start of the previous line
+                    while (cur.off > 0 and source[cur.off - 1] != '\n') {
+                        cur.off -= 1;
+                    }
+                    cur.line_start = cur.off;
+                    cur.line -= 1;
+                }
+            }
+            // The cursor is now positioned before `want_offset`.
+            // Seek forward as in `std.zig.findLineColumn`.
+            while (cur.off < want_offset) : (cur.off += 1) {
+                switch (source[cur.off]) {
+                    '\n' => {
+                        cur.line += 1;
+                        cur.column = 0;
+                        cur.line_start = cur.off + 1;
+                    },
+                    else => {
+                        cur.column += 1;
+                    },
+                }
+            }
+            while (cur.off < source.len and source[cur.off] != '\n') {
+                cur.off += 1;
+            }
+            return .{
+                .line = cur.line,
+                .column = cur.column,
+                .source_line = source[cur.line_start..cur.off],
+            };
+        }
+    } = .{},
     fn relativeToNodeIndex(self: *Writer, offset: i32) Ast.Node.Index {
         return @as(Ast.Node.Index, @bitCast(offset + @as(i32, @bitCast(self.parent_decl_node))));
     }
 @@ -148,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,
 @@ -184,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,
 @@ -224,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,
 @@ -243,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),
 @@ -259,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),
 @@ -273,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),
 @@ -285,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,
 @@ -352,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),
 @@ -373,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),
 @@ -395,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,
 @@ -560,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)});
 @@ -915,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;
 @@ -947,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);
 @@ -1077,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);
 @@ -2590,8 +2669,8 @@ const Writer = struct {
                 .lazy = src,
             };
             const src_span = src_loc.span(self.gpa) catch unreachable;
-            const start = std.zig.findLineColumn(tree.source, src_span.start);
+            const start = self.line_col_cursor.find(tree.source, src_span.start);
-            const end = std.zig.findLineColumn(tree.source, src_span.end);
+            const end = self.line_col_cursor.find(tree.source, src_span.end);
             try stream.print("{s}:{d}:{d} to :{d}:{d}", .{
                 @tagName(src), start.line + 1, start.column + 1,
                 end.line + 1,  end.column + 1,

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/bugs/12776.zig+1

...	@@ -29,6 +29,7 @@ const CPU = packed struct {	...	@@ -29,6 +29,7 @@ const CPU = packed struct {
29	};	29	};
30		30
31	test {	31	test {
		32	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
32	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	33	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
33	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	34	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
34	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;	35	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;

test/behavior/bugs/13664.zig+1

...	@@ -17,6 +17,7 @@ test {	...	@@ -17,6 +17,7 @@ test {
17	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	17	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
18	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	18	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
19	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	19	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		20	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
20		21
21	const timestamp: i64 = value();	22	const timestamp: i64 = value();
22	const id = ID{ .fields = Fields{	23	const id = ID{ .fields = Fields{

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",

test/tests.zig+5

 @@ -1034,6 +1034,11 @@ pub fn addModuleTests(b: *std.Build, options: ModuleTestOptions) *Step {
         these_tests.addIncludePath(.{ .path = "test" });
+        if (test_target.target.getOs().tag == .wasi) {
+            // WASI's default stack size can be too small for some big tests.
+            these_tests.stack_size = 2 * 1024 * 1024;
+        }
         const qualified_name = b.fmt("{s}-{s}-{s}{s}{s}{s}", .{
             options.name,
             triple_txt,

...	@@ -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