Commit b34f994c0ba2d87fce2a3409d6bcfa7a5ebe78ff | zig

author	Andrew Kelley <andrew@ziglang.org> 2022-01-21 00:49:58-07:00
committer	Andrew Kelley <andrew@ziglang.org> 2022-01-24 21:47:53-07:00
log	b34f994c0ba2d87fce2a3409d6bcfa7a5ebe78ff
tree	436e0ad81e8baddbdcbe5d7148338bcac11a23df
parent	0866fa9d1d46f3c66a4adcaf1d863e762f874c6c

stage2: type system treats fn ptr and body separately

This commit updates stage2 to enforce the property that the syntax
`fn()void` is a function *body* not a *pointer*. To get a pointer, the
syntax `*const fn()void` is required.

ZIR puts function alignment into the func instruction rather than the
decl because this way it makes it into function types. LLVM backend
respects function alignments.

Struct and Union have methods `fieldSrcLoc` to help look up source
locations of their fields. These trigger full loading, tokenization, and
parsing of source files, so should only be called once it is confirmed
that an error message needs to be printed.

There are some nice new error hints for explaining why a type is
required to be comptime, particularly for structs that contain function
body types.

`Type.requiresComptime` is now moved into Sema because it can fail and
might need to trigger field type resolution. Comptime pointer loading
takes into account types that do not have a well-defined memory layout
and does not try to compute a byte offset for them.

`fn()void` syntax no longer secretly makes a pointer. You get a function
body type, which requires comptime. However a pointer to a function body
can be runtime known (obviously).

Compile errors that report "expected pointer, found ..." are factored
out into convenience functions `checkPtrOperand` and `checkPtrType` and
have a note about function pointers.

Implemented `Value.hash` for functions, enum literals, and undefined values.

stage1 is not updated to this (yet?), so some workarounds and disabled
tests are needed to keep everything working. Should we update stage1 to
these new type semantics? Yes probably because I don't want to add too
much conditional compilation logic in the std lib for the different
backends.

24 files changed, 856 insertions(+), 354 deletions(-)

lib/std/builtin.zig+7-1

...	...	@@ -730,10 +730,16 @@ pub const CompilerBackend = enum(u64) {
730	730	/// therefore must be kept in sync with the compiler implementation.
731	731	pub const TestFn = struct {
732	732	name: []const u8,
733		func: fn () anyerror!void,
	733	func: testFnProto,
734	734	async_frame_size: ?usize,
735	735	};
736	736
	737	/// stage1 is wrong. It is not yet updated to support the new function type semantics.
	738	const testFnProto = switch (builtin.zig_backend) {
	739	.stage1 => fn () anyerror!void, // wrong!
	740	else => *const fn () anyerror!void,
	741	};
	742
737	743	/// This function type is used by the Zig language code generation and
738	744	/// therefore must be kept in sync with the compiler implementation.
739	745	pub const PanicFn = fn ([]const u8, ?*StackTrace) noreturn;

src/AstGen.zig+4-6

...	...	@@ -3240,7 +3240,8 @@ fn fnDecl(
3240	3240	const doc_comment_index = try astgen.docCommentAsString(fn_proto.firstToken());
3241	3241
3242	3242	const has_section_or_addrspace = fn_proto.ast.section_expr != 0 or fn_proto.ast.addrspace_expr != 0;
3243		wip_members.nextDecl(is_pub, is_export, fn_proto.ast.align_expr != 0, has_section_or_addrspace);
	3243	// Alignment is passed in the func instruction in this case.
	3244	wip_members.nextDecl(is_pub, is_export, false, has_section_or_addrspace);
3244	3245
3245	3246	var params_scope = &fn_gz.base;
3246	3247	const is_var_args = is_var_args: {
...	...	@@ -3380,7 +3381,7 @@ fn fnDecl(
3380	3381	.param_block = block_inst,
3381	3382	.body_gz = null,
3382	3383	.cc = cc,
3383		.align_inst = .none, // passed in the per-decl data
	3384	.align_inst = align_inst,
3384	3385	.lib_name = lib_name,
3385	3386	.is_var_args = is_var_args,
3386	3387	.is_inferred_error = false,
...	...	@@ -3423,7 +3424,7 @@ fn fnDecl(
3423	3424	.ret_br = ret_br,
3424	3425	.body_gz = &fn_gz,
3425	3426	.cc = cc,
3426		.align_inst = .none, // passed in the per-decl data
	3427	.align_inst = align_inst,
3427	3428	.lib_name = lib_name,
3428	3429	.is_var_args = is_var_args,
3429	3430	.is_inferred_error = is_inferred_error,
...	...	@@ -3449,9 +3450,6 @@ fn fnDecl(
3449	3450	wip_members.appendToDecl(fn_name_str_index);
3450	3451	wip_members.appendToDecl(block_inst);
3451	3452	wip_members.appendToDecl(doc_comment_index);
3452		if (align_inst != .none) {
3453		wip_members.appendToDecl(@enumToInt(align_inst));
3454		}
3455	3453	if (has_section_or_addrspace) {
3456	3454	wip_members.appendToDecl(@enumToInt(section_inst));
3457	3455	wip_members.appendToDecl(@enumToInt(addrspace_inst));

src/Module.zig+117-2

...	...	@@ -898,6 +898,45 @@ pub const Struct = struct {
898	898	};
899	899	}
900	900
	901	pub fn fieldSrcLoc(s: Struct, gpa: Allocator, query: FieldSrcQuery) SrcLoc {
	902	@setCold(true);
	903	const tree = s.owner_decl.getFileScope().getTree(gpa) catch \|err\| {
	904	// In this case we emit a warning + a less precise source location.
	905	log.warn("unable to load {s}: {s}", .{
	906	s.owner_decl.getFileScope().sub_file_path, @errorName(err),
	907	});
	908	return s.srcLoc();
	909	};
	910	const node = s.owner_decl.relativeToNodeIndex(s.node_offset);
	911	const node_tags = tree.nodes.items(.tag);
	912	const file = s.owner_decl.getFileScope();
	913	switch (node_tags[node]) {
	914	.container_decl,
	915	.container_decl_trailing,
	916	=> return queryFieldSrc(tree.*, query, file, tree.containerDecl(node)),
	917	.container_decl_two, .container_decl_two_trailing => {
	918	var buffer: [2]Ast.Node.Index = undefined;
	919	return queryFieldSrc(tree.*, query, file, tree.containerDeclTwo(&buffer, node));
	920	},
	921	.container_decl_arg,
	922	.container_decl_arg_trailing,
	923	=> return queryFieldSrc(tree.*, query, file, tree.containerDeclArg(node)),
	924
	925	.tagged_union,
	926	.tagged_union_trailing,
	927	=> return queryFieldSrc(tree.*, query, file, tree.taggedUnion(node)),
	928	.tagged_union_two, .tagged_union_two_trailing => {
	929	var buffer: [2]Ast.Node.Index = undefined;
	930	return queryFieldSrc(tree.*, query, file, tree.taggedUnionTwo(&buffer, node));
	931	},
	932	.tagged_union_enum_tag,
	933	.tagged_union_enum_tag_trailing,
	934	=> return queryFieldSrc(tree.*, query, file, tree.taggedUnionEnumTag(node)),
	935
	936	else => unreachable,
	937	}
	938	}
	939
901	940	pub fn haveFieldTypes(s: Struct) bool {
902	941	return switch (s.status) {
903	942	.none,
...	...	@@ -1063,6 +1102,33 @@ pub const Union = struct {
1063	1102	};
1064	1103	}
1065	1104
	1105	pub fn fieldSrcLoc(u: Union, gpa: Allocator, query: FieldSrcQuery) SrcLoc {
	1106	@setCold(true);
	1107	const tree = u.owner_decl.getFileScope().getTree(gpa) catch \|err\| {
	1108	// In this case we emit a warning + a less precise source location.
	1109	log.warn("unable to load {s}: {s}", .{
	1110	u.owner_decl.getFileScope().sub_file_path, @errorName(err),
	1111	});
	1112	return u.srcLoc();
	1113	};
	1114	const node = u.owner_decl.relativeToNodeIndex(u.node_offset);
	1115	const node_tags = tree.nodes.items(.tag);
	1116	const file = u.owner_decl.getFileScope();
	1117	switch (node_tags[node]) {
	1118	.container_decl,
	1119	.container_decl_trailing,
	1120	=> return queryFieldSrc(tree.*, query, file, tree.containerDecl(node)),
	1121	.container_decl_two, .container_decl_two_trailing => {
	1122	var buffer: [2]Ast.Node.Index = undefined;
	1123	return queryFieldSrc(tree.*, query, file, tree.containerDeclTwo(&buffer, node));
	1124	},
	1125	.container_decl_arg,
	1126	.container_decl_arg_trailing,
	1127	=> return queryFieldSrc(tree.*, query, file, tree.containerDeclArg(node)),
	1128	else => unreachable,
	1129	}
	1130	}
	1131
1066	1132	pub fn haveFieldTypes(u: Union) bool {
1067	1133	return switch (u.status) {
1068	1134	.none,
...	...	@@ -4662,8 +4728,8 @@ pub fn createAnonymousDeclFromDeclNamed(
4662	4728	new_decl.src_line = src_decl.src_line;
4663	4729	new_decl.ty = typed_value.ty;
4664	4730	new_decl.val = typed_value.val;
4665		new_decl.align_val = Value.initTag(.null_value);
4666		new_decl.linksection_val = Value.initTag(.null_value);
	4731	new_decl.align_val = Value.@"null";
	4732	new_decl.linksection_val = Value.@"null";
4667	4733	new_decl.has_tv = true;
4668	4734	new_decl.analysis = .complete;
4669	4735	new_decl.generation = mod.generation;
...	...	@@ -4905,6 +4971,55 @@ pub const PeerTypeCandidateSrc = union(enum) {
4905	4971	}
4906	4972	};
4907	4973
	4974	const FieldSrcQuery = struct {
	4975	index: usize,
	4976	range: enum { name, type, value, alignment },
	4977	};
	4978
	4979	fn queryFieldSrc(
	4980	tree: Ast,
	4981	query: FieldSrcQuery,
	4982	file_scope: *File,
	4983	container_decl: Ast.full.ContainerDecl,
	4984	) SrcLoc {
	4985	const node_tags = tree.nodes.items(.tag);
	4986	var field_index: usize = 0;
	4987	for (container_decl.ast.members) \|member_node\| {
	4988	const field = switch (node_tags[member_node]) {
	4989	.container_field_init => tree.containerFieldInit(member_node),
	4990	.container_field_align => tree.containerFieldAlign(member_node),
	4991	.container_field => tree.containerField(member_node),
	4992	else => continue,
	4993	};
	4994	if (field_index == query.index) {
	4995	return switch (query.range) {
	4996	.name => .{
	4997	.file_scope = file_scope,
	4998	.parent_decl_node = 0,
	4999	.lazy = .{ .token_abs = field.ast.name_token },
	5000	},
	5001	.type => .{
	5002	.file_scope = file_scope,
	5003	.parent_decl_node = 0,
	5004	.lazy = .{ .node_abs = field.ast.type_expr },
	5005	},
	5006	.value => .{
	5007	.file_scope = file_scope,
	5008	.parent_decl_node = 0,
	5009	.lazy = .{ .node_abs = field.ast.value_expr },
	5010	},
	5011	.alignment => .{
	5012	.file_scope = file_scope,
	5013	.parent_decl_node = 0,
	5014	.lazy = .{ .node_abs = field.ast.align_expr },
	5015	},
	5016	};
	5017	}
	5018	field_index += 1;
	5019	}
	5020	unreachable;
	5021	}
	5022
4908	5023	/// Called from `performAllTheWork`, after all AstGen workers have finished,
4909	5024	/// and before the main semantic analysis loop begins.
4910	5025	pub fn processOutdatedAndDeletedDecls(mod: *Module) !void {

src/Sema.zig+473-103

...	...	@@ -4147,7 +4147,7 @@ fn analyzeCall(
4147	4147	const gpa = sema.gpa;
4148	4148
4149	4149	const is_comptime_call = block.is_comptime or modifier == .compile_time or
4150		func_ty_info.return_type.requiresComptime();
	4150	try sema.typeRequiresComptime(block, func_src, func_ty_info.return_type);
4151	4151	const is_inline_call = is_comptime_call or modifier == .always_inline or
4152	4152	func_ty_info.cc == .Inline;
4153	4153	const result: Air.Inst.Ref = if (is_inline_call) res: {
...	...	@@ -4576,7 +4576,7 @@ fn analyzeCall(
4576	4576	}
4577	4577	} else if (is_anytype) {
4578	4578	const arg_ty = sema.typeOf(arg);
4579		if (arg_ty.requiresComptime()) {
	4579	if (try sema.typeRequiresComptime(block, arg_src, arg_ty)) {
4580	4580	const arg_val = try sema.resolveConstValue(block, arg_src, arg);
4581	4581	const child_arg = try child_sema.addConstant(arg_ty, arg_val);
4582	4582	child_sema.inst_map.putAssumeCapacityNoClobber(inst, child_arg);
...	...	@@ -5430,7 +5430,6 @@ fn funcCommon(
5430	5430	src_locs: Zir.Inst.Func.SrcLocs,
5431	5431	opt_lib_name: ?[]const u8,
5432	5432	) CompileError!Air.Inst.Ref {
5433		const src: LazySrcLoc = .{ .node_offset = src_node_offset };
5434	5433	const ret_ty_src: LazySrcLoc = .{ .node_offset_fn_type_ret_ty = src_node_offset };
5435	5434
5436	5435	// The return type body might be a type expression that depends on generic parameters.
...	...	@@ -5481,11 +5480,22 @@ fn funcCommon(
5481	5480	errdefer if (maybe_inferred_error_set_node) \|node\| sema.gpa.destroy(node);
5482	5481	// Note: no need to errdefer since this will still be in its default state at the end of the function.
5483	5482
	5483	const target = mod.getTarget();
	5484
5484	5485	const fn_ty: Type = fn_ty: {
	5486	const alignment: u32 = if (align_val.tag() == .null_value) 0 else a: {
	5487	const alignment = @intCast(u32, align_val.toUnsignedInt());
	5488	if (alignment == target_util.defaultFunctionAlignment(target)) {
	5489	break :a 0;
	5490	} else {
	5491	break :a alignment;
	5492	}
	5493	};
	5494
5485	5495	// Hot path for some common function types.
5486	5496	// TODO can we eliminate some of these Type tag values? seems unnecessarily complicated.
5487	5497	if (!is_generic and block.params.items.len == 0 and !var_args and
5488		align_val.tag() == .null_value and !inferred_error_set)
	5498	alignment == 0 and !inferred_error_set)
5489	5499	{
5490	5500	if (bare_return_type.zigTypeTag() == .NoReturn and cc == .Unspecified) {
5491	5501	break :fn_ty Type.initTag(.fn_noreturn_no_args);
...	...	@@ -5507,16 +5517,15 @@ fn funcCommon(
5507	5517	const param_types = try sema.arena.alloc(Type, block.params.items.len);
5508	5518	const comptime_params = try sema.arena.alloc(bool, block.params.items.len);
5509	5519	for (block.params.items) \|param, i\| {
	5520	const param_src: LazySrcLoc = .{ .node_offset = src_node_offset }; // TODO better src
5510	5521	param_types[i] = param.ty;
5511		comptime_params[i] = param.is_comptime or param.ty.requiresComptime();
	5522	comptime_params[i] = param.is_comptime or
	5523	try sema.typeRequiresComptime(block, param_src, param.ty);
5512	5524	is_generic = is_generic or comptime_params[i] or param.ty.tag() == .generic_poison;
5513	5525	}
5514	5526
5515		if (align_val.tag() != .null_value) {
5516		return sema.fail(block, src, "TODO implement support for function prototypes to have alignment specified", .{});
5517		}
5518
5519		is_generic = is_generic or bare_return_type.requiresComptime();
	5527	is_generic = is_generic or
	5528	try sema.typeRequiresComptime(block, ret_ty_src, bare_return_type);
5520	5529
5521	5530	const return_type = if (!inferred_error_set or bare_return_type.tag() == .generic_poison)
5522	5531	bare_return_type
...	...	@@ -5537,6 +5546,7 @@ fn funcCommon(
5537	5546	.comptime_params = comptime_params.ptr,
5538	5547	.return_type = return_type,
5539	5548	.cc = cc,
	5549	.alignment = alignment,
5540	5550	.is_var_args = var_args,
5541	5551	.is_generic = is_generic,
5542	5552	});
...	...	@@ -5550,7 +5560,6 @@ fn funcCommon(
5550	5560	lib_name, @errorName(err),
5551	5561	});
5552	5562	};
5553		const target = mod.getTarget();
5554	5563	if (target_util.is_libc_lib_name(target, lib_name)) {
5555	5564	if (!mod.comp.bin_file.options.link_libc) {
5556	5565	return sema.fail(
...	...	@@ -5591,12 +5600,7 @@ fn funcCommon(
5591	5600	}
5592	5601
5593	5602	if (body_inst == 0) {
5594		const fn_ptr_ty = try Type.ptr(sema.arena, .{
5595		.pointee_type = fn_ty,
5596		.@"addrspace" = .generic,
5597		.mutable = false,
5598		});
5599		return sema.addType(fn_ptr_ty);
	5603	return sema.addType(fn_ty);
5600	5604	}
5601	5605
5602	5606	const is_inline = fn_ty.fnCallingConvention() == .Inline;
...	...	@@ -5632,7 +5636,7 @@ fn zirParam(
5632	5636	sema: *Sema,
5633	5637	block: *Block,
5634	5638	inst: Zir.Inst.Index,
5635		is_comptime: bool,
	5639	comptime_syntax: bool,
5636	5640	) CompileError!void {
5637	5641	const inst_data = sema.code.instructions.items(.data)[inst].pl_tok;
5638	5642	const src = inst_data.src();
...	...	@@ -5669,7 +5673,7 @@ fn zirParam(
5669	5673	// insert an anytype parameter.
5670	5674	try block.params.append(sema.gpa, .{
5671	5675	.ty = Type.initTag(.generic_poison),
5672		.is_comptime = is_comptime,
	5676	.is_comptime = comptime_syntax,
5673	5677	});
5674	5678	try sema.inst_map.putNoClobber(sema.gpa, inst, .generic_poison);
5675	5679	return;
...	...	@@ -5677,8 +5681,10 @@ fn zirParam(
5677	5681	else => \|e\| return e,
5678	5682	}
5679	5683	};
	5684	const is_comptime = comptime_syntax or
	5685	try sema.typeRequiresComptime(block, src, param_ty);
5680	5686	if (sema.inst_map.get(inst)) \|arg\| {
5681		if (is_comptime or param_ty.requiresComptime()) {
	5687	if (is_comptime) {
5682	5688	// We have a comptime value for this parameter so it should be elided from the
5683	5689	// function type of the function instruction in this block.
5684	5690	const coerced_arg = try sema.coerce(block, param_ty, arg, src);
...	...	@@ -5692,7 +5698,7 @@ fn zirParam(
5692	5698
5693	5699	try block.params.append(sema.gpa, .{
5694	5700	.ty = param_ty,
5695		.is_comptime = is_comptime or param_ty.requiresComptime(),
	5701	.is_comptime = is_comptime,
5696	5702	});
5697	5703	const result = try sema.addConstant(param_ty, Value.initTag(.generic_poison));
5698	5704	try sema.inst_map.putNoClobber(sema.gpa, inst, result);
...	...	@@ -5702,9 +5708,10 @@ fn zirParamAnytype(
5702	5708	sema: *Sema,
5703	5709	block: *Block,
5704	5710	inst: Zir.Inst.Index,
5705		is_comptime: bool,
	5711	comptime_syntax: bool,
5706	5712	) CompileError!void {
5707	5713	const inst_data = sema.code.instructions.items(.data)[inst].str_tok;
	5714	const src = inst_data.src();
5708	5715	const param_name = inst_data.get(sema.code);
5709	5716
5710	5717	// TODO check if param_name shadows a Decl. This only needs to be done if
...	...	@@ -5713,7 +5720,7 @@ fn zirParamAnytype(
5713	5720
5714	5721	if (sema.inst_map.get(inst)) \|air_ref\| {
5715	5722	const param_ty = sema.typeOf(air_ref);
5716		if (is_comptime or param_ty.requiresComptime()) {
	5723	if (comptime_syntax or try sema.typeRequiresComptime(block, src, param_ty)) {
5717	5724	// We have a comptime value for this parameter so it should be elided from the
5718	5725	// function type of the function instruction in this block.
5719	5726	return;
...	...	@@ -5730,7 +5737,7 @@ fn zirParamAnytype(
5730	5737
5731	5738	try block.params.append(sema.gpa, .{
5732	5739	.ty = Type.initTag(.generic_poison),
5733		.is_comptime = is_comptime,
	5740	.is_comptime = comptime_syntax,
5734	5741	});
5735	5742	try sema.inst_map.put(sema.gpa, inst, .generic_poison);
5736	5743	}
...	...	@@ -11118,8 +11125,7 @@ fn zirIntToPtr(sema: Sema, block: Block, inst: Zir.Inst.Index) CompileError!Ai
11118	11125
11119	11126	const type_src: LazySrcLoc = .{ .node_offset_builtin_call_arg0 = inst_data.src_node };
11120	11127	const type_res = try sema.resolveType(block, src, extra.lhs);
11121		if (type_res.zigTypeTag() != .Pointer)
11122		return sema.fail(block, type_src, "expected pointer, found '{}'", .{type_res});
	11128	try sema.checkPtrType(block, type_src, type_res);
11123	11129	const ptr_align = type_res.ptrAlignment(sema.mod.getTarget());
11124	11130
11125	11131	if (try sema.resolveDefinedValue(block, operand_src, operand_coerced)) \|val\| {
...	...	@@ -11176,16 +11182,8 @@ fn zirPtrCast(sema: Sema, block: Block, inst: Zir.Inst.Index) CompileError!Air
11176	11182	const dest_ty = try sema.resolveType(block, dest_ty_src, extra.lhs);
11177	11183	const operand = sema.resolveInst(extra.rhs);
11178	11184	const operand_ty = sema.typeOf(operand);
11179		if (operand_ty.zigTypeTag() != .Pointer) {
11180		return sema.fail(block, operand_src, "expected pointer, found {s} type '{}'", .{
11181		@tagName(operand_ty.zigTypeTag()), operand_ty,
11182		});
11183		}
11184		if (dest_ty.zigTypeTag() != .Pointer) {
11185		return sema.fail(block, dest_ty_src, "expected pointer, found {s} type '{}'", .{
11186		@tagName(dest_ty.zigTypeTag()), dest_ty,
11187		});
11188		}
	11185	try sema.checkPtrType(block, dest_ty_src, dest_ty);
	11186	try sema.checkPtrOperand(block, operand_src, operand_ty);
11189	11187	return sema.coerceCompatiblePtrs(block, dest_ty, operand, operand_src);
11190	11188	}
11191	11189
...	...	@@ -11264,7 +11262,7 @@ fn zirAlignCast(sema: Sema, block: Block, inst: Zir.Inst.Index) CompileError!A
11264	11262
11265	11263	// TODO in addition to pointers, this instruction is supposed to work for
11266	11264	// pointer-like optionals and slices.
11267		try sema.checkPtrType(block, ptr_src, ptr_ty);
	11265	try sema.checkPtrOperand(block, ptr_src, ptr_ty);
11268	11266
11269	11267	// TODO compile error if the result pointer is comptime known and would have an
11270	11268	// alignment that disagrees with the Decl's alignment.
...	...	@@ -11462,6 +11460,34 @@ fn checkIntType(sema: Sema, block: Block, src: LazySrcLoc, ty: Type) CompileEr
11462	11460	}
11463	11461	}
11464	11462
	11463	fn checkPtrOperand(
	11464	sema: *Sema,
	11465	block: *Block,
	11466	ty_src: LazySrcLoc,
	11467	ty: Type,
	11468	) CompileError!void {
	11469	switch (ty.zigTypeTag()) {
	11470	.Pointer => {},
	11471	.Fn => {
	11472	const msg = msg: {
	11473	const msg = try sema.errMsg(
	11474	block,
	11475	ty_src,
	11476	"expected pointer, found {}",
	11477	.{ty},
	11478	);
	11479	errdefer msg.destroy(sema.gpa);
	11480
	11481	try sema.errNote(block, ty_src, msg, "use '&' to obtain a function pointer", .{});
	11482
	11483	break :msg msg;
	11484	};
	11485	return sema.failWithOwnedErrorMsg(msg);
	11486	},
	11487	else => return sema.fail(block, ty_src, "expected pointer, found '{}'", .{ty}),
	11488	}
	11489	}
	11490
11465	11491	fn checkPtrType(
11466	11492	sema: *Sema,
11467	11493	block: *Block,
...	...	@@ -11470,6 +11496,22 @@ fn checkPtrType(
11470	11496	) CompileError!void {
11471	11497	switch (ty.zigTypeTag()) {
11472	11498	.Pointer => {},
	11499	.Fn => {
	11500	const msg = msg: {
	11501	const msg = try sema.errMsg(
	11502	block,
	11503	ty_src,
	11504	"expected pointer type, found '{}'",
	11505	.{ty},
	11506	);
	11507	errdefer msg.destroy(sema.gpa);
	11508
	11509	try sema.errNote(block, ty_src, msg, "use '*const ' to make a function pointer type", .{});
	11510
	11511	break :msg msg;
	11512	};
	11513	return sema.failWithOwnedErrorMsg(msg);
	11514	},
11473	11515	else => return sema.fail(block, ty_src, "expected pointer type, found '{}'", .{ty}),
11474	11516	}
11475	11517	}
...	...	@@ -12139,20 +12181,14 @@ fn zirMemcpy(sema: Sema, block: Block, inst: Zir.Inst.Index) CompileError!void
12139	12181	const dest_ptr = sema.resolveInst(extra.dest);
12140	12182	const dest_ptr_ty = sema.typeOf(dest_ptr);
12141	12183
12142		if (dest_ptr_ty.zigTypeTag() != .Pointer) {
12143		return sema.fail(block, dest_src, "expected pointer, found '{}'", .{dest_ptr_ty});
12144		}
	12184	try sema.checkPtrOperand(block, dest_src, dest_ptr_ty);
12145	12185	if (dest_ptr_ty.isConstPtr()) {
12146	12186	return sema.fail(block, dest_src, "cannot store through const pointer '{}'", .{dest_ptr_ty});
12147	12187	}
12148	12188
12149	12189	const uncasted_src_ptr = sema.resolveInst(extra.source);
12150	12190	const uncasted_src_ptr_ty = sema.typeOf(uncasted_src_ptr);
12151		if (uncasted_src_ptr_ty.zigTypeTag() != .Pointer) {
12152		return sema.fail(block, src_src, "expected pointer, found '{}'", .{
12153		uncasted_src_ptr_ty,
12154		});
12155		}
	12191	try sema.checkPtrOperand(block, src_src, uncasted_src_ptr_ty);
12156	12192	const src_ptr_info = uncasted_src_ptr_ty.ptrInfo().data;
12157	12193	const wanted_src_ptr_ty = try Type.ptr(sema.arena, .{
12158	12194	.pointee_type = dest_ptr_ty.elemType2(),
...	...	@@ -12203,9 +12239,7 @@ fn zirMemset(sema: Sema, block: Block, inst: Zir.Inst.Index) CompileError!void
12203	12239	const len_src: LazySrcLoc = .{ .node_offset_builtin_call_arg2 = inst_data.src_node };
12204	12240	const dest_ptr = sema.resolveInst(extra.dest);
12205	12241	const dest_ptr_ty = sema.typeOf(dest_ptr);
12206		if (dest_ptr_ty.zigTypeTag() != .Pointer) {
12207		return sema.fail(block, dest_src, "expected pointer, found '{}'", .{dest_ptr_ty});
12208		}
	12242	try sema.checkPtrOperand(block, dest_src, dest_ptr_ty);
12209	12243	if (dest_ptr_ty.isConstPtr()) {
12210	12244	return sema.fail(block, dest_src, "cannot store through const pointer '{}'", .{dest_ptr_ty});
12211	12245	}
...	...	@@ -12487,7 +12521,7 @@ fn zirPrefetch(
12487	12521	const opts_src: LazySrcLoc = .{ .node_offset_builtin_call_arg1 = extra.node };
12488	12522	const options_ty = try sema.getBuiltinType(block, opts_src, "PrefetchOptions");
12489	12523	const ptr = sema.resolveInst(extra.lhs);
12490		try sema.checkPtrType(block, ptr_src, sema.typeOf(ptr));
	12524	try sema.checkPtrOperand(block, ptr_src, sema.typeOf(ptr));
12491	12525	const options = try sema.coerce(block, options_ty, sema.resolveInst(extra.rhs), opts_src);
12492	12526
12493	12527	const rw = try sema.fieldVal(block, opts_src, options, "rw", opts_src);
...	...	@@ -12568,12 +12602,15 @@ fn validateVarType(
12568	12602	.Type,
12569	12603	.Undefined,
12570	12604	.Null,
	12605	.Fn,
12571	12606	=> break,
12572	12607
12573	12608	.Pointer => {
12574	12609	const elem_ty = ty.childType();
12575		if (elem_ty.zigTypeTag() == .Opaque) return;
12576		ty = elem_ty;
	12610	switch (elem_ty.zigTypeTag()) {
	12611	.Opaque, .Fn => return,
	12612	else => ty = elem_ty,
	12613	}
12577	12614	},
12578	12615	.Opaque => if (is_extern) return else break,
12579	12616
...	...	@@ -12586,9 +12623,9 @@ fn validateVarType(
12586	12623
12587	12624	.ErrorUnion => ty = ty.errorUnionPayload(),
12588	12625
12589		.Fn, .Struct, .Union => {
	12626	.Struct, .Union => {
12590	12627	const resolved_ty = try sema.resolveTypeFields(block, src, ty);
12591		if (resolved_ty.requiresComptime()) {
	12628	if (try sema.typeRequiresComptime(block, src, resolved_ty)) {
12592	12629	break;
12593	12630	} else {
12594	12631	return;
...	...	@@ -12596,7 +12633,99 @@ fn validateVarType(
12596	12633	},
12597	12634	} else unreachable; // TODO should not need else unreachable
12598	12635
12599		return sema.fail(block, src, "variable of type '{}' must be const or comptime", .{var_ty});
	12636	const msg = msg: {
	12637	const msg = try sema.errMsg(block, src, "variable of type '{}' must be const or comptime", .{var_ty});
	12638	errdefer msg.destroy(sema.gpa);
	12639
	12640	try sema.explainWhyTypeIsComptime(block, src, msg, src.toSrcLoc(block.src_decl), var_ty);
	12641
	12642	break :msg msg;
	12643	};
	12644	return sema.failWithOwnedErrorMsg(msg);
	12645	}
	12646
	12647	fn explainWhyTypeIsComptime(
	12648	sema: *Sema,
	12649	block: *Block,
	12650	src: LazySrcLoc,
	12651	msg: *Module.ErrorMsg,
	12652	src_loc: Module.SrcLoc,
	12653	ty: Type,
	12654	) CompileError!void {
	12655	const mod = sema.mod;
	12656	switch (ty.zigTypeTag()) {
	12657	.Bool,
	12658	.Int,
	12659	.Float,
	12660	.ErrorSet,
	12661	.Enum,
	12662	.Frame,
	12663	.AnyFrame,
	12664	.Void,
	12665	=> return,
	12666
	12667	.Fn => {
	12668	try mod.errNoteNonLazy(src_loc, msg, "use '*const {}' for a function pointer type", .{
	12669	ty,
	12670	});
	12671	},
	12672
	12673	.Type => {
	12674	try mod.errNoteNonLazy(src_loc, msg, "types are not available at runtime", .{});
	12675	},
	12676
	12677	.BoundFn,
	12678	.ComptimeFloat,
	12679	.ComptimeInt,
	12680	.EnumLiteral,
	12681	.NoReturn,
	12682	.Undefined,
	12683	.Null,
	12684	.Opaque,
	12685	.Optional,
	12686	=> return,
	12687
	12688	.Pointer, .Array, .Vector => {
	12689	try sema.explainWhyTypeIsComptime(block, src, msg, src_loc, ty.elemType());
	12690	},
	12691
	12692	.ErrorUnion => {
	12693	try sema.explainWhyTypeIsComptime(block, src, msg, src_loc, ty.errorUnionPayload());
	12694	},
	12695
	12696	.Struct => {
	12697	if (ty.castTag(.@"struct")) \|payload\| {
	12698	const struct_obj = payload.data;
	12699	for (struct_obj.fields.values()) \|field, i\| {
	12700	const field_src_loc = struct_obj.fieldSrcLoc(sema.gpa, .{
	12701	.index = i,
	12702	.range = .type,
	12703	});
	12704	if (try sema.typeRequiresComptime(block, src, field.ty)) {
	12705	try mod.errNoteNonLazy(field_src_loc, msg, "struct requires comptime because of this field", .{});
	12706	try sema.explainWhyTypeIsComptime(block, src, msg, field_src_loc, field.ty);
	12707	}
	12708	}
	12709	}
	12710	// TODO tuples
	12711	},
	12712
	12713	.Union => {
	12714	if (ty.cast(Type.Payload.Union)) \|payload\| {
	12715	const union_obj = payload.data;
	12716	for (union_obj.fields.values()) \|field, i\| {
	12717	const field_src_loc = union_obj.fieldSrcLoc(sema.gpa, .{
	12718	.index = i,
	12719	.range = .type,
	12720	});
	12721	if (try sema.typeRequiresComptime(block, src, field.ty)) {
	12722	try mod.errNoteNonLazy(field_src_loc, msg, "union requires comptime because of this field", .{});
	12723	try sema.explainWhyTypeIsComptime(block, src, msg, field_src_loc, field.ty);
	12724	}
	12725	}
	12726	}
	12727	},
	12728	}
12600	12729	}
12601	12730
12602	12731	pub const PanicId = enum {
...	...	@@ -13883,6 +14012,10 @@ fn coerce(
13883	14012	{
13884	14013	return sema.coerceCompatiblePtrs(block, dest_ty, inst, inst_src);
13885	14014	}
	14015
	14016	// This will give an extra hint on top of what the bottom of this func would provide.
	14017	try sema.checkPtrOperand(block, dest_ty_src, inst_ty);
	14018	unreachable;
13886	14019	},
13887	14020	.Int, .ComptimeInt => switch (inst_ty.zigTypeTag()) {
13888	14021	.Float, .ComptimeFloat => float: {
...	...	@@ -14683,7 +14816,8 @@ const ComptimePtrLoadKit = struct {
14683	14816	/// The Type of the parent Value.
14684	14817	ty: Type,
14685	14818	/// The starting byte offset of `val` from `root_val`.
14686		byte_offset: usize,
	14819	/// If the type does not have a well-defined memory layout, this is null.
	14820	byte_offset: ?usize,
14687	14821	/// Whether the `root_val` could be mutated by further
14688	14822	/// semantic analysis and a copy must be performed.
14689	14823	is_mutable: bool,
...	...	@@ -14738,12 +14872,24 @@ fn beginComptimePtrLoad(
14738	14872	});
14739	14873	}
14740	14874	const elem_ty = parent.ty.childType();
14741		const elem_size = elem_ty.abiSize(target);
	14875	const byte_offset: ?usize = bo: {
	14876	if (try sema.typeRequiresComptime(block, src, elem_ty)) {
	14877	break :bo null;
	14878	} else {
	14879	if (parent.byte_offset) \|off\| {
	14880	try sema.resolveTypeLayout(block, src, elem_ty);
	14881	const elem_size = elem_ty.abiSize(target);
	14882	break :bo try sema.usizeCast(block, src, off + elem_size * elem_ptr.index);
	14883	} else {
	14884	break :bo null;
	14885	}
	14886	}
	14887	};
14742	14888	return ComptimePtrLoadKit{
14743	14889	.root_val = parent.root_val,
14744	14890	.val = try parent.val.elemValue(sema.arena, elem_ptr.index),
14745	14891	.ty = elem_ty,
14746		.byte_offset = try sema.usizeCast(block, src, parent.byte_offset + elem_size * elem_ptr.index),
	14892	.byte_offset = byte_offset,
14747	14893	.is_mutable = parent.is_mutable,
14748	14894	};
14749	14895	},
...	...	@@ -14768,13 +14914,24 @@ fn beginComptimePtrLoad(
14768	14914	const field_ptr = ptr_val.castTag(.field_ptr).?.data;
14769	14915	const parent = try beginComptimePtrLoad(sema, block, src, field_ptr.container_ptr);
14770	14916	const field_index = @intCast(u32, field_ptr.field_index);
14771		try sema.resolveTypeLayout(block, src, parent.ty);
14772		const field_offset = parent.ty.structFieldOffset(field_index, target);
	14917	const byte_offset: ?usize = bo: {
	14918	if (try sema.typeRequiresComptime(block, src, parent.ty)) {
	14919	break :bo null;
	14920	} else {
	14921	if (parent.byte_offset) \|off\| {
	14922	try sema.resolveTypeLayout(block, src, parent.ty);
	14923	const field_offset = parent.ty.structFieldOffset(field_index, target);
	14924	break :bo try sema.usizeCast(block, src, off + field_offset);
	14925	} else {
	14926	break :bo null;
	14927	}
	14928	}
	14929	};
14773	14930	return ComptimePtrLoadKit{
14774	14931	.root_val = parent.root_val,
14775	14932	.val = try parent.val.fieldValue(sema.arena, field_index),
14776	14933	.ty = parent.ty.structFieldType(field_index),
14777		.byte_offset = try sema.usizeCast(block, src, parent.byte_offset + field_offset),
	14934	.byte_offset = byte_offset,
14778	14935	.is_mutable = parent.is_mutable,
14779	14936	};
14780	14937	},
...	...	@@ -14785,7 +14942,7 @@ fn beginComptimePtrLoad(
14785	14942	.root_val = parent.root_val,
14786	14943	.val = parent.val.castTag(.eu_payload).?.data,
14787	14944	.ty = parent.ty.errorUnionPayload(),
14788		.byte_offset = undefined,
	14945	.byte_offset = null,
14789	14946	.is_mutable = parent.is_mutable,
14790	14947	};
14791	14948	},
...	...	@@ -14796,7 +14953,7 @@ fn beginComptimePtrLoad(
14796	14953	.root_val = parent.root_val,
14797	14954	.val = parent.val.castTag(.opt_payload).?.data,
14798	14955	.ty = try parent.ty.optionalChildAlloc(sema.arena),
14799		.byte_offset = undefined,
	14956	.byte_offset = null,
14800	14957	.is_mutable = parent.is_mutable,
14801	14958	};
14802	14959	},
...	...	@@ -16090,28 +16247,12 @@ fn resolveTypeFields(sema: Sema, block: Block, src: LazySrcLoc, ty: Type) Comp
16090	16247	switch (ty.tag()) {
16091	16248	.@"struct" => {
16092	16249	const struct_obj = ty.castTag(.@"struct").?.data;
16093		switch (struct_obj.status) {
16094		.none => {},
16095		.field_types_wip => {
16096		return sema.fail(block, src, "struct {} depends on itself", .{ty});
16097		},
16098		.have_field_types,
16099		.have_layout,
16100		.layout_wip,
16101		.fully_resolved_wip,
16102		.fully_resolved,
16103		=> return ty,
16104		}
16105
16106		struct_obj.status = .field_types_wip;
16107		try semaStructFields(sema.mod, struct_obj);
16108
16109		if (struct_obj.fields.count() == 0) {
16110		struct_obj.status = .have_layout;
16111		} else {
16112		struct_obj.status = .have_field_types;
16113		}
16114
	16250	try sema.resolveTypeFieldsStruct(block, src, ty, struct_obj);
	16251	return ty;
	16252	},
	16253	.@"union", .union_tagged => {
	16254	const union_obj = ty.cast(Type.Payload.Union).?.data;
	16255	try sema.resolveTypeFieldsUnion(block, src, ty, union_obj);
16115	16256	return ty;
16116	16257	},
16117	16258	.type_info => return sema.resolveBuiltinTypeFields(block, src, "TypeInfo"),
...	...	@@ -16126,29 +16267,63 @@ fn resolveTypeFields(sema: Sema, block: Block, src: LazySrcLoc, ty: Type) Comp
16126	16267	.call_options => return sema.resolveBuiltinTypeFields(block, src, "CallOptions"),
16127	16268	.prefetch_options => return sema.resolveBuiltinTypeFields(block, src, "PrefetchOptions"),
16128	16269
16129		.@"union", .union_tagged => {
16130		const union_obj = ty.cast(Type.Payload.Union).?.data;
16131		switch (union_obj.status) {
16132		.none => {},
16133		.field_types_wip => {
16134		return sema.fail(block, src, "union {} depends on itself", .{ty});
16135		},
16136		.have_field_types,
16137		.have_layout,
16138		.layout_wip,
16139		.fully_resolved_wip,
16140		.fully_resolved,
16141		=> return ty,
16142		}
	16270	else => return ty,
	16271	}
	16272	}
16143	16273
16144		union_obj.status = .field_types_wip;
16145		try semaUnionFields(sema.mod, union_obj);
16146		union_obj.status = .have_field_types;
	16274	fn resolveTypeFieldsStruct(
	16275	sema: *Sema,
	16276	block: *Block,
	16277	src: LazySrcLoc,
	16278	ty: Type,
	16279	struct_obj: *Module.Struct,
	16280	) CompileError!void {
	16281	switch (struct_obj.status) {
	16282	.none => {},
	16283	.field_types_wip => {
	16284	return sema.fail(block, src, "struct {} depends on itself", .{ty});
	16285	},
	16286	.have_field_types,
	16287	.have_layout,
	16288	.layout_wip,
	16289	.fully_resolved_wip,
	16290	.fully_resolved,
	16291	=> return,
	16292	}
16147	16293
16148		return ty;
	16294	struct_obj.status = .field_types_wip;
	16295	try semaStructFields(sema.mod, struct_obj);
	16296
	16297	if (struct_obj.fields.count() == 0) {
	16298	struct_obj.status = .have_layout;
	16299	} else {
	16300	struct_obj.status = .have_field_types;
	16301	}
	16302	}
	16303
	16304	fn resolveTypeFieldsUnion(
	16305	sema: *Sema,
	16306	block: *Block,
	16307	src: LazySrcLoc,
	16308	ty: Type,
	16309	union_obj: *Module.Union,
	16310	) CompileError!void {
	16311	switch (union_obj.status) {
	16312	.none => {},
	16313	.field_types_wip => {
	16314	return sema.fail(block, src, "union {} depends on itself", .{ty});
16149	16315	},
16150		else => return ty,
	16316	.have_field_types,
	16317	.have_layout,
	16318	.layout_wip,
	16319	.fully_resolved_wip,
	16320	.fully_resolved,
	16321	=> return,
16151	16322	}
	16323
	16324	union_obj.status = .field_types_wip;
	16325	try semaUnionFields(sema.mod, union_obj);
	16326	union_obj.status = .have_field_types;
16152	16327	}
16153	16328
16154	16329	fn resolveBuiltinTypeFields(
...	...	@@ -17295,3 +17470,198 @@ fn typePtrOrOptionalPtrTy(
17295	17470	else => return null,
17296	17471	}
17297	17472	}
	17473
	17474	/// Anything that reports hasCodeGenBits() false returns false here as well.
	17475	/// `generic_poison` will return false.
	17476	/// This function returns false negatives when structs and unions are having their
	17477	/// field types resolved.
	17478	fn typeRequiresComptime(sema: Sema, block: Block, src: LazySrcLoc, ty: Type) CompileError!bool {
	17479	return switch (ty.tag()) {
	17480	.u1,
	17481	.u8,
	17482	.i8,
	17483	.u16,
	17484	.i16,
	17485	.u32,
	17486	.i32,
	17487	.u64,
	17488	.i64,
	17489	.u128,
	17490	.i128,
	17491	.usize,
	17492	.isize,
	17493	.c_short,
	17494	.c_ushort,
	17495	.c_int,
	17496	.c_uint,
	17497	.c_long,
	17498	.c_ulong,
	17499	.c_longlong,
	17500	.c_ulonglong,
	17501	.c_longdouble,
	17502	.f16,
	17503	.f32,
	17504	.f64,
	17505	.f128,
	17506	.anyopaque,
	17507	.bool,
	17508	.void,
	17509	.anyerror,
	17510	.noreturn,
	17511	.@"anyframe",
	17512	.@"null",
	17513	.@"undefined",
	17514	.atomic_order,
	17515	.atomic_rmw_op,
	17516	.calling_convention,
	17517	.address_space,
	17518	.float_mode,
	17519	.reduce_op,
	17520	.call_options,
	17521	.prefetch_options,
	17522	.export_options,
	17523	.extern_options,
	17524	.manyptr_u8,
	17525	.manyptr_const_u8,
	17526	.manyptr_const_u8_sentinel_0,
	17527	.const_slice_u8,
	17528	.const_slice_u8_sentinel_0,
	17529	.anyerror_void_error_union,
	17530	.empty_struct_literal,
	17531	.empty_struct,
	17532	.error_set,
	17533	.error_set_single,
	17534	.error_set_inferred,
	17535	.error_set_merged,
	17536	.@"opaque",
	17537	.generic_poison,
	17538	.array_u8,
	17539	.array_u8_sentinel_0,
	17540	.int_signed,
	17541	.int_unsigned,
	17542	.enum_simple,
	17543	=> false,
	17544
	17545	.single_const_pointer_to_comptime_int,
	17546	.type,
	17547	.comptime_int,
	17548	.comptime_float,
	17549	.enum_literal,
	17550	.type_info,
	17551	// These are function bodies, not function pointers.
	17552	.fn_noreturn_no_args,
	17553	.fn_void_no_args,
	17554	.fn_naked_noreturn_no_args,
	17555	.fn_ccc_void_no_args,
	17556	.function,
	17557	=> true,
	17558
	17559	.var_args_param => unreachable,
	17560	.inferred_alloc_mut => unreachable,
	17561	.inferred_alloc_const => unreachable,
	17562	.bound_fn => unreachable,
	17563
	17564	.array,
	17565	.array_sentinel,
	17566	.vector,
	17567	=> return sema.typeRequiresComptime(block, src, ty.childType()),
	17568
	17569	.pointer,
	17570	.single_const_pointer,
	17571	.single_mut_pointer,
	17572	.many_const_pointer,
	17573	.many_mut_pointer,
	17574	.c_const_pointer,
	17575	.c_mut_pointer,
	17576	.const_slice,
	17577	.mut_slice,
	17578	=> {
	17579	const child_ty = ty.childType();
	17580	if (child_ty.zigTypeTag() == .Fn) {
	17581	return false;
	17582	} else {
	17583	return sema.typeRequiresComptime(block, src, child_ty);
	17584	}
	17585	},
	17586
	17587	.optional,
	17588	.optional_single_mut_pointer,
	17589	.optional_single_const_pointer,
	17590	=> {
	17591	var buf: Type.Payload.ElemType = undefined;
	17592	return sema.typeRequiresComptime(block, src, ty.optionalChild(&buf));
	17593	},
	17594
	17595	.tuple => {
	17596	const tuple = ty.castTag(.tuple).?.data;
	17597	for (tuple.types) \|field_ty\| {
	17598	if (try sema.typeRequiresComptime(block, src, field_ty)) {
	17599	return true;
	17600	}
	17601	}
	17602	return false;
	17603	},
	17604
	17605	.@"struct" => {
	17606	const struct_obj = ty.castTag(.@"struct").?.data;
	17607	switch (struct_obj.requires_comptime) {
	17608	.no, .wip => return false,
	17609	.yes => return true,
	17610	.unknown => {
	17611	if (struct_obj.status == .field_types_wip)
	17612	return false;
	17613
	17614	try sema.resolveTypeFieldsStruct(block, src, ty, struct_obj);
	17615
	17616	struct_obj.requires_comptime = .wip;
	17617	for (struct_obj.fields.values()) \|field\| {
	17618	if (try sema.typeRequiresComptime(block, src, field.ty)) {
	17619	struct_obj.requires_comptime = .yes;
	17620	return true;
	17621	}
	17622	}
	17623	struct_obj.requires_comptime = .no;
	17624	return false;
	17625	},
	17626	}
	17627	},
	17628
	17629	.@"union", .union_tagged => {
	17630	const union_obj = ty.cast(Type.Payload.Union).?.data;
	17631	switch (union_obj.requires_comptime) {
	17632	.no, .wip => return false,
	17633	.yes => return true,
	17634	.unknown => {
	17635	if (union_obj.status == .field_types_wip)
	17636	return false;
	17637
	17638	try sema.resolveTypeFieldsUnion(block, src, ty, union_obj);
	17639
	17640	union_obj.requires_comptime = .wip;
	17641	for (union_obj.fields.values()) \|field\| {
	17642	if (try sema.typeRequiresComptime(block, src, field.ty)) {
	17643	union_obj.requires_comptime = .yes;
	17644	return true;
	17645	}
	17646	}
	17647	union_obj.requires_comptime = .no;
	17648	return false;
	17649	},
	17650	}
	17651	},
	17652
	17653	.error_union => return sema.typeRequiresComptime(block, src, ty.errorUnionPayload()),
	17654	.anyframe_T => {
	17655	const child_ty = ty.castTag(.anyframe_T).?.data;
	17656	return sema.typeRequiresComptime(block, src, child_ty);
	17657	},
	17658	.enum_numbered => {
	17659	const tag_ty = ty.castTag(.enum_numbered).?.data.tag_ty;
	17660	return sema.typeRequiresComptime(block, src, tag_ty);
	17661	},
	17662	.enum_full, .enum_nonexhaustive => {
	17663	const tag_ty = ty.cast(Type.Payload.EnumFull).?.data.tag_ty;
	17664	return sema.typeRequiresComptime(block, src, tag_ty);
	17665	},
	17666	};
	17667	}

src/codegen/llvm.zig+4

...	...	@@ -725,6 +725,10 @@ pub const DeclGen = struct {
725	725	llvm_fn.setFunctionCallConv(toLlvmCallConv(fn_info.cc, target));
726	726	}
727	727
	728	if (fn_info.alignment != 0) {
	729	llvm_fn.setAlignment(fn_info.alignment);
	730	}
	731
728	732	// Function attributes that are independent of analysis results of the function body.
729	733	dg.addCommonFnAttributes(llvm_fn);
730	734

src/target.zig+9

...	...	@@ -637,3 +637,12 @@ pub fn llvmMachineAbi(target: std.Target) ?[:0]const u8 {
637	637	else => return null,
638	638	}
639	639	}
	640
	641	pub fn defaultFunctionAlignment(target: std.Target) u32 {
	642	return switch (target.cpu.arch) {
	643	.arm, .armeb => 4,
	644	.aarch64, .aarch64_32, .aarch64_be => 4,
	645	.riscv64 => 2,
	646	else => 1,
	647	};
	648	}

src/type.zig+48-181

...	...	@@ -5,6 +5,7 @@ const Allocator = std.mem.Allocator;
5	5	const Target = std.Target;
6	6	const Module = @import("Module.zig");
7	7	const log = std.log.scoped(.Type);
	8	const target_util = @import("target.zig");
8	9
9	10	const file_struct = @This();
10	11
...	...	@@ -577,21 +578,36 @@ pub const Type = extern union {
577	578	}
578	579	},
579	580	.Fn => {
580		if (!a.fnReturnType().eql(b.fnReturnType()))
	581	const a_info = a.fnInfo();
	582	const b_info = b.fnInfo();
	583
	584	if (!eql(a_info.return_type, b_info.return_type))
581	585	return false;
582		if (a.fnCallingConvention() != b.fnCallingConvention())
	586
	587	if (a_info.cc != b_info.cc)
583	588	return false;
584		const a_param_len = a.fnParamLen();
585		const b_param_len = b.fnParamLen();
586		if (a_param_len != b_param_len)
	589
	590	if (a_info.param_types.len != b_info.param_types.len)
587	591	return false;
588		var i: usize = 0;
589		while (i < a_param_len) : (i += 1) {
590		if (!a.fnParamType(i).eql(b.fnParamType(i)))
	592
	593	for (a_info.param_types) \|a_param_ty, i\| {
	594	const b_param_ty = b_info.param_types[i];
	595	if (!eql(a_param_ty, b_param_ty))
	596	return false;
	597
	598	if (a_info.comptime_params[i] != b_info.comptime_params[i])
591	599	return false;
592	600	}
593		if (a.fnIsVarArgs() != b.fnIsVarArgs())
	601
	602	if (a_info.alignment != b_info.alignment)
	603	return false;
	604
	605	if (a_info.is_var_args != b_info.is_var_args)
594	606	return false;
	607
	608	if (a_info.is_generic != b_info.is_generic)
	609	return false;
	610
595	611	return true;
596	612	},
597	613	.Optional => {
...	...	@@ -686,6 +702,7 @@ pub const Type = extern union {
686	702	return false;
687	703	},
688	704	.Float => return a.tag() == b.tag(),
	705
689	706	.BoundFn,
690	707	.Frame,
691	708	=> std.debug.panic("TODO implement Type equality comparison of {} and {}", .{ a, b }),
...	...	@@ -937,6 +954,7 @@ pub const Type = extern union {
937	954	.return_type = try payload.return_type.copy(allocator),
938	955	.param_types = param_types,
939	956	.cc = payload.cc,
	957	.alignment = payload.alignment,
940	958	.is_var_args = payload.is_var_args,
941	959	.is_generic = payload.is_generic,
942	960	.comptime_params = comptime_params.ptr,
...	...	@@ -1114,9 +1132,15 @@ pub const Type = extern union {
1114	1132	}
1115	1133	try writer.writeAll("...");
1116	1134	}
1117		try writer.writeAll(") callconv(.");
1118		try writer.writeAll(@tagName(payload.cc));
1119	1135	try writer.writeAll(") ");
	1136	if (payload.cc != .Unspecified) {
	1137	try writer.writeAll("callconv(.");
	1138	try writer.writeAll(@tagName(payload.cc));
	1139	try writer.writeAll(") ");
	1140	}
	1141	if (payload.alignment != 0) {
	1142	try writer.print("align({d}) ", .{payload.alignment});
	1143	}
1120	1144	ty = payload.return_type;
1121	1145	continue;
1122	1146	},
...	...	@@ -1423,170 +1447,6 @@ pub const Type = extern union {
1423	1447	}
1424	1448	}
1425	1449
1426		/// Anything that reports hasCodeGenBits() false returns false here as well.
1427		/// `generic_poison` will return false.
1428		pub fn requiresComptime(ty: Type) bool {
1429		return switch (ty.tag()) {
1430		.u1,
1431		.u8,
1432		.i8,
1433		.u16,
1434		.i16,
1435		.u32,
1436		.i32,
1437		.u64,
1438		.i64,
1439		.u128,
1440		.i128,
1441		.usize,
1442		.isize,
1443		.c_short,
1444		.c_ushort,
1445		.c_int,
1446		.c_uint,
1447		.c_long,
1448		.c_ulong,
1449		.c_longlong,
1450		.c_ulonglong,
1451		.c_longdouble,
1452		.f16,
1453		.f32,
1454		.f64,
1455		.f128,
1456		.anyopaque,
1457		.bool,
1458		.void,
1459		.anyerror,
1460		.noreturn,
1461		.@"anyframe",
1462		.@"null",
1463		.@"undefined",
1464		.atomic_order,
1465		.atomic_rmw_op,
1466		.calling_convention,
1467		.address_space,
1468		.float_mode,
1469		.reduce_op,
1470		.call_options,
1471		.prefetch_options,
1472		.export_options,
1473		.extern_options,
1474		.manyptr_u8,
1475		.manyptr_const_u8,
1476		.manyptr_const_u8_sentinel_0,
1477		.fn_noreturn_no_args,
1478		.fn_void_no_args,
1479		.fn_naked_noreturn_no_args,
1480		.fn_ccc_void_no_args,
1481		.const_slice_u8,
1482		.const_slice_u8_sentinel_0,
1483		.anyerror_void_error_union,
1484		.empty_struct_literal,
1485		.function,
1486		.empty_struct,
1487		.error_set,
1488		.error_set_single,
1489		.error_set_inferred,
1490		.error_set_merged,
1491		.@"opaque",
1492		.generic_poison,
1493		.array_u8,
1494		.array_u8_sentinel_0,
1495		.int_signed,
1496		.int_unsigned,
1497		.enum_simple,
1498		=> false,
1499
1500		.single_const_pointer_to_comptime_int,
1501		.type,
1502		.comptime_int,
1503		.comptime_float,
1504		.enum_literal,
1505		.type_info,
1506		=> true,
1507
1508		.var_args_param => unreachable,
1509		.inferred_alloc_mut => unreachable,
1510		.inferred_alloc_const => unreachable,
1511		.bound_fn => unreachable,
1512
1513		.array,
1514		.array_sentinel,
1515		.vector,
1516		.pointer,
1517		.single_const_pointer,
1518		.single_mut_pointer,
1519		.many_const_pointer,
1520		.many_mut_pointer,
1521		.c_const_pointer,
1522		.c_mut_pointer,
1523		.const_slice,
1524		.mut_slice,
1525		=> return requiresComptime(childType(ty)),
1526
1527		.optional,
1528		.optional_single_mut_pointer,
1529		.optional_single_const_pointer,
1530		=> {
1531		var buf: Payload.ElemType = undefined;
1532		return requiresComptime(optionalChild(ty, &buf));
1533		},
1534
1535		.tuple => {
1536		const tuple = ty.castTag(.tuple).?.data;
1537		for (tuple.types) \|field_ty\| {
1538		if (requiresComptime(field_ty)) {
1539		return true;
1540		}
1541		}
1542		return false;
1543		},
1544
1545		.@"struct" => {
1546		const struct_obj = ty.castTag(.@"struct").?.data;
1547		switch (struct_obj.requires_comptime) {
1548		.no, .wip => return false,
1549		.yes => return true,
1550		.unknown => {
1551		struct_obj.requires_comptime = .wip;
1552		for (struct_obj.fields.values()) \|field\| {
1553		if (requiresComptime(field.ty)) {
1554		struct_obj.requires_comptime = .yes;
1555		return true;
1556		}
1557		}
1558		struct_obj.requires_comptime = .no;
1559		return false;
1560		},
1561		}
1562		},
1563
1564		.@"union", .union_tagged => {
1565		const union_obj = ty.cast(Payload.Union).?.data;
1566		switch (union_obj.requires_comptime) {
1567		.no, .wip => return false,
1568		.yes => return true,
1569		.unknown => {
1570		union_obj.requires_comptime = .wip;
1571		for (union_obj.fields.values()) \|field\| {
1572		if (requiresComptime(field.ty)) {
1573		union_obj.requires_comptime = .yes;
1574		return true;
1575		}
1576		}
1577		union_obj.requires_comptime = .no;
1578		return false;
1579		},
1580		}
1581		},
1582
1583		.error_union => return requiresComptime(errorUnionPayload(ty)),
1584		.anyframe_T => return ty.castTag(.anyframe_T).?.data.requiresComptime(),
1585		.enum_numbered => return ty.castTag(.enum_numbered).?.data.tag_ty.requiresComptime(),
1586		.enum_full, .enum_nonexhaustive => return ty.cast(Payload.EnumFull).?.data.tag_ty.requiresComptime(),
1587		};
1588		}
1589
1590	1450	pub fn toValue(self: Type, allocator: Allocator) Allocator.Error!Value {
1591	1451	switch (self.tag()) {
1592	1452	.u1 => return Value.initTag(.u1_type),
...	...	@@ -1918,12 +1778,13 @@ pub const Type = extern union {
1918	1778	.fn_void_no_args, // represents machine code; not a pointer
1919	1779	.fn_naked_noreturn_no_args, // represents machine code; not a pointer
1920	1780	.fn_ccc_void_no_args, // represents machine code; not a pointer
1921		.function, // represents machine code; not a pointer
1922		=> return switch (target.cpu.arch) {
1923		.arm, .armeb => 4,
1924		.aarch64, .aarch64_32, .aarch64_be => 4,
1925		.riscv64 => 2,
1926		else => 1,
	1781	=> return target_util.defaultFunctionAlignment(target),
	1782
	1783	// represents machine code; not a pointer
	1784	.function => {
	1785	const alignment = self.castTag(.function).?.data.alignment;
	1786	if (alignment != 0) return alignment;
	1787	return target_util.defaultFunctionAlignment(target);
1927	1788	},
1928	1789
1929	1790	.i16, .u16 => return 2,
...	...	@@ -3424,6 +3285,7 @@ pub const Type = extern union {
3424	3285	.comptime_params = undefined,
3425	3286	.return_type = initTag(.noreturn),
3426	3287	.cc = .Unspecified,
	3288	.alignment = 0,
3427	3289	.is_var_args = false,
3428	3290	.is_generic = false,
3429	3291	},
...	...	@@ -3432,6 +3294,7 @@ pub const Type = extern union {
3432	3294	.comptime_params = undefined,
3433	3295	.return_type = initTag(.void),
3434	3296	.cc = .Unspecified,
	3297	.alignment = 0,
3435	3298	.is_var_args = false,
3436	3299	.is_generic = false,
3437	3300	},
...	...	@@ -3440,6 +3303,7 @@ pub const Type = extern union {
3440	3303	.comptime_params = undefined,
3441	3304	.return_type = initTag(.noreturn),
3442	3305	.cc = .Naked,
	3306	.alignment = 0,
3443	3307	.is_var_args = false,
3444	3308	.is_generic = false,
3445	3309	},
...	...	@@ -3448,6 +3312,7 @@ pub const Type = extern union {
3448	3312	.comptime_params = undefined,
3449	3313	.return_type = initTag(.void),
3450	3314	.cc = .C,
	3315	.alignment = 0,
3451	3316	.is_var_args = false,
3452	3317	.is_generic = false,
3453	3318	},
...	...	@@ -4572,6 +4437,8 @@ pub const Type = extern union {
4572	4437	param_types: []Type,
4573	4438	comptime_params: [*]bool,
4574	4439	return_type: Type,
	4440	/// If zero use default target function code alignment.
	4441	alignment: u32,
4575	4442	cc: std.builtin.CallingConvention,
4576	4443	is_var_args: bool,
4577	4444	is_generic: bool,

src/value.zig+10-2

...	...	@@ -1520,6 +1520,11 @@ pub const Value = extern union {
1520	1520	}
1521	1521	return true;
1522	1522	},
	1523	.function => {
	1524	const a_payload = a.castTag(.function).?.data;
	1525	const b_payload = b.castTag(.function).?.data;
	1526	return a_payload == b_payload;
	1527	},
1523	1528	else => {},
1524	1529	}
1525	1530	} else if (a_tag == .null_value or b_tag == .null_value) {
...	...	@@ -1573,6 +1578,7 @@ pub const Value = extern union {
1573	1578	pub fn hash(val: Value, ty: Type, hasher: *std.hash.Wyhash) void {
1574	1579	const zig_ty_tag = ty.zigTypeTag();
1575	1580	std.hash.autoHash(hasher, zig_ty_tag);
	1581	if (val.isUndef()) return;
1576	1582
1577	1583	switch (zig_ty_tag) {
1578	1584	.BoundFn => unreachable, // TODO remove this from the language
...	...	@@ -1694,7 +1700,8 @@ pub const Value = extern union {
1694	1700	union_obj.val.hash(active_field_ty, hasher);
1695	1701	},
1696	1702	.Fn => {
1697		@panic("TODO implement hashing function values");
	1703	const func = val.castTag(.function).?.data;
	1704	return std.hash.autoHash(hasher, func.owner_decl);
1698	1705	},
1699	1706	.Frame => {
1700	1707	@panic("TODO implement hashing frame values");
...	...	@@ -1703,7 +1710,8 @@ pub const Value = extern union {
1703	1710	@panic("TODO implement hashing anyframe values");
1704	1711	},
1705	1712	.EnumLiteral => {
1706		@panic("TODO implement hashing enum literal values");
	1713	const bytes = val.castTag(.enum_literal).?.data;
	1714	hasher.update(bytes);
1707	1715	},
1708	1716	}
1709	1717	}

test/behavior.zig+9-12

...	...	@@ -2,22 +2,23 @@ const builtin = @import("builtin");
2	2
3	3	test {
4	4	// Tests that pass for stage1, llvm backend, C backend, wasm backend, arm backend and x86_64 backend.
	5	_ = @import("behavior/align.zig");
	6	_ = @import("behavior/array.zig");
	7	_ = @import("behavior/bool.zig");
	8	_ = @import("behavior/bugs/655.zig");
	9	_ = @import("behavior/bugs/679.zig");
5	10	_ = @import("behavior/bugs/1111.zig");
6	11	_ = @import("behavior/bugs/2346.zig");
7		_ = @import("behavior/slice_sentinel_comptime.zig");
8		_ = @import("behavior/bugs/679.zig");
9	12	_ = @import("behavior/bugs/6850.zig");
	13	_ = @import("behavior/cast.zig");
	14	_ = @import("behavior/comptime_memory.zig");
10	15	_ = @import("behavior/fn_in_struct_in_comptime.zig");
11	16	_ = @import("behavior/hasdecl.zig");
12	17	_ = @import("behavior/hasfield.zig");
13	18	_ = @import("behavior/prefetch.zig");
14	19	_ = @import("behavior/pub_enum.zig");
	20	_ = @import("behavior/slice_sentinel_comptime.zig");
15	21	_ = @import("behavior/type.zig");
16		_ = @import("behavior/bugs/655.zig");
17		_ = @import("behavior/bool.zig");
18		_ = @import("behavior/align.zig");
19		_ = @import("behavior/array.zig");
20		_ = @import("behavior/cast.zig");
21	22
22	23	if (builtin.zig_backend != .stage2_arm and builtin.zig_backend != .stage2_x86_64) {
23	24	// Tests that pass for stage1, llvm backend, C backend, wasm backend.
...	...	@@ -113,11 +114,7 @@ test {
113	114	_ = @import("behavior/switch.zig");
114	115	_ = @import("behavior/widening.zig");
115	116
116		if (builtin.zig_backend != .stage1) {
117		// When all comptime_memory.zig tests pass, #9646 can be closed.
118		// _ = @import("behavior/comptime_memory.zig");
119		_ = @import("behavior/slice_stage2.zig");
120		} else {
	117	if (builtin.zig_backend == .stage1) {
121	118	// Tests that only pass for the stage1 backend.
122	119	_ = @import("behavior/align_stage1.zig");
123	120	if (builtin.os.tag != .wasi) {

test/behavior/align.zig+20

...	...	@@ -181,3 +181,23 @@ test "page aligned array on stack" {
181	181	try expect(number1 == 42);
182	182	try expect(number2 == 43);
183	183	}
	184
	185	fn derp() align(@sizeOf(usize) * 2) i32 {
	186	return 1234;
	187	}
	188	fn noop1() align(1) void {}
	189	fn noop4() align(4) void {}
	190
	191	test "function alignment" {
	192	// function alignment is a compile error on wasm32/wasm64
	193	if (native_arch == .wasm32 or native_arch == .wasm64) return error.SkipZigTest;
	194
	195	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
	196	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
	197
	198	try expect(derp() == 1234);
	199	try expect(@TypeOf(noop1) == fn () align(1) void);
	200	try expect(@TypeOf(noop4) == fn () align(4) void);
	201	noop1();
	202	noop4();
	203	}

test/behavior/align_stage1.zig-17

...	...	@@ -3,23 +3,6 @@ const expect = std.testing.expect;
3	3	const builtin = @import("builtin");
4	4	const native_arch = builtin.target.cpu.arch;
5	5
6		fn derp() align(@sizeOf(usize) * 2) i32 {
7		return 1234;
8		}
9		fn noop1() align(1) void {}
10		fn noop4() align(4) void {}
11
12		test "function alignment" {
13		// function alignment is a compile error on wasm32/wasm64
14		if (native_arch == .wasm32 or native_arch == .wasm64) return error.SkipZigTest;
15
16		try expect(derp() == 1234);
17		try expect(@TypeOf(noop1) == fn () align(1) void);
18		try expect(@TypeOf(noop4) == fn () align(4) void);
19		noop1();
20		noop4();
21		}
22
23	6	test "implicitly decreasing fn alignment" {
24	7	// function alignment is a compile error on wasm32/wasm64
25	8	if (native_arch == .wasm32 or native_arch == .wasm64) return error.SkipZigTest;

test/behavior/basic.zig+3-1

...	...	@@ -259,6 +259,8 @@ fn fB() []const u8 {
259	259	}
260	260
261	261	test "call function pointer in struct" {
	262	if (builtin.zig_backend == .stage1) return error.SkipZigTest;
	263
262	264	try expect(mem.eql(u8, f3(true), "a"));
263	265	try expect(mem.eql(u8, f3(false), "b"));
264	266	}
...	...	@@ -276,7 +278,7 @@ fn f3(x: bool) []const u8 {
276	278	}
277	279
278	280	const FnPtrWrapper = struct {
279		fn_ptr: fn () []const u8,
	281	fn_ptr: *const fn () []const u8,
280	282	};
281	283
282	284	test "const ptr from var variable" {

test/behavior/basic_llvm.zig+3-1

...	...	@@ -205,9 +205,11 @@ test "multiline string literal is null terminated" {
205	205	}
206	206
207	207	test "self reference through fn ptr field" {
	208	if (builtin.zig_backend == .stage1) return error.SkipZigTest;
	209
208	210	const S = struct {
209	211	const A = struct {
210		f: fn (A) u8,
	212	f: *const fn (A) u8,
211	213	};
212	214
213	215	fn foo(a: A) u8 {

test/behavior/bugs/1500.zig+1-1

...	...	@@ -2,7 +2,7 @@ const A = struct {
2	2	b: B,
3	3	};
4	4
5		const B = fn (A) void;
	5	const B = *const fn (A) void;
6	6
7	7	test "allow these dependencies" {
8	8	var a: A = undefined;

test/behavior/bugs/3112.zig+4-1

...	...	@@ -1,9 +1,10 @@
	1	const builtin = @import("builtin");
1	2	const std = @import("std");
2	3	const expect = std.testing.expect;
3	4
4	5	const State = struct {
5	6	const Self = @This();
6		enter: fn (previous: ?Self) void,
	7	enter: *const fn (previous: ?Self) void,
7	8	};
8	9
9	10	fn prev(p: ?State) void {
...	...	@@ -11,6 +12,8 @@ fn prev(p: ?State) void {
11	12	}
12	13
13	14	test "zig test crash" {
	15	if (builtin.zig_backend == .stage1) return error.SkipZigTest;
	16
14	17	var global: State = undefined;
15	18	global.enter = prev;
16	19	global.enter(null);

test/behavior/cast_llvm.zig+4-2

...	...	@@ -47,12 +47,14 @@ fn incrementVoidPtrArray(array: ?*anyopaque, len: usize) void {
47	47	}
48	48
49	49	test "compile time int to ptr of function" {
	50	if (builtin.zig_backend == .stage1) return error.SkipZigTest;
50	51	if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .aarch64) return error.SkipZigTest; // TODO
	52
51	53	try foobar(FUNCTION_CONSTANT);
52	54	}
53	55
54	56	pub const FUNCTION_CONSTANT = @intToPtr(PFN_void, maxInt(usize));
55		pub const PFN_void = fn (*anyopaque) callconv(.C) void;
	57	pub const PFN_void = const fn (anyopaque) callconv(.C) void;
56	58
57	59	fn foobar(func: PFN_void) !void {
58	60	try std.testing.expect(@ptrToInt(func) == maxInt(usize));
...	...	@@ -154,7 +156,7 @@ test "implicit cast *[0]T to E![]const u8" {
154	156
155	157	var global_array: [4]u8 = undefined;
156	158	test "cast from array reference to fn" {
157		const f = @ptrCast(fn () callconv(.C) void, &global_array);
	159	const f = @ptrCast(*const fn () callconv(.C) void, &global_array);
158	160	try expect(@ptrToInt(f) == @ptrToInt(&global_array));
159	161	}
160	162

test/behavior/comptime_memory.zig+98-1

...	...	@@ -1,8 +1,15 @@
1		const endian = @import("builtin").cpu.arch.endian();
	1	const builtin = @import("builtin");
	2	const endian = builtin.cpu.arch.endian();
2	3	const testing = @import("std").testing;
3	4	const ptr_size = @sizeOf(usize);
4	5
5	6	test "type pun signed and unsigned as single pointer" {
	7	if (builtin.zig_backend == .stage1) return error.SkipZigTest;
	8	if (builtin.zig_backend != .stage1) {
	9	// TODO https://github.com/ziglang/zig/issues/9646
	10	return error.SkipZigTest;
	11	}
	12
6	13	comptime {
7	14	var x: u32 = 0;
8	15	const y = @ptrCast(*i32, &x);
...	...	@@ -12,6 +19,12 @@ test "type pun signed and unsigned as single pointer" {
12	19	}
13	20
14	21	test "type pun signed and unsigned as many pointer" {
	22	if (builtin.zig_backend == .stage1) return error.SkipZigTest;
	23	if (builtin.zig_backend != .stage1) {
	24	// TODO https://github.com/ziglang/zig/issues/9646
	25	return error.SkipZigTest;
	26	}
	27
15	28	comptime {
16	29	var x: u32 = 0;
17	30	const y = @ptrCast([*]i32, &x);
...	...	@@ -21,6 +34,12 @@ test "type pun signed and unsigned as many pointer" {
21	34	}
22	35
23	36	test "type pun signed and unsigned as array pointer" {
	37	if (builtin.zig_backend == .stage1) return error.SkipZigTest;
	38	if (builtin.zig_backend != .stage1) {
	39	// TODO https://github.com/ziglang/zig/issues/9646
	40	return error.SkipZigTest;
	41	}
	42
24	43	comptime {
25	44	var x: u32 = 0;
26	45	const y = @ptrCast(*[1]i32, &x);
...	...	@@ -30,6 +49,12 @@ test "type pun signed and unsigned as array pointer" {
30	49	}
31	50
32	51	test "type pun signed and unsigned as offset many pointer" {
	52	if (builtin.zig_backend == .stage1) return error.SkipZigTest;
	53	if (builtin.zig_backend != .stage1) {
	54	// TODO https://github.com/ziglang/zig/issues/9646
	55	return error.SkipZigTest;
	56	}
	57
33	58	comptime {
34	59	var x: u32 = 0;
35	60	var y = @ptrCast([*]i32, &x);
...	...	@@ -40,6 +65,12 @@ test "type pun signed and unsigned as offset many pointer" {
40	65	}
41	66
42	67	test "type pun signed and unsigned as array pointer" {
	68	if (builtin.zig_backend == .stage1) return error.SkipZigTest;
	69	if (builtin.zig_backend != .stage1) {
	70	// TODO https://github.com/ziglang/zig/issues/9646
	71	return error.SkipZigTest;
	72	}
	73
43	74	comptime {
44	75	var x: u32 = 0;
45	76	const y = @ptrCast([*]i32, &x) - 10;
...	...	@@ -50,6 +81,12 @@ test "type pun signed and unsigned as array pointer" {
50	81	}
51	82
52	83	test "type pun value and struct" {
	84	if (builtin.zig_backend == .stage1) return error.SkipZigTest;
	85	if (builtin.zig_backend != .stage1) {
	86	// TODO https://github.com/ziglang/zig/issues/9646
	87	return error.SkipZigTest;
	88	}
	89
53	90	comptime {
54	91	const StructOfU32 = extern struct { x: u32 };
55	92	var inst: StructOfU32 = .{ .x = 0 };
...	...	@@ -64,6 +101,12 @@ fn bigToNativeEndian(comptime T: type, v: T) T {
64	101	return if (endian == .Big) v else @byteSwap(T, v);
65	102	}
66	103	test "type pun endianness" {
	104	if (builtin.zig_backend == .stage1) return error.SkipZigTest;
	105	if (builtin.zig_backend != .stage1) {
	106	// TODO https://github.com/ziglang/zig/issues/9646
	107	return error.SkipZigTest;
	108	}
	109
67	110	comptime {
68	111	const StructOfBytes = extern struct { x: [4]u8 };
69	112	var inst: StructOfBytes = .{ .x = [4]u8{ 0, 0, 0, 0 } };
...	...	@@ -155,6 +198,12 @@ fn doTypePunBitsTest(as_bits: *Bits) !void {
155	198	}
156	199
157	200	test "type pun bits" {
	201	if (builtin.zig_backend == .stage1) return error.SkipZigTest;
	202	if (builtin.zig_backend != .stage1) {
	203	// TODO https://github.com/ziglang/zig/issues/9646
	204	return error.SkipZigTest;
	205	}
	206
158	207	comptime {
159	208	var v: u32 = undefined;
160	209	try doTypePunBitsTest(@ptrCast(*Bits, &v));
...	...	@@ -167,6 +216,12 @@ const imports = struct {
167	216
168	217	// Make sure lazy values work on their own, before getting into more complex tests
169	218	test "basic pointer preservation" {
	219	if (builtin.zig_backend == .stage1) return error.SkipZigTest;
	220	if (builtin.zig_backend != .stage1) {
	221	// TODO https://github.com/ziglang/zig/issues/9646
	222	return error.SkipZigTest;
	223	}
	224
170	225	comptime {
171	226	const lazy_address = @ptrToInt(&imports.global_u32);
172	227	try testing.expectEqual(@ptrToInt(&imports.global_u32), lazy_address);
...	...	@@ -175,6 +230,12 @@ test "basic pointer preservation" {
175	230	}
176	231
177	232	test "byte copy preserves linker value" {
	233	if (builtin.zig_backend == .stage1) return error.SkipZigTest;
	234	if (builtin.zig_backend != .stage1) {
	235	// TODO https://github.com/ziglang/zig/issues/9646
	236	return error.SkipZigTest;
	237	}
	238
178	239	const ct_value = comptime blk: {
179	240	const lazy = &imports.global_u32;
180	241	var result: *u32 = undefined;
...	...	@@ -193,6 +254,12 @@ test "byte copy preserves linker value" {
193	254	}
194	255
195	256	test "unordered byte copy preserves linker value" {
	257	if (builtin.zig_backend == .stage1) return error.SkipZigTest;
	258	if (builtin.zig_backend != .stage1) {
	259	// TODO https://github.com/ziglang/zig/issues/9646
	260	return error.SkipZigTest;
	261	}
	262
196	263	const ct_value = comptime blk: {
197	264	const lazy = &imports.global_u32;
198	265	var result: *u32 = undefined;
...	...	@@ -212,6 +279,12 @@ test "unordered byte copy preserves linker value" {
212	279	}
213	280
214	281	test "shuffle chunks of linker value" {
	282	if (builtin.zig_backend == .stage1) return error.SkipZigTest;
	283	if (builtin.zig_backend != .stage1) {
	284	// TODO https://github.com/ziglang/zig/issues/9646
	285	return error.SkipZigTest;
	286	}
	287
215	288	const lazy_address = @ptrToInt(&imports.global_u32);
216	289	const shuffled1_rt = shuffle(lazy_address, Bits, ShuffledBits);
217	290	const unshuffled1_rt = shuffle(shuffled1_rt, ShuffledBits, Bits);
...	...	@@ -225,6 +298,12 @@ test "shuffle chunks of linker value" {
225	298	}
226	299
227	300	test "dance on linker values" {
	301	if (builtin.zig_backend == .stage1) return error.SkipZigTest;
	302	if (builtin.zig_backend != .stage1) {
	303	// TODO https://github.com/ziglang/zig/issues/9646
	304	return error.SkipZigTest;
	305	}
	306
228	307	comptime {
229	308	var arr: [2]usize = undefined;
230	309	arr[0] = @ptrToInt(&imports.global_u32);
...	...	@@ -251,6 +330,12 @@ test "dance on linker values" {
251	330	}
252	331
253	332	test "offset array ptr by element size" {
	333	if (builtin.zig_backend == .stage1) return error.SkipZigTest;
	334	if (builtin.zig_backend != .stage1) {
	335	// TODO https://github.com/ziglang/zig/issues/9646
	336	return error.SkipZigTest;
	337	}
	338
254	339	comptime {
255	340	const VirtualStruct = struct { x: u32 };
256	341	var arr: [4]VirtualStruct = .{
...	...	@@ -273,6 +358,12 @@ test "offset array ptr by element size" {
273	358	}
274	359
275	360	test "offset instance by field size" {
	361	if (builtin.zig_backend == .stage1) return error.SkipZigTest;
	362	if (builtin.zig_backend != .stage1) {
	363	// TODO https://github.com/ziglang/zig/issues/9646
	364	return error.SkipZigTest;
	365	}
	366
276	367	comptime {
277	368	const VirtualStruct = struct { x: u32, y: u32, z: u32, w: u32 };
278	369	var inst = VirtualStruct{ .x = 0, .y = 1, .z = 2, .w = 3 };
...	...	@@ -293,6 +384,12 @@ test "offset instance by field size" {
293	384	}
294	385
295	386	test "offset field ptr by enclosing array element size" {
	387	if (builtin.zig_backend == .stage1) return error.SkipZigTest;
	388	if (builtin.zig_backend != .stage1) {
	389	// TODO https://github.com/ziglang/zig/issues/9646
	390	return error.SkipZigTest;
	391	}
	392
296	393	comptime {
297	394	const VirtualStruct = struct { x: u32 };
298	395	var arr: [4]VirtualStruct = .{

test/behavior/error.zig+1

...	...	@@ -1,3 +1,4 @@
	1	const builtin = @import("builtin");
1	2	const std = @import("std");
2	3	const expect = std.testing.expect;
3	4	const expectError = std.testing.expectError;

test/behavior/fn.zig+9-3

...	...	@@ -57,7 +57,7 @@ test "assign inline fn to const variable" {
57	57
58	58	inline fn inlineFn() void {}
59	59
60		fn outer(y: u32) fn (u32) u32 {
	60	fn outer(y: u32) *const fn (u32) u32 {
61	61	const Y = @TypeOf(y);
62	62	const st = struct {
63	63	fn get(z: u32) u32 {
...	...	@@ -68,6 +68,8 @@ fn outer(y: u32) fn (u32) u32 {
68	68	}
69	69
70	70	test "return inner function which references comptime variable of outer function" {
	71	if (builtin.zig_backend == .stage1) return error.SkipZigTest;
	72
71	73	var func = outer(10);
72	74	try expect(func(3) == 7);
73	75	}
...	...	@@ -92,6 +94,8 @@ test "discard the result of a function that returns a struct" {
92	94	}
93	95
94	96	test "inline function call that calls optional function pointer, return pointer at callsite interacts correctly with callsite return type" {
	97	if (builtin.zig_backend == .stage1) return error.SkipZigTest;
	98
95	99	const S = struct {
96	100	field: u32,
97	101
...	...	@@ -113,7 +117,7 @@ test "inline function call that calls optional function pointer, return pointer
113	117	return bar2.?();
114	118	}
115	119
116		var bar2: ?fn () u32 = null;
	120	var bar2: ?*const fn () u32 = null;
117	121
118	122	fn actualFn() u32 {
119	123	return 1234;
...	...	@@ -135,8 +139,10 @@ fn fnWithUnreachable() noreturn {
135	139	}
136	140
137	141	test "extern struct with stdcallcc fn pointer" {
	142	if (builtin.zig_backend == .stage1) return error.SkipZigTest;
	143
138	144	const S = extern struct {
139		ptr: fn () callconv(if (builtin.target.cpu.arch == .i386) .Stdcall else .C) i32,
	145	ptr: *const fn () callconv(if (builtin.target.cpu.arch == .i386) .Stdcall else .C) i32,
140	146
141	147	fn foo() callconv(if (builtin.target.cpu.arch == .i386) .Stdcall else .C) i32 {
142	148	return 1234;

test/behavior/inttoptr.zig+7-5

...	...	@@ -1,14 +1,16 @@
1	1	const builtin = @import("builtin");
2	2
3		test "casting random address to function pointer" {
	3	test "casting integer address to function pointer" {
	4	if (builtin.zig_backend == .stage1) return error.SkipZigTest;
4	5	if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .aarch64) return error.SkipZigTest; // TODO
5		randomAddressToFunction();
6		comptime randomAddressToFunction();
	6
	7	addressToFunction();
	8	comptime addressToFunction();
7	9	}
8	10
9		fn randomAddressToFunction() void {
	11	fn addressToFunction() void {
10	12	var addr: usize = 0xdeadbeef;
11		_ = @intToPtr(fn () void, addr);
	13	_ = @intToPtr(*const fn () void, addr);
12	14	}
13	15
14	16	test "mutate through ptr initialized with constant intToPtr value" {

test/behavior/member_func.zig+8-2

...	...	@@ -1,8 +1,10 @@
1		const expect = @import("std").testing.expect;
	1	const builtin = @import("builtin");
	2	const std = @import("std");
	3	const expect = std.testing.expect;
2	4
3	5	const HasFuncs = struct {
4	6	state: u32,
5		func_field: fn (u32) u32,
	7	func_field: *const fn (u32) u32,
6	8
7	9	fn inc(self: *HasFuncs) void {
8	10	self.state += 1;
...	...	@@ -25,6 +27,8 @@ const HasFuncs = struct {
25	27	};
26	28
27	29	test "standard field calls" {
	30	if (builtin.zig_backend == .stage1) return error.SkipZigTest;
	31
28	32	try expect(HasFuncs.one(0) == 1);
29	33	try expect(HasFuncs.two(0) == 2);
30	34
...	...	@@ -64,6 +68,8 @@ test "standard field calls" {
64	68	}
65	69
66	70	test "@field field calls" {
	71	if (builtin.zig_backend == .stage1) return error.SkipZigTest;
	72
67	73	try expect(@field(HasFuncs, "one")(0) == 1);
68	74	try expect(@field(HasFuncs, "two")(0) == 2);
69	75

test/behavior/slice.zig+13

...	...	@@ -1,3 +1,4 @@
	1	const builtin = @import("builtin");
1	2	const std = @import("std");
2	3	const expect = std.testing.expect;
3	4	const expectEqualSlices = std.testing.expectEqualSlices;
...	...	@@ -166,3 +167,15 @@ test "slicing zero length array" {
166	167	try expect(mem.eql(u8, s1, ""));
167	168	try expect(mem.eql(u32, s2, &[_]u32{}));
168	169	}
	170
	171	const x = @intToPtr([*]i32, 0x1000)[0..0x500];
	172	const y = x[0x100..];
	173	test "compile time slice of pointer to hard coded address" {
	174	if (builtin.zig_backend == .stage1) return error.SkipZigTest;
	175
	176	try expect(@ptrToInt(x) == 0x1000);
	177	try expect(x.len == 0x500);
	178
	179	try expect(@ptrToInt(y) == 0x1400);
	180	try expect(y.len == 0x400);
	181	}

test/behavior/slice_stage2.zig deleted-12

...	...	@@ -1,12 +0,0 @@
1		const std = @import("std");
2		const expect = std.testing.expect;
3
4		const x = @intToPtr([*]i32, 0x1000)[0..0x500];
5		const y = x[0x100..];
6		test "compile time slice of pointer to hard coded address" {
7		try expect(@ptrToInt(x) == 0x1000);
8		try expect(x.len == 0x500);
9
10		try expect(@ptrToInt(y) == 0x1400);
11		try expect(y.len == 0x400);
12		}

test/behavior/union.zig+4-1

...	...	@@ -1,3 +1,4 @@
	1	const builtin = @import("builtin");
1	2	const std = @import("std");
2	3	const expect = std.testing.expect;
3	4	const expectEqual = std.testing.expectEqual;
...	...	@@ -166,8 +167,10 @@ test "union with specified enum tag" {
166	167	}
167	168
168	169	test "packed union generates correctly aligned LLVM type" {
	170	if (builtin.zig_backend == .stage1) return error.SkipZigTest;
	171
169	172	const U = packed union {
170		f1: fn () error{TestUnexpectedResult}!void,
	173	f1: *const fn () error{TestUnexpectedResult}!void,
171	174	f2: u32,
172	175	};
173	176	var foo = [_]U{