Commit 88d275199c8807912f859e9f2b689700e3866689 | zig

author	Andrew Kelley <andrew@ziglang.org> 2023-05-12 14:46:20-07:00
committer	GitHub <noreply@github.com> 2023-05-12 14:46:20-07:00
log	88d275199c8807912f859e9f2b689700e3866689
tree	61157f4fb8ab135930ebfee3d40f4eede9b568ae
parent	6547d233125199b16644c0f7504793490af67926
parent	d61dc3a5a2320d1adda759cf5f90aaf817cb9ca2
signature	Signed by PGP key 4AEE18F83AFDEB23

Merge pull request #15240 from Snektron/spirv-basic

spirv: attempting to get the 'basic' behavior tests running

181 files changed, 1721 insertions(+), 145 deletions(-)

lib
- std
  - builtin.zig
  - target.zig
src
- Compilation.zig
- codegen
  - spirv.zig
  - spirv
    Module.zig
test
- behavior.zig
- behavior

lib/std/builtin.zig+3

...	...	@@ -836,6 +836,9 @@ pub const CompilerBackend = enum(u64) {
836	836	/// The reference implementation self-hosted compiler of Zig, using the
837	837	/// sparc64 backend.
838	838	stage2_sparc64 = 10,
	839	/// The reference implementation self-hosted compiler of Zig, using the
	840	/// spirv backend.
	841	stage2_spirv64 = 11,
839	842
840	843	_,
841	844	};

lib/std/target.zig+11-1

...	...	@@ -2220,6 +2220,17 @@ pub const Target = struct {
2220	2220	.longdouble => return 128,
2221	2221	},
2222	2222
	2223	.opencl => switch (c_type) {
	2224	.char => return 8,
	2225	.short, .ushort => return 16,
	2226	.int, .uint, .float => return 32,
	2227	.long, .ulong, .double => return 64,
	2228	.longlong, .ulonglong => return 128,
	2229	// Note: The OpenCL specification does not guarantee a particular size for long double,
	2230	// but clang uses 128 bits.
	2231	.longdouble => return 128,
	2232	},
	2233
2223	2234	.cloudabi,
2224	2235	.kfreebsd,
2225	2236	.lv2,
...	...	@@ -2234,7 +2245,6 @@ pub const Target = struct {
2234	2245	.contiki,
2235	2246	.hermit,
2236	2247	.hurd,
2237		.opencl,
2238	2248	.glsl450,
2239	2249	.vulkan,
2240	2250	.driverkit,

src/Compilation.zig+1

...	...	@@ -5076,6 +5076,7 @@ pub fn getZigBackend(comp: Compilation) std.builtin.CompilerBackend {
5076	5076	.aarch64, .aarch64_be, .aarch64_32 => .stage2_aarch64,
5077	5077	.riscv64 => .stage2_riscv64,
5078	5078	.sparc64 => .stage2_sparc64,
	5079	.spirv64 => .stage2_spirv64,
5079	5080	else => .other,
5080	5081	};
5081	5082	}

src/codegen/spirv.zig+467-137

...	...	@@ -238,6 +238,7 @@ pub const DeclGen = struct {
238	238	else => unreachable,
239	239	};
240	240	const spv_decl_index = try self.resolveDecl(fn_decl_index);
	241	try self.func.decl_deps.put(self.spv.gpa, spv_decl_index, {});
241	242	return self.spv.declPtr(spv_decl_index).result_id;
242	243	}
243	244
...	...	@@ -402,12 +403,44 @@ pub const DeclGen = struct {
402	403	return result_id;
403	404	}
404	405
405		fn genUndef(self: *DeclGen, ty_ref: SpvType.Ref) Error!IdRef {
	406	fn constUndef(self: *DeclGen, ty_ref: SpvType.Ref) !IdRef {
406	407	const result_id = self.spv.allocId();
407		try self.spv.sections.types_globals_constants.emit(self.spv.gpa, .OpUndef, .{ .id_result_type = self.typeId(ty_ref), .id_result = result_id });
	408	try self.spv.sections.types_globals_constants.emit(self.spv.gpa, .OpUndef, .{
	409	.id_result_type = self.typeId(ty_ref),
	410	.id_result = result_id,
	411	});
408	412	return result_id;
409	413	}
410	414
	415	fn constNull(self: *DeclGen, ty_ref: SpvType.Ref) !IdRef {
	416	const result_id = self.spv.allocId();
	417	try self.spv.sections.types_globals_constants.emit(self.spv.gpa, .OpConstantNull, .{
	418	.id_result_type = self.typeId(ty_ref),
	419	.id_result = result_id,
	420	});
	421	return result_id;
	422	}
	423
	424	fn constBool(self: *DeclGen, value: bool, repr: Repr) !IdRef {
	425	switch (repr) {
	426	.indirect => {
	427	const int_ty_ref = try self.intType(.unsigned, 1);
	428	return self.constInt(int_ty_ref, @boolToInt(value));
	429	},
	430	.direct => {
	431	const bool_ty_ref = try self.resolveType(Type.bool, .direct);
	432	const result_id = self.spv.allocId();
	433	const operands = .{ .id_result_type = self.typeId(bool_ty_ref), .id_result = result_id };
	434	if (value) {
	435	try self.spv.sections.types_globals_constants.emit(self.spv.gpa, .OpConstantTrue, operands);
	436	} else {
	437	try self.spv.sections.types_globals_constants.emit(self.spv.gpa, .OpConstantFalse, operands);
	438	}
	439	return result_id;
	440	},
	441	}
	442	}
	443
411	444	const IndirectConstantLowering = struct {
412	445	const undef = 0xAA;
413	446
...	...	@@ -427,7 +460,7 @@ pub const DeclGen = struct {
427	460	/// If full, its flushed.
428	461	partial_word: std.BoundedArray(u8, @sizeOf(Word)) = .{},
429	462	/// The declaration dependencies of the constant we are lowering.
430		decl_deps: std.ArrayList(SpvModule.Decl.Index),
	463	decl_deps: std.AutoArrayHashMap(SpvModule.Decl.Index, void),
431	464
432	465	/// Utility function to get the section that instructions should be lowered to.
433	466	fn section(self: @This()) SpvSection {
...	...	@@ -550,14 +583,15 @@ pub const DeclGen = struct {
550	583	// just generate an empty pointer. Function pointers are represented by usize for now,
551	584	// though.
552	585	try self.addInt(Type.usize, Value.initTag(.zero));
	586	// TODO: Add dependency
553	587	return;
554	588	},
555	589	.extern_fn => unreachable, // TODO
556	590	else => {
557	591	const result_id = dg.spv.allocId();
558		log.debug("addDeclRef {s} = {}", .{ decl.name, result_id.id });
	592	log.debug("addDeclRef: id = {}, index = {}, name = {s}", .{ result_id.id, @enumToInt(spv_decl_index), decl.name });
559	593
560		try self.decl_deps.append(spv_decl_index);
	594	try self.decl_deps.put(spv_decl_index, {});
561	595
562	596	const decl_id = dg.spv.declPtr(spv_decl_index).result_id;
563	597	// TODO: Do we need a storage class cast here?
...	...	@@ -674,7 +708,7 @@ pub const DeclGen = struct {
674	708	try self.addConstBool(has_payload);
675	709	return;
676	710	} else if (ty.optionalReprIsPayload()) {
677		// Optional representation is a nullable pointer.
	711	// Optional representation is a nullable pointer or slice.
678	712	if (val.castTag(.opt_payload)) \|payload\| {
679	713	try self.lower(payload_ty, payload.data);
680	714	} else if (has_payload) {
...	...	@@ -765,21 +799,18 @@ pub const DeclGen = struct {
765	799	const is_pl = val.errorUnionIsPayload();
766	800	const error_val = if (!is_pl) val else Value.initTag(.zero);
767	801
768		if (!payload_ty.hasRuntimeBitsIgnoreComptime()) {
	802	const eu_layout = dg.errorUnionLayout(payload_ty);
	803	if (!eu_layout.payload_has_bits) {
769	804	return try self.lower(Type.anyerror, error_val);
770	805	}
771	806
772		const payload_align = payload_ty.abiAlignment(target);
773		const error_align = Type.anyerror.abiAlignment(target);
774
775	807	const payload_size = payload_ty.abiSize(target);
776	808	const error_size = Type.anyerror.abiAlignment(target);
777	809	const ty_size = ty.abiSize(target);
778	810	const padding = ty_size - payload_size - error_size;
779
780	811	const payload_val = if (val.castTag(.eu_payload)) \|pl\| pl.data else Value.initTag(.undef);
781	812
782		if (error_align > payload_align) {
	813	if (eu_layout.error_first) {
783	814	try self.lower(Type.anyerror, error_val);
784	815	try self.lower(payload_ty, payload_val);
785	816	} else {
...	...	@@ -832,7 +863,8 @@ pub const DeclGen = struct {
832	863
833	864	assert(storage_class != .Generic and storage_class != .Function);
834	865
835		log.debug("lowerIndirectConstant: ty = {}, val = {}", .{ ty.fmt(self.module), val.fmtDebug() });
	866	const var_id = self.spv.allocId();
	867	log.debug("lowerIndirectConstant: id = {}, index = {}, ty = {}, val = {}", .{ var_id.id, @enumToInt(spv_decl_index), ty.fmt(self.module), val.fmtDebug() });
836	868
837	869	const section = &self.spv.globals.section;
838	870
...	...	@@ -868,7 +900,7 @@ pub const DeclGen = struct {
868	900	.u32_ty_id = self.typeId(u32_ty_ref),
869	901	.members = std.ArrayList(SpvType.Payload.Struct.Member).init(self.gpa),
870	902	.initializers = std.ArrayList(IdRef).init(self.gpa),
871		.decl_deps = std.ArrayList(SpvModule.Decl.Index).init(self.gpa),
	903	.decl_deps = std.AutoArrayHashMap(SpvModule.Decl.Index, void).init(self.gpa),
872	904	};
873	905
874	906	defer icl.members.deinit();
...	...	@@ -888,7 +920,6 @@ pub const DeclGen = struct {
888	920	.constituents = icl.initializers.items,
889	921	});
890	922
891		const var_id = self.spv.allocId();
892	923	self.spv.globalPtr(spv_decl_index).?.result_id = var_id;
893	924	try section.emit(self.spv.gpa, .OpVariable, .{
894	925	.id_result_type = self.typeId(ptr_constant_struct_ty_ref),
...	...	@@ -922,7 +953,7 @@ pub const DeclGen = struct {
922	953	});
923	954	}
924	955
925		try self.spv.declareDeclDeps(spv_decl_index, icl.decl_deps.items);
	956	try self.spv.declareDeclDeps(spv_decl_index, icl.decl_deps.keys());
926	957	self.spv.endGlobal(spv_decl_index, begin_inst);
927	958	}
928	959
...	...	@@ -948,11 +979,11 @@ pub const DeclGen = struct {
948	979
949	980	switch (ty.zigTypeTag()) {
950	981	.Int => {
951		const int_bits = if (ty.isSignedInt())
952		@bitCast(u64, val.toSignedInt(target))
953		else
954		val.toUnsignedInt(target);
955		try self.genConstInt(result_ty_ref, result_id, int_bits);
	982	if (ty.isSignedInt()) {
	983	try self.genConstInt(result_ty_ref, result_id, val.toSignedInt(target));
	984	} else {
	985	try self.genConstInt(result_ty_ref, result_id, val.toUnsignedInt(target));
	986	}
956	987	},
957	988	.Bool => {
958	989	const operands = .{ .id_result_type = result_ty_id, .id_result = result_id };
...	...	@@ -978,7 +1009,8 @@ pub const DeclGen = struct {
978	1009	false,
979	1010	alignment,
980	1011	);
981		try self.func.decl_deps.append(self.spv.gpa, spv_decl_index);
	1012	log.debug("indirect constant: index = {}", .{@enumToInt(spv_decl_index)});
	1013	try self.func.decl_deps.put(self.spv.gpa, spv_decl_index, {});
982	1014
983	1015	try self.func.body.emit(self.spv.gpa, .OpLoad, .{
984	1016	.id_result_type = result_ty_id,
...	...	@@ -1260,7 +1292,7 @@ pub const DeclGen = struct {
1260	1292
1261	1293	const payload_ty_ref = try self.resolveType(payload_ty, .indirect);
1262	1294	if (ty.optionalReprIsPayload()) {
1263		// Optional is actually a pointer.
	1295	// Optional is actually a pointer or a slice.
1264	1296	return payload_ty_ref;
1265	1297	}
1266	1298
...	...	@@ -1277,18 +1309,16 @@ pub const DeclGen = struct {
1277	1309	.ErrorUnion => {
1278	1310	const payload_ty = ty.errorUnionPayload();
1279	1311	const error_ty_ref = try self.resolveType(Type.anyerror, .indirect);
1280		if (!payload_ty.hasRuntimeBitsIgnoreComptime()) {
	1312
	1313	const eu_layout = self.errorUnionLayout(payload_ty);
	1314	if (!eu_layout.payload_has_bits) {
1281	1315	return error_ty_ref;
1282	1316	}
1283	1317
1284	1318	const payload_ty_ref = try self.resolveType(payload_ty, .indirect);
1285	1319
1286		const payload_align = payload_ty.abiAlignment(target);
1287		const error_align = Type.anyerror.abiAlignment(target);
1288
1289	1320	var members = std.BoundedArray(SpvType.Payload.Struct.Member, 2){};
1290		// Similar to unions, we're going to put the most aligned member first.
1291		if (error_align > payload_align) {
	1321	if (eu_layout.error_first) {
1292	1322	// Put the error first
1293	1323	members.appendAssumeCapacity(.{ .ty = error_ty_ref, .name = "error" });
1294	1324	members.appendAssumeCapacity(.{ .ty = payload_ty_ref, .name = "payload" });
...	...	@@ -1336,6 +1366,34 @@ pub const DeclGen = struct {
1336	1366	};
1337	1367	}
1338	1368
	1369	const ErrorUnionLayout = struct {
	1370	payload_has_bits: bool,
	1371	error_first: bool,
	1372
	1373	fn errorFieldIndex(self: @This()) u32 {
	1374	assert(self.payload_has_bits);
	1375	return if (self.error_first) 0 else 1;
	1376	}
	1377
	1378	fn payloadFieldIndex(self: @This()) u32 {
	1379	assert(self.payload_has_bits);
	1380	return if (self.error_first) 1 else 0;
	1381	}
	1382	};
	1383
	1384	fn errorUnionLayout(self: *DeclGen, payload_ty: Type) ErrorUnionLayout {
	1385	const target = self.getTarget();
	1386
	1387	const error_align = Type.anyerror.abiAlignment(target);
	1388	const payload_align = payload_ty.abiAlignment(target);
	1389
	1390	const error_first = error_align > payload_align;
	1391	return .{
	1392	.payload_has_bits = payload_ty.hasRuntimeBitsIgnoreComptime(),
	1393	.error_first = error_first,
	1394	};
	1395	}
	1396
1339	1397	/// The SPIR-V backend is not yet advanced enough to support the std testing infrastructure.
1340	1398	/// In order to be able to run tests, we "temporarily" lower test kernels into separate entry-
1341	1399	/// points. The test executor will then be able to invoke these to run the tests.
...	...	@@ -1416,7 +1474,7 @@ pub const DeclGen = struct {
1416	1474	const spv_decl_index = try self.resolveDecl(self.decl_index);
1417	1475
1418	1476	const decl_id = self.spv.declPtr(spv_decl_index).result_id;
1419		log.debug("genDecl {s} = {}", .{ decl.name, decl_id });
	1477	log.debug("genDecl: id = {}, index = {}, name = {s}", .{ decl_id.id, @enumToInt(spv_decl_index), decl.name });
1420	1478
1421	1479	if (decl.val.castTag(.function)) \|_\| {
1422	1480	assert(decl.ty.zigTypeTag() == .Fn);
...	...	@@ -1500,6 +1558,93 @@ pub const DeclGen = struct {
1500	1558	}
1501	1559	}
1502	1560
	1561	/// Convert representation from indirect (in memory) to direct (in 'register')
	1562	/// This converts the argument type from resolveType(ty, .indirect) to resolveType(ty, .direct).
	1563	fn convertToDirect(self: *DeclGen, ty: Type, operand_id: IdRef) !IdRef {
	1564	// const direct_ty_ref = try self.resolveType(ty, .direct);
	1565	return switch (ty.zigTypeTag()) {
	1566	.Bool => blk: {
	1567	const direct_bool_ty_ref = try self.resolveType(ty, .direct);
	1568	const indirect_bool_ty_ref = try self.resolveType(ty, .indirect);
	1569	const zero_id = try self.constInt(indirect_bool_ty_ref, 0);
	1570	const result_id = self.spv.allocId();
	1571	try self.func.body.emit(self.spv.gpa, .OpINotEqual, .{
	1572	.id_result_type = self.typeId(direct_bool_ty_ref),
	1573	.id_result = result_id,
	1574	.operand_1 = operand_id,
	1575	.operand_2 = zero_id,
	1576	});
	1577	break :blk result_id;
	1578	},
	1579	else => operand_id,
	1580	};
	1581	}
	1582
	1583	/// Convert representation from direct (in 'register) to direct (in memory)
	1584	/// This converts the argument type from resolveType(ty, .direct) to resolveType(ty, .indirect).
	1585	fn convertToIndirect(self: *DeclGen, ty: Type, operand_id: IdRef) !IdRef {
	1586	return switch (ty.zigTypeTag()) {
	1587	.Bool => blk: {
	1588	const indirect_bool_ty_ref = try self.resolveType(ty, .indirect);
	1589	const zero_id = try self.constInt(indirect_bool_ty_ref, 0);
	1590	const one_id = try self.constInt(indirect_bool_ty_ref, 1);
	1591	const result_id = self.spv.allocId();
	1592	try self.func.body.emit(self.spv.gpa, .OpSelect, .{
	1593	.id_result_type = self.typeId(indirect_bool_ty_ref),
	1594	.id_result = result_id,
	1595	.condition = operand_id,
	1596	.object_1 = one_id,
	1597	.object_2 = zero_id,
	1598	});
	1599	break :blk result_id;
	1600	},
	1601	else => operand_id,
	1602	};
	1603	}
	1604
	1605	fn extractField(self: *DeclGen, result_ty: Type, object: IdRef, field: u32) !IdRef {
	1606	const result_ty_ref = try self.resolveType(result_ty, .indirect);
	1607	const result_id = self.spv.allocId();
	1608	const indexes = [_]u32{field};
	1609	try self.func.body.emit(self.spv.gpa, .OpCompositeExtract, .{
	1610	.id_result_type = self.typeId(result_ty_ref),
	1611	.id_result = result_id,
	1612	.composite = object,
	1613	.indexes = &indexes,
	1614	});
	1615	// Convert bools; direct structs have their field types as indirect values.
	1616	return try self.convertToDirect(result_ty, result_id);
	1617	}
	1618
	1619	fn load(self: *DeclGen, ptr_ty: Type, ptr_id: IdRef) !IdRef {
	1620	const value_ty = ptr_ty.childType();
	1621	const indirect_value_ty_ref = try self.resolveType(value_ty, .indirect);
	1622	const result_id = self.spv.allocId();
	1623	const access = spec.MemoryAccess.Extended{
	1624	.Volatile = ptr_ty.isVolatilePtr(),
	1625	};
	1626	try self.func.body.emit(self.spv.gpa, .OpLoad, .{
	1627	.id_result_type = self.typeId(indirect_value_ty_ref),
	1628	.id_result = result_id,
	1629	.pointer = ptr_id,
	1630	.memory_access = access,
	1631	});
	1632	return try self.convertToDirect(value_ty, result_id);
	1633	}
	1634
	1635	fn store(self: *DeclGen, ptr_ty: Type, ptr_id: IdRef, value_id: IdRef) !void {
	1636	const value_ty = ptr_ty.childType();
	1637	const indirect_value_id = try self.convertToIndirect(value_ty, value_id);
	1638	const access = spec.MemoryAccess.Extended{
	1639	.Volatile = ptr_ty.isVolatilePtr(),
	1640	};
	1641	try self.func.body.emit(self.spv.gpa, .OpStore, .{
	1642	.pointer = ptr_id,
	1643	.object = indirect_value_id,
	1644	.memory_access = access,
	1645	});
	1646	}
	1647
1503	1648	fn genBody(self: *DeclGen, body: []const Air.Inst.Index) Error!void {
1504	1649	for (body) \|inst\| {
1505	1650	try self.genInst(inst);
...	...	@@ -1543,9 +1688,9 @@ pub const DeclGen = struct {
1543	1688
1544	1689	.shl => try self.airShift(inst, .OpShiftLeftLogical),
1545	1690
1546		.bitcast => try self.airBitcast(inst),
1547		.intcast => try self.airIntcast(inst),
1548		.not => try self.airNot(inst),
	1691	.bitcast => try self.airBitcast(inst),
	1692	.intcast, .trunc => try self.airIntcast(inst),
	1693	.not => try self.airNot(inst),
1549	1694
1550	1695	.slice_ptr => try self.airSliceField(inst, 0),
1551	1696	.slice_len => try self.airSliceField(inst, 1),
...	...	@@ -1573,20 +1718,30 @@ pub const DeclGen = struct {
1573	1718	.ret_ptr => try self.airAlloc(inst),
1574	1719	.block => try self.airBlock(inst),
1575	1720
1576		.load => try self.airLoad(inst),
1577		.store => return self.airStore(inst),
1578
1579		.br => return self.airBr(inst),
1580		.breakpoint => return,
1581		.cond_br => return self.airCondBr(inst),
1582		.constant => unreachable,
1583		.const_ty => unreachable,
1584		.dbg_stmt => return self.airDbgStmt(inst),
1585		.loop => return self.airLoop(inst),
1586		.ret => return self.airRet(inst),
1587		.ret_load => return self.airRetLoad(inst),
1588		.switch_br => return self.airSwitchBr(inst),
1589		.unreach => return self.airUnreach(),
	1721	.load => try self.airLoad(inst),
	1722	.store, .store_safe => return self.airStore(inst),
	1723
	1724	.br => return self.airBr(inst),
	1725	.breakpoint => return,
	1726	.cond_br => return self.airCondBr(inst),
	1727	.constant => unreachable,
	1728	.const_ty => unreachable,
	1729	.dbg_stmt => return self.airDbgStmt(inst),
	1730	.loop => return self.airLoop(inst),
	1731	.ret => return self.airRet(inst),
	1732	.ret_load => return self.airRetLoad(inst),
	1733	.@"try" => try self.airTry(inst),
	1734	.switch_br => return self.airSwitchBr(inst),
	1735	.unreach, .trap => return self.airUnreach(),
	1736
	1737	.unwrap_errunion_err => try self.airErrUnionErr(inst),
	1738	.wrap_errunion_err => try self.airWrapErrUnionErr(inst),
	1739
	1740	.is_null => try self.airIsNull(inst, .is_null),
	1741	.is_non_null => try self.airIsNull(inst, .is_non_null),
	1742
	1743	.optional_payload => try self.airUnwrapOptional(inst),
	1744	.wrap_optional => try self.airWrapOptional(inst),
1590	1745
1591	1746	.assembly => try self.airAssembly(inst),
1592	1747
...	...	@@ -1749,19 +1904,17 @@ pub const DeclGen = struct {
1749	1904	.float, .bool => unreachable,
1750	1905	}
1751	1906
1752		const operand_ty_id = try self.resolveTypeId(operand_ty);
1753		const result_type_id = try self.resolveTypeId(result_ty);
1754
1755		const overflow_member_ty = try self.intType(.unsigned, info.bits);
1756		const overflow_member_ty_id = self.typeId(overflow_member_ty);
	1907	// The operand type must be the same as the result type in SPIR-V.
	1908	const operand_ty_ref = try self.resolveType(operand_ty, .direct);
	1909	const operand_ty_id = self.typeId(operand_ty_ref);
1757	1910
1758	1911	const op_result_id = blk: {
1759	1912	// Construct the SPIR-V result type.
1760	1913	// It is almost the same as the zig one, except that the fields must be the same type
1761	1914	// and they must be unsigned.
1762	1915	const overflow_result_ty_ref = try self.spv.simpleStructType(&.{
1763		.{ .ty = overflow_member_ty, .name = "res" },
1764		.{ .ty = overflow_member_ty, .name = "ov" },
	1916	.{ .ty = operand_ty_ref, .name = "res" },
	1917	.{ .ty = operand_ty_ref, .name = "ov" },
1765	1918	});
1766	1919	const result_id = self.spv.allocId();
1767	1920	try self.func.body.emit(self.spv.gpa, .OpIAddCarry, .{
...	...	@@ -1775,11 +1928,13 @@ pub const DeclGen = struct {
1775	1928
1776	1929	// Now convert the SPIR-V flavor result into a Zig-flavor result.
1777	1930	// First, extract the two fields.
1778		const unsigned_result = try self.extractField(overflow_member_ty_id, op_result_id, 0);
1779		const overflow = try self.extractField(overflow_member_ty_id, op_result_id, 1);
	1931	const unsigned_result = try self.extractField(operand_ty, op_result_id, 0);
	1932	const overflow = try self.extractField(operand_ty, op_result_id, 1);
1780	1933
1781	1934	// We need to convert the results to the types that Zig expects here.
1782	1935	// The `result` is the same type except unsigned, so we can just bitcast that.
	1936	// TODO: This can be removed in Kernels as there are only unsigned ints. Maybe for
	1937	// shaders as well?
1783	1938	const result = try self.bitcast(operand_ty_id, unsigned_result);
1784	1939
1785	1940	// The overflow needs to be converted into whatever is used to represent it in Zig.
...	...	@@ -1802,7 +1957,7 @@ pub const DeclGen = struct {
1802	1957	const result_id = self.spv.allocId();
1803	1958	const constituents = [_]IdRef{ result, casted_overflow };
1804	1959	try self.func.body.emit(self.spv.gpa, .OpCompositeConstruct, .{
1805		.id_result_type = result_type_id,
	1960	.id_result_type = operand_ty_id,
1806	1961	.id_result = result_id,
1807	1962	.constituents = &constituents,
1808	1963	});
...	...	@@ -1954,24 +2109,14 @@ pub const DeclGen = struct {
1954	2109	return result_id;
1955	2110	}
1956	2111
1957		fn extractField(self: *DeclGen, result_ty: IdResultType, object: IdRef, field: u32) !IdRef {
1958		const result_id = self.spv.allocId();
1959		const indexes = [_]u32{field};
1960		try self.func.body.emit(self.spv.gpa, .OpCompositeExtract, .{
1961		.id_result_type = result_ty,
1962		.id_result = result_id,
1963		.composite = object,
1964		.indexes = &indexes,
1965		});
1966		return result_id;
1967		}
1968
1969	2112	fn airSliceField(self: *DeclGen, inst: Air.Inst.Index, field: u32) !?IdRef {
1970	2113	if (self.liveness.isUnused(inst)) return null;
1971	2114	const ty_op = self.air.instructions.items(.data)[inst].ty_op;
	2115	const field_ty = self.air.typeOfIndex(inst);
	2116	const operand_id = try self.resolve(ty_op.operand);
1972	2117	return try self.extractField(
1973		try self.resolveTypeId(self.air.typeOfIndex(inst)),
1974		try self.resolve(ty_op.operand),
	2118	field_ty,
	2119	operand_id,
1975	2120	field,
1976	2121	);
1977	2122	}
...	...	@@ -2264,15 +2409,15 @@ pub const DeclGen = struct {
2264	2409	return null;
2265	2410
2266	2411	// Combine the result from the blocks using the Phi instruction.
2267
2268	2412	const result_id = self.spv.allocId();
2269	2413
2270	2414	// TODO: OpPhi is limited in the types that it may produce, such as pointers. Figure out which other types
2271	2415	// are not allowed to be created from a phi node, and throw an error for those.
2272	2416	const result_type_id = try self.resolveTypeId(ty);
2273		_ = result_type_id;
2274	2417
2275	2418	try self.func.body.emitRaw(self.spv.gpa, .OpPhi, 2 + @intCast(u16, incoming_blocks.items.len * 2)); // result type + result + variable/parent...
	2419	self.func.body.writeOperand(spec.IdResultType, result_type_id);
	2420	self.func.body.writeOperand(spec.IdRef, result_id);
2276	2421
2277	2422	for (incoming_blocks.items) \|incoming\| {
2278	2423	self.func.body.writeOperand(spec.PairIdRefIdRef, .{ incoming.break_value_id, incoming.src_label_id });
...	...	@@ -2340,71 +2485,20 @@ pub const DeclGen = struct {
2340	2485	return try self.load(ptr_ty, operand);
2341	2486	}
2342	2487
2343		fn load(self: *DeclGen, ptr_ty: Type, ptr: IdRef) !IdRef {
2344		const value_ty = ptr_ty.childType();
2345		const direct_result_ty_ref = try self.resolveType(value_ty, .direct);
2346		const indirect_result_ty_ref = try self.resolveType(value_ty, .indirect);
2347		const result_id = self.spv.allocId();
2348		const access = spec.MemoryAccess.Extended{
2349		.Volatile = ptr_ty.isVolatilePtr(),
2350		};
2351		try self.func.body.emit(self.spv.gpa, .OpLoad, .{
2352		.id_result_type = self.typeId(indirect_result_ty_ref),
2353		.id_result = result_id,
2354		.pointer = ptr,
2355		.memory_access = access,
2356		});
2357		if (value_ty.zigTypeTag() == .Bool) {
2358		// Convert indirect bool to direct bool
2359		const zero_id = try self.constInt(indirect_result_ty_ref, 0);
2360		const casted_result_id = self.spv.allocId();
2361		try self.func.body.emit(self.spv.gpa, .OpINotEqual, .{
2362		.id_result_type = self.typeId(direct_result_ty_ref),
2363		.id_result = casted_result_id,
2364		.operand_1 = result_id,
2365		.operand_2 = zero_id,
2366		});
2367		return casted_result_id;
2368		}
2369		return result_id;
2370		}
2371
2372	2488	fn airStore(self: *DeclGen, inst: Air.Inst.Index) !void {
2373	2489	const bin_op = self.air.instructions.items(.data)[inst].bin_op;
2374	2490	const ptr_ty = self.air.typeOf(bin_op.lhs);
2375	2491	const ptr = try self.resolve(bin_op.lhs);
2376	2492	const value = try self.resolve(bin_op.rhs);
	2493	const ptr_ty_ref = try self.resolveType(ptr_ty, .direct);
2377	2494
2378		try self.store(ptr_ty, ptr, value);
2379		}
2380
2381		fn store(self: *DeclGen, ptr_ty: Type, ptr: IdRef, value: IdRef) !void {
2382		const value_ty = ptr_ty.childType();
2383		const converted_value = switch (value_ty.zigTypeTag()) {
2384		.Bool => blk: {
2385		const indirect_bool_ty_ref = try self.resolveType(value_ty, .indirect);
2386		const result_id = self.spv.allocId();
2387		const zero = try self.constInt(indirect_bool_ty_ref, 0);
2388		const one = try self.constInt(indirect_bool_ty_ref, 1);
2389		try self.func.body.emit(self.spv.gpa, .OpSelect, .{
2390		.id_result_type = self.typeId(indirect_bool_ty_ref),
2391		.id_result = result_id,
2392		.condition = value,
2393		.object_1 = one,
2394		.object_2 = zero,
2395		});
2396		break :blk result_id;
2397		},
2398		else => value,
2399		};
2400		const access = spec.MemoryAccess.Extended{
2401		.Volatile = ptr_ty.isVolatilePtr(),
2402		};
2403		try self.func.body.emit(self.spv.gpa, .OpStore, .{
2404		.pointer = ptr,
2405		.object = converted_value,
2406		.memory_access = access,
2407		});
	2495	const val_is_undef = if (self.air.value(bin_op.rhs)) \|val\| val.isUndefDeep() else false;
	2496	if (val_is_undef) {
	2497	const undef = try self.constUndef(ptr_ty_ref);
	2498	try self.store(ptr_ty, ptr, undef);
	2499	} else {
	2500	try self.store(ptr_ty, ptr, value);
	2501	}
2408	2502	}
2409	2503
2410	2504	fn airLoop(self: *DeclGen, inst: Air.Inst.Index) !void {
...	...	@@ -2451,6 +2545,232 @@ pub const DeclGen = struct {
2451	2545	});
2452	2546	}
2453	2547
	2548	fn airTry(self: *DeclGen, inst: Air.Inst.Index) !?IdRef {
	2549	const pl_op = self.air.instructions.items(.data)[inst].pl_op;
	2550	const err_union_id = try self.resolve(pl_op.operand);
	2551	const extra = self.air.extraData(Air.Try, pl_op.payload);
	2552	const body = self.air.extra[extra.end..][0..extra.data.body_len];
	2553
	2554	const err_union_ty = self.air.typeOf(pl_op.operand);
	2555	const payload_ty = self.air.typeOfIndex(inst);
	2556
	2557	const err_ty_ref = try self.resolveType(Type.anyerror, .direct);
	2558	const bool_ty_ref = try self.resolveType(Type.bool, .direct);
	2559
	2560	const eu_layout = self.errorUnionLayout(payload_ty);
	2561
	2562	if (!err_union_ty.errorUnionSet().errorSetIsEmpty()) {
	2563	const err_id = if (eu_layout.payload_has_bits)
	2564	try self.extractField(Type.anyerror, err_union_id, eu_layout.errorFieldIndex())
	2565	else
	2566	err_union_id;
	2567
	2568	const zero_id = try self.constInt(err_ty_ref, 0);
	2569	const is_err_id = self.spv.allocId();
	2570	try self.func.body.emit(self.spv.gpa, .OpINotEqual, .{
	2571	.id_result_type = self.typeId(bool_ty_ref),
	2572	.id_result = is_err_id,
	2573	.operand_1 = err_id,
	2574	.operand_2 = zero_id,
	2575	});
	2576
	2577	// When there is an error, we must evaluate `body`. Otherwise we must continue
	2578	// with the current body.
	2579	// Just generate a new block here, then generate a new block inline for the remainder of the body.
	2580
	2581	const err_block = self.spv.allocId();
	2582	const ok_block = self.spv.allocId();
	2583
	2584	// TODO: Merge block
	2585	try self.func.body.emit(self.spv.gpa, .OpBranchConditional, .{
	2586	.condition = is_err_id,
	2587	.true_label = err_block,
	2588	.false_label = ok_block,
	2589	});
	2590
	2591	try self.beginSpvBlock(err_block);
	2592	try self.genBody(body);
	2593
	2594	try self.beginSpvBlock(ok_block);
	2595	// Now just extract the payload, if required.
	2596	}
	2597	if (self.liveness.isUnused(inst)) {
	2598	return null;
	2599	}
	2600	if (!eu_layout.payload_has_bits) {
	2601	return null;
	2602	}
	2603
	2604	return try self.extractField(payload_ty, err_union_id, eu_layout.payloadFieldIndex());
	2605	}
	2606
	2607	fn airErrUnionErr(self: *DeclGen, inst: Air.Inst.Index) !?IdRef {
	2608	if (self.liveness.isUnused(inst)) return null;
	2609
	2610	const ty_op = self.air.instructions.items(.data)[inst].ty_op;
	2611	const operand_id = try self.resolve(ty_op.operand);
	2612	const err_union_ty = self.air.typeOf(ty_op.operand);
	2613	const err_ty_ref = try self.resolveType(Type.anyerror, .direct);
	2614
	2615	if (err_union_ty.errorUnionSet().errorSetIsEmpty()) {
	2616	// No error possible, so just return undefined.
	2617	return try self.constUndef(err_ty_ref);
	2618	}
	2619
	2620	const payload_ty = err_union_ty.errorUnionPayload();
	2621	const eu_layout = self.errorUnionLayout(payload_ty);
	2622
	2623	if (!eu_layout.payload_has_bits) {
	2624	// If no payload, error union is represented by error set.
	2625	return operand_id;
	2626	}
	2627
	2628	return try self.extractField(Type.anyerror, operand_id, eu_layout.errorFieldIndex());
	2629	}
	2630
	2631	fn airWrapErrUnionErr(self: *DeclGen, inst: Air.Inst.Index) !?IdRef {
	2632	if (self.liveness.isUnused(inst)) return null;
	2633
	2634	const ty_op = self.air.instructions.items(.data)[inst].ty_op;
	2635	const err_union_ty = self.air.typeOfIndex(inst);
	2636	const payload_ty = err_union_ty.errorUnionPayload();
	2637	const operand_id = try self.resolve(ty_op.operand);
	2638	const eu_layout = self.errorUnionLayout(payload_ty);
	2639
	2640	if (!eu_layout.payload_has_bits) {
	2641	return operand_id;
	2642	}
	2643
	2644	const payload_ty_ref = try self.resolveType(payload_ty, .indirect);
	2645	var members = std.BoundedArray(IdRef, 2){};
	2646	const payload_id = try self.constUndef(payload_ty_ref);
	2647	if (eu_layout.error_first) {
	2648	members.appendAssumeCapacity(operand_id);
	2649	members.appendAssumeCapacity(payload_id);
	2650	// TODO: ABI padding?
	2651	} else {
	2652	members.appendAssumeCapacity(payload_id);
	2653	members.appendAssumeCapacity(operand_id);
	2654	// TODO: ABI padding?
	2655	}
	2656
	2657	const err_union_ty_ref = try self.resolveType(err_union_ty, .direct);
	2658	const result_id = self.spv.allocId();
	2659	try self.func.body.emit(self.spv.gpa, .OpCompositeConstruct, .{
	2660	.id_result_type = self.typeId(err_union_ty_ref),
	2661	.id_result = result_id,
	2662	.constituents = members.slice(),
	2663	});
	2664	return result_id;
	2665	}
	2666
	2667	fn airIsNull(self: *DeclGen, inst: Air.Inst.Index, pred: enum { is_null, is_non_null }) !?IdRef {
	2668	if (self.liveness.isUnused(inst)) return null;
	2669
	2670	const un_op = self.air.instructions.items(.data)[inst].un_op;
	2671	const operand_id = try self.resolve(un_op);
	2672	const optional_ty = self.air.typeOf(un_op);
	2673
	2674	var buf: Type.Payload.ElemType = undefined;
	2675	const payload_ty = optional_ty.optionalChild(&buf);
	2676
	2677	const bool_ty_ref = try self.resolveType(Type.bool, .direct);
	2678
	2679	if (optional_ty.optionalReprIsPayload()) {
	2680	// Pointer payload represents nullability: pointer or slice.
	2681
	2682	var ptr_buf: Type.SlicePtrFieldTypeBuffer = undefined;
	2683	const ptr_ty = if (payload_ty.isSlice())
	2684	payload_ty.slicePtrFieldType(&ptr_buf)
	2685	else
	2686	payload_ty;
	2687
	2688	const ptr_id = if (payload_ty.isSlice())
	2689	try self.extractField(Type.bool, operand_id, 0)
	2690	else
	2691	operand_id;
	2692
	2693	const payload_ty_ref = try self.resolveType(ptr_ty, .direct);
	2694	const null_id = try self.constNull(payload_ty_ref);
	2695	const result_id = self.spv.allocId();
	2696	const operands = .{
	2697	.id_result_type = self.typeId(bool_ty_ref),
	2698	.id_result = result_id,
	2699	.operand_1 = ptr_id,
	2700	.operand_2 = null_id,
	2701	};
	2702	switch (pred) {
	2703	.is_null => try self.func.body.emit(self.spv.gpa, .OpPtrEqual, operands),
	2704	.is_non_null => try self.func.body.emit(self.spv.gpa, .OpPtrNotEqual, operands),
	2705	}
	2706	return result_id;
	2707	}
	2708
	2709	const is_non_null_id = if (optional_ty.hasRuntimeBitsIgnoreComptime())
	2710	try self.extractField(Type.bool, operand_id, 1)
	2711	else
	2712	// Optional representation is bool indicating whether the optional is set
	2713	operand_id;
	2714
	2715	return switch (pred) {
	2716	.is_null => blk: {
	2717	// Invert condition
	2718	const result_id = self.spv.allocId();
	2719	try self.func.body.emit(self.spv.gpa, .OpLogicalNot, .{
	2720	.id_result_type = self.typeId(bool_ty_ref),
	2721	.id_result = result_id,
	2722	.operand = is_non_null_id,
	2723	});
	2724	break :blk result_id;
	2725	},
	2726	.is_non_null => is_non_null_id,
	2727	};
	2728	}
	2729
	2730	fn airUnwrapOptional(self: *DeclGen, inst: Air.Inst.Index) !?IdRef {
	2731	if (self.liveness.isUnused(inst)) return null;
	2732
	2733	const ty_op = self.air.instructions.items(.data)[inst].ty_op;
	2734	const operand_id = try self.resolve(ty_op.operand);
	2735	const optional_ty = self.air.typeOf(ty_op.operand);
	2736	const payload_ty = self.air.typeOfIndex(inst);
	2737
	2738	if (!payload_ty.hasRuntimeBitsIgnoreComptime()) return null;
	2739
	2740	if (optional_ty.optionalReprIsPayload()) {
	2741	return operand_id;
	2742	}
	2743
	2744	return try self.extractField(payload_ty, operand_id, 0);
	2745	}
	2746
	2747	fn airWrapOptional(self: *DeclGen, inst: Air.Inst.Index) !?IdRef {
	2748	if (self.liveness.isUnused(inst)) return null;
	2749
	2750	const ty_op = self.air.instructions.items(.data)[inst].ty_op;
	2751	const payload_ty = self.air.typeOf(ty_op.operand);
	2752
	2753	if (!payload_ty.hasRuntimeBitsIgnoreComptime()) {
	2754	return try self.constBool(true, .direct);
	2755	}
	2756
	2757	const operand_id = try self.resolve(ty_op.operand);
	2758	const optional_ty = self.air.typeOfIndex(inst);
	2759	if (optional_ty.optionalReprIsPayload()) {
	2760	return operand_id;
	2761	}
	2762
	2763	const optional_ty_ref = try self.resolveType(optional_ty, .direct);
	2764	const result_id = self.spv.allocId();
	2765	const members = [_]IdRef{ operand_id, try self.constBool(true, .indirect) };
	2766	try self.func.body.emit(self.spv.gpa, .OpCompositeConstruct, .{
	2767	.id_result_type = self.typeId(optional_ty_ref),
	2768	.id_result = result_id,
	2769	.constituents = &members,
	2770	});
	2771	return result_id;
	2772	}
	2773
2454	2774	fn airSwitchBr(self: *DeclGen, inst: Air.Inst.Index) !void {
2455	2775	const target = self.getTarget();
2456	2776	const pl_op = self.air.instructions.items(.data)[inst].pl_op;
...	...	@@ -2717,19 +3037,29 @@ pub const DeclGen = struct {
2717	3037	const result_id = self.spv.allocId();
2718	3038	const callee_id = try self.resolve(pl_op.operand);
2719	3039
2720		try self.func.body.emitRaw(self.spv.gpa, .OpFunctionCall, 3 + args.len);
2721		self.func.body.writeOperand(spec.IdResultType, result_type_id);
2722		self.func.body.writeOperand(spec.IdResult, result_id);
2723		self.func.body.writeOperand(spec.IdRef, callee_id);
	3040	const params = try self.gpa.alloc(spec.IdRef, args.len);
	3041	defer self.gpa.free(params);
2724	3042
	3043	var n_params: usize = 0;
2725	3044	for (args) \|arg\| {
	3045	// Note: resolve() might emit instructions, so we need to call it
	3046	// before starting to emit OpFunctionCall instructions. Hence the
	3047	// temporary params buffer.
2726	3048	const arg_id = try self.resolve(arg);
2727	3049	const arg_ty = self.air.typeOf(arg);
2728	3050	if (!arg_ty.hasRuntimeBitsIgnoreComptime()) continue;
2729	3051
2730		self.func.body.writeOperand(spec.IdRef, arg_id);
	3052	params[n_params] = arg_id;
	3053	n_params += 1;
2731	3054	}
2732	3055
	3056	try self.func.body.emit(self.spv.gpa, .OpFunctionCall, .{
	3057	.id_result_type = result_type_id,
	3058	.id_result = result_id,
	3059	.function = callee_id,
	3060	.id_ref_3 = params[0..n_params],
	3061	});
	3062
2733	3063	if (return_type.isNoReturn()) {
2734	3064	try self.func.body.emit(self.spv.gpa, .OpUnreachable, {});
2735	3065	}

src/codegen/spirv/Module.zig+8-5

...	...	@@ -40,14 +40,14 @@ pub const Fn = struct {
40	40	/// the end of this function definition.
41	41	body: Section = .{},
42	42	/// The decl dependencies that this function depends on.
43		decl_deps: std.ArrayListUnmanaged(Decl.Index) = .{},
	43	decl_deps: std.AutoArrayHashMapUnmanaged(Decl.Index, void) = .{},
44	44
45	45	/// Reset this function without deallocating resources, so that
46	46	/// it may be used to emit code for another function.
47	47	pub fn reset(self: *Fn) void {
48	48	self.prologue.reset();
49	49	self.body.reset();
50		self.decl_deps.items.len = 0;
	50	self.decl_deps.clearRetainingCapacity();
51	51	}
52	52
53	53	/// Free the resources owned by this function.
...	...	@@ -358,7 +358,7 @@ pub fn flush(self: *Module, file: std.fs.File) !void {
358	358	pub fn addFunction(self: *Module, decl_index: Decl.Index, func: Fn) !void {
359	359	try self.sections.functions.append(self.gpa, func.prologue);
360	360	try self.sections.functions.append(self.gpa, func.body);
361		try self.declareDeclDeps(decl_index, func.decl_deps.items);
	361	try self.declareDeclDeps(decl_index, func.decl_deps.keys());
362	362	}
363	363
364	364	/// Fetch the result-id of an OpString instruction that encodes the path of the source
...	...	@@ -393,11 +393,14 @@ pub fn resolveSourceFileName(self: Module, decl: ZigDecl) !IdRef {
393	393	/// be emitted at this point.
394	394	pub fn resolveType(self: *Module, ty: Type) !Type.Ref {
395	395	const result = try self.type_cache.getOrPut(self.gpa, ty);
	396	const index = @intToEnum(Type.Ref, result.index);
	397
396	398	if (!result.found_existing) {
397		result.value_ptr.* = try self.emitType(ty);
	399	const ref = try self.emitType(ty);
	400	self.type_cache.values()[result.index] = ref;
398	401	}
399	402
400		return @intToEnum(Type.Ref, result.index);
	403	return index;
401	404	}
402	405
403	406	pub fn resolveTypeId(self: *Module, ty: Type) !IdResultType {

test/behavior.zig+2-1

...	...	@@ -241,7 +241,8 @@ test {
241	241	builtin.zig_backend != .stage2_x86_64 and
242	242	builtin.zig_backend != .stage2_aarch64 and
243	243	builtin.zig_backend != .stage2_wasm and
244		builtin.zig_backend != .stage2_c)
	244	builtin.zig_backend != .stage2_c and
	245	builtin.zig_backend != .stage2_spirv64)
245	246	{
246	247	_ = @import("behavior/bugs/13063.zig");
247	248	_ = @import("behavior/bugs/11227.zig");

test/behavior/align.zig+23

...	...	@@ -19,6 +19,7 @@ test "slicing array of length 1 can not assume runtime index is always zero" {
19	19	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
20	20	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
21	21	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	22	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
22	23
23	24	var runtime_index: usize = 1;
24	25	const slice = @as(*align(4) [1]u8, &foo)[runtime_index..];
...	...	@@ -32,6 +33,8 @@ test "default alignment allows unspecified in type syntax" {
32	33	}
33	34
34	35	test "implicitly decreasing pointer alignment" {
	36	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	37
35	38	const a: u32 align(4) = 3;
36	39	const b: u32 align(8) = 4;
37	40	try expect(addUnaligned(&a, &b) == 7);
...	...	@@ -42,6 +45,8 @@ fn addUnaligned(a: align(1) const u32, b: align(1) const u32) u32 {
42	45	}
43	46
44	47	test "@alignCast pointers" {
	48	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	49
45	50	var x: u32 align(4) = 1;
46	51	expectsOnly1(&x);
47	52	try expect(x == 2);
...	...	@@ -214,6 +219,8 @@ test "alignment and size of structs with 128-bit fields" {
214	219	}
215	220
216	221	test "@ptrCast preserves alignment of bigger source" {
	222	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	223
217	224	var x: u32 align(16) = 1234;
218	225	const ptr = @ptrCast(*u8, &x);
219	226	try expect(@TypeOf(ptr) == *align(16) u8);
...	...	@@ -231,6 +238,7 @@ fn fnWithAlignedStack() i32 {
231	238	test "implicitly decreasing slice alignment" {
232	239	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
233	240	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	241	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
234	242
235	243	const a: u32 align(4) = 3;
236	244	const b: u32 align(8) = 4;
...	...	@@ -256,6 +264,7 @@ test "@alignCast slices" {
256	264	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
257	265	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
258	266	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	267	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
259	268
260	269	var array align(4) = [_]u32{ 1, 1 };
261	270	const slice = array[0..];
...	...	@@ -273,6 +282,7 @@ test "return error union with 128-bit integer" {
273	282	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
274	283	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
275	284	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	285	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
276	286
277	287	try expect(3 == try give());
278	288	}
...	...	@@ -284,6 +294,7 @@ test "page aligned array on stack" {
284	294	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
285	295	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
286	296	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	297	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
287	298
288	299	if (builtin.cpu.arch == .aarch64 and builtin.os.tag == .windows) {
289	300	// https://github.com/ziglang/zig/issues/13679
...	...	@@ -329,6 +340,7 @@ test "implicitly decreasing fn alignment" {
329	340	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
330	341	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
331	342	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	343	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
332	344
333	345	// function alignment is a compile error on wasm32/wasm64
334	346	if (native_arch == .wasm32 or native_arch == .wasm64) return error.SkipZigTest;
...	...	@@ -352,6 +364,7 @@ test "@alignCast functions" {
352	364	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
353	365	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
354	366	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	367	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
355	368
356	369	// function alignment is a compile error on wasm32/wasm64
357	370	if (native_arch == .wasm32 or native_arch == .wasm64) return error.SkipZigTest;
...	...	@@ -395,6 +408,7 @@ test "function align expression depends on generic parameter" {
395	408
396	409	test "function callconv expression depends on generic parameter" {
397	410	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	411	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
398	412
399	413	const S = struct {
400	414	fn doTheTest() !void {
...	...	@@ -412,6 +426,7 @@ test "function callconv expression depends on generic parameter" {
412	426
413	427	test "runtime-known array index has best alignment possible" {
414	428	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	429	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
415	430
416	431	// take full advantage of over-alignment
417	432	var array align(4) = [_]u8{ 1, 2, 3, 4 };
...	...	@@ -451,6 +466,8 @@ fn testIndex2(ptr: [*]align(4) u8, index: usize, comptime T: type) !void {
451	466	}
452	467
453	468	test "alignment of function with c calling convention" {
	469	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	470
454	471	var runtime_nothing = &nothing;
455	472	const casted1 = @ptrCast(*const u8, runtime_nothing);
456	473	const casted2 = @ptrCast(*const fn () callconv(.C) void, casted1);
...	...	@@ -468,6 +485,7 @@ test "read 128-bit field from default aligned struct in stack memory" {
468	485	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
469	486	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
470	487	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	488	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
471	489
472	490	var default_aligned = DefaultAligned{
473	491	.nevermind = 1,
...	...	@@ -485,6 +503,7 @@ test "read 128-bit field from default aligned struct in global memory" {
485	503	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
486	504	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
487	505	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	506	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
488	507
489	508	try expect(12 == default_aligned_global.badguy);
490	509	}
...	...	@@ -493,6 +512,7 @@ test "struct field explicit alignment" {
493	512	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
494	513	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
495	514	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	515	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
496	516
497	517	const S = struct {
498	518	const Node = struct {
...	...	@@ -537,6 +557,7 @@ test "align(N) on functions" {
537	557	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
538	558	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
539	559	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	560	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
540	561
541	562	// This is not supported on MSVC
542	563	if (builtin.zig_backend == .stage2_c and builtin.os.tag == .windows) {
...	...	@@ -558,6 +579,7 @@ test "comptime alloc alignment" {
558	579	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
559	580	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
560	581	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	582	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
561	583
562	584	comptime var bytes1 = [_]u8{0};
563	585	_ = bytes1;
...	...	@@ -570,6 +592,7 @@ test "comptime alloc alignment" {
570	592	test "@alignCast null" {
571	593	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
572	594	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	595	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
573	596
574	597	var ptr: ?*anyopaque = null;
575	598	const aligned: ?anyopaque = @alignCast(@alignOf(?anyopaque), ptr);

test/behavior/array.zig+30

...	...	@@ -21,6 +21,7 @@ test "arrays" {
21	21	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
22	22	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
23	23	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	24	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
24	25
25	26	var array: [5]u32 = undefined;
26	27
...	...	@@ -48,6 +49,7 @@ fn getArrayLen(a: []const u32) usize {
48	49	test "array concat with undefined" {
49	50	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
50	51	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	52	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
51	53
52	54	const S = struct {
53	55	fn doTheTest() !void {
...	...	@@ -72,6 +74,7 @@ test "array concat with tuple" {
72	74	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
73	75	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
74	76	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	77	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
75	78
76	79	const array: [2]u8 = .{ 1, 2 };
77	80	{
...	...	@@ -86,6 +89,8 @@ test "array concat with tuple" {
86	89
87	90	test "array init with concat" {
88	91	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	92	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	93
89	94	const a = 'a';
90	95	var i: [4]u8 = [2]u8{ a, 'b' } ++ [2]u8{ 'c', 'd' };
91	96	try expect(std.mem.eql(u8, &i, "abcd"));
...	...	@@ -94,6 +99,7 @@ test "array init with concat" {
94	99	test "array init with mult" {
95	100	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
96	101	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	102	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
97	103
98	104	const a = 'a';
99	105	var i: [8]u8 = [2]u8{ a, 'b' } ** 4;
...	...	@@ -135,6 +141,7 @@ test "array literal with specified size" {
135	141	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
136	142	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
137	143	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	144	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
138	145
139	146	var array = [2]u8{ 1, 2 };
140	147	try expect(array[0] == 1);
...	...	@@ -156,6 +163,7 @@ test "array len field" {
156	163	test "array with sentinels" {
157	164	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
158	165	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	166	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
159	167
160	168	const S = struct {
161	169	fn doTheTest(is_ct: bool) !void {
...	...	@@ -193,6 +201,7 @@ test "nested arrays of strings" {
193	201	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
194	202	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
195	203	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	204	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
196	205
197	206	const array_of_strings = [_][]const u8{ "hello", "this", "is", "my", "thing" };
198	207	for (array_of_strings, 0..) \|s, i\| {
...	...	@@ -222,6 +231,7 @@ test "nested arrays of integers" {
222	231	test "implicit comptime in array type size" {
223	232	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
224	233	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	234	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
225	235
226	236	var arr: [plusOne(10)]bool = undefined;
227	237	try expect(arr.len == 11);
...	...	@@ -234,6 +244,7 @@ fn plusOne(x: u32) u32 {
234	244	test "single-item pointer to array indexing and slicing" {
235	245	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
236	246	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	247	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
237	248
238	249	try testSingleItemPtrArrayIndexSlice();
239	250	comptime try testSingleItemPtrArrayIndexSlice();
...	...	@@ -259,6 +270,7 @@ fn doSomeMangling(array: *[4]u8) void {
259	270
260	271	test "implicit cast zero sized array ptr to slice" {
261	272	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	273	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
262	274
263	275	{
264	276	var b = "".*;
...	...	@@ -276,6 +288,7 @@ test "anonymous list literal syntax" {
276	288	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
277	289	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
278	290	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	291	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
279	292
280	293	const S = struct {
281	294	fn doTheTest() !void {
...	...	@@ -296,6 +309,7 @@ const Str = struct { a: []Sub };
296	309	test "set global var array via slice embedded in struct" {
297	310	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
298	311	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	312	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
299	313
300	314	var s = Str{ .a = s_array[0..] };
301	315
...	...	@@ -312,6 +326,7 @@ test "read/write through global variable array of struct fields initialized via
312	326	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
313	327	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
314	328	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	329	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
315	330
316	331	const S = struct {
317	332	fn doTheTest() !void {
...	...	@@ -332,6 +347,7 @@ test "read/write through global variable array of struct fields initialized via
332	347	test "implicit cast single-item pointer" {
333	348	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
334	349	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	350	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
335	351
336	352	try testImplicitCastSingleItemPtr();
337	353	comptime try testImplicitCastSingleItemPtr();
...	...	@@ -351,6 +367,7 @@ fn testArrayByValAtComptime(b: [2]u8) u8 {
351	367	test "comptime evaluating function that takes array by value" {
352	368	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
353	369	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	370	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
354	371
355	372	const arr = [_]u8{ 1, 2 };
356	373	const x = comptime testArrayByValAtComptime(arr);
...	...	@@ -362,6 +379,7 @@ test "comptime evaluating function that takes array by value" {
362	379	test "runtime initialize array elem and then implicit cast to slice" {
363	380	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
364	381	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	382	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
365	383
366	384	var two: i32 = 2;
367	385	const x: []const i32 = &[_]i32{two};
...	...	@@ -371,6 +389,7 @@ test "runtime initialize array elem and then implicit cast to slice" {
371	389	test "array literal as argument to function" {
372	390	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
373	391	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	392	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
374	393
375	394	const S = struct {
376	395	fn entry(two: i32) !void {
...	...	@@ -399,6 +418,7 @@ test "double nested array to const slice cast in array literal" {
399	418	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
400	419	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
401	420	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	421	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
402	422
403	423	const S = struct {
404	424	fn entry(two: i32) !void {
...	...	@@ -460,6 +480,7 @@ test "anonymous literal in array" {
460	480	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
461	481	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
462	482	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	483	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
463	484
464	485	const S = struct {
465	486	const Foo = struct {
...	...	@@ -484,6 +505,7 @@ test "anonymous literal in array" {
484	505	test "access the null element of a null terminated array" {
485	506	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
486	507	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	508	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
487	509
488	510	const S = struct {
489	511	fn doTheTest() !void {
...	...	@@ -501,6 +523,7 @@ test "type deduction for array subscript expression" {
501	523	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
502	524	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
503	525	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	526	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
504	527
505	528	const S = struct {
506	529	fn doTheTest() !void {
...	...	@@ -519,6 +542,7 @@ test "sentinel element count towards the ABI size calculation" {
519	542	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
520	543	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
521	544	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	545	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
522	546
523	547	const S = struct {
524	548	fn doTheTest() !void {
...	...	@@ -542,6 +566,7 @@ test "sentinel element count towards the ABI size calculation" {
542	566	test "zero-sized array with recursive type definition" {
543	567	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
544	568	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	569	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
545	570
546	571	const U = struct {
547	572	fn foo(comptime T: type, comptime n: usize) type {
...	...	@@ -564,6 +589,7 @@ test "type coercion of anon struct literal to array" {
564	589	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
565	590	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
566	591	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	592	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
567	593
568	594	const S = struct {
569	595	const U = union {
...	...	@@ -596,6 +622,7 @@ test "type coercion of pointer to anon struct literal to pointer to array" {
596	622	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
597	623	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
598	624	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	625	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
599	626
600	627	const S = struct {
601	628	const U = union {
...	...	@@ -634,6 +661,7 @@ test "tuple to array handles sentinel" {
634	661	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
635	662	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
636	663	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	664	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
637	665
638	666	const S = struct {
639	667	const a = .{ 1, 2, 3 };
...	...	@@ -646,6 +674,7 @@ test "array init of container level array variable" {
646	674	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
647	675	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
648	676	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	677	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
649	678
650	679	const S = struct {
651	680	var pair: [2]usize = .{ 1, 2 };
...	...	@@ -676,6 +705,7 @@ test "array of array agregate init" {
676	705	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
677	706	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
678	707	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	708	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
679	709
680	710	var a = [1]u32{11} ** 10;
681	711	var b = [1][10]u32{a} ** 2;

test/behavior/asm.zig+4

...	...	@@ -24,6 +24,7 @@ test "module level assembly" {
24	24	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
25	25	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
26	26	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	27	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
27	28
28	29	if (builtin.zig_backend == .stage2_c and builtin.os.tag == .windows) return error.SkipZigTest; // MSVC doesn't support inline assembly
29	30
...	...	@@ -38,6 +39,7 @@ test "output constraint modifiers" {
38	39	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
39	40	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
40	41	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	42	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
41	43
42	44	if (builtin.zig_backend == .stage2_c and builtin.os.tag == .windows) return error.SkipZigTest; // MSVC doesn't support inline assembly
43	45
...	...	@@ -61,6 +63,7 @@ test "alternative constraints" {
61	63	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
62	64	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
63	65	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	66	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
64	67
65	68	if (builtin.zig_backend == .stage2_c and builtin.os.tag == .windows) return error.SkipZigTest; // MSVC doesn't support inline assembly
66	69
...	...	@@ -79,6 +82,7 @@ test "sized integer/float in asm input" {
79	82	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
80	83	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
81	84	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	85	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
82	86
83	87	if (builtin.zig_backend == .stage2_c and builtin.os.tag == .windows) return error.SkipZigTest; // MSVC doesn't support inline assembly
84	88

test/behavior/atomics.zig+15

...	...	@@ -14,6 +14,7 @@ test "cmpxchg" {
14	14	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
15	15	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
16	16	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	17	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
17	18
18	19	try testCmpxchg();
19	20	comptime try testCmpxchg();
...	...	@@ -39,6 +40,7 @@ fn testCmpxchg() !void {
39	40	test "fence" {
40	41	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
41	42	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	43	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
42	44
43	45	var x: i32 = 1234;
44	46	@fence(.SeqCst);
...	...	@@ -49,6 +51,7 @@ test "atomicrmw and atomicload" {
49	51	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
50	52	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
51	53	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	54	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
52	55
53	56	var data: u8 = 200;
54	57	try testAtomicRmw(&data);
...	...	@@ -76,6 +79,7 @@ test "cmpxchg with ptr" {
76	79	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
77	80	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
78	81	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	82	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
79	83
80	84	var data1: i32 = 1234;
81	85	var data2: i32 = 5678;
...	...	@@ -100,6 +104,7 @@ test "cmpxchg with ignored result" {
100	104	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
101	105	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
102	106	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	107	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
103	108
104	109	var x: i32 = 1234;
105	110
...	...	@@ -115,6 +120,7 @@ test "128-bit cmpxchg" {
115	120	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
116	121	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
117	122	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	123	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
118	124
119	125	try test_u128_cmpxchg();
120	126	comptime try test_u128_cmpxchg();
...	...	@@ -143,6 +149,7 @@ test "cmpxchg on a global variable" {
143	149	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
144	150	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
145	151	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	152	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
146	153
147	154	if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .aarch64) {
148	155	// https://github.com/ziglang/zig/issues/10627
...	...	@@ -157,6 +164,7 @@ test "atomic load and rmw with enum" {
157	164	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
158	165	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
159	166	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	167	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
160	168
161	169	const Value = enum(u8) { a, b, c };
162	170	var x = Value.a;
...	...	@@ -173,6 +181,7 @@ test "atomic store" {
173	181	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
174	182	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
175	183	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	184	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
176	185
177	186	var x: u32 = 0;
178	187	@atomicStore(u32, &x, 1, .SeqCst);
...	...	@@ -185,6 +194,7 @@ test "atomic store comptime" {
185	194	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
186	195	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
187	196	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	197	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
188	198
189	199	comptime try testAtomicStore();
190	200	try testAtomicStore();
...	...	@@ -203,6 +213,7 @@ test "atomicrmw with floats" {
203	213	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
204	214	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
205	215	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	216	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
206	217
207	218	if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .aarch64) {
208	219	// https://github.com/ziglang/zig/issues/10627
...	...	@@ -231,6 +242,7 @@ test "atomicrmw with ints" {
231	242	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
232	243	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
233	244	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	245	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
234	246
235	247	try testAtomicRmwInts();
236	248	comptime try testAtomicRmwInts();
...	...	@@ -301,6 +313,7 @@ test "atomicrmw with 128-bit ints" {
301	313
302	314	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
303	315	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
	316	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
304	317
305	318	// TODO "ld.lld: undefined symbol: __sync_lock_test_and_set_16" on -mcpu x86_64
306	319	if (builtin.cpu.arch == .x86_64 and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
...	...	@@ -376,6 +389,7 @@ test "atomics with different types" {
376	389	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
377	390	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
378	391	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	392	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
379	393
380	394	try testAtomicsWithType(bool, true, false);
381	395
...	...	@@ -404,6 +418,7 @@ test "return @atomicStore, using it as a void value" {
404	418	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
405	419	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
406	420	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	421	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
407	422
408	423	const S = struct {
409	424	const A = struct {

test/behavior/basic.zig+55

...	...	@@ -42,6 +42,7 @@ test "truncate to non-power-of-two integers from 128-bit" {
42	42	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
43	43	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
44	44	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	45	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
45	46
46	47	try testTrunc(u128, u1, 0xffffffff_ffffffff_ffffffff_01010101, 0x01);
47	48	try testTrunc(u128, u1, 0xffffffff_ffffffff_ffffffff_01010110, 0x00);
...	...	@@ -81,6 +82,8 @@ test "type equality" {
81	82	}
82	83
83	84	test "pointer dereferencing" {
	85	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	86
84	87	var x = @as(i32, 3);
85	88	const y = &x;
86	89
...	...	@@ -131,18 +134,21 @@ fn first4KeysOfHomeRow() []const u8 {
131	134
132	135	test "return string from function" {
133	136	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	137	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
134	138
135	139	try expect(mem.eql(u8, first4KeysOfHomeRow(), "aoeu"));
136	140	}
137	141
138	142	test "hex escape" {
139	143	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	144	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
140	145
141	146	try expect(mem.eql(u8, "\x68\x65\x6c\x6c\x6f", "hello"));
142	147	}
143	148
144	149	test "multiline string" {
145	150	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	151	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
146	152
147	153	const s1 =
148	154	\\one
...	...	@@ -155,6 +161,7 @@ test "multiline string" {
155	161
156	162	test "multiline string comments at start" {
157	163	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	164	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
158	165
159	166	const s1 =
160	167	//\\one
...	...	@@ -167,6 +174,7 @@ test "multiline string comments at start" {
167	174
168	175	test "multiline string comments at end" {
169	176	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	177	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
170	178
171	179	const s1 =
172	180	\\one
...	...	@@ -179,6 +187,7 @@ test "multiline string comments at end" {
179	187
180	188	test "multiline string comments in middle" {
181	189	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	190	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
182	191
183	192	const s1 =
184	193	\\one
...	...	@@ -191,6 +200,7 @@ test "multiline string comments in middle" {
191	200
192	201	test "multiline string comments at multiple places" {
193	202	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	203	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
194	204
195	205	const s1 =
196	206	\\one
...	...	@@ -204,11 +214,14 @@ test "multiline string comments at multiple places" {
204	214	}
205	215
206	216	test "string concatenation simple" {
	217	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	218
207	219	try expect(mem.eql(u8, "OK" ++ " IT " ++ "WORKED", "OK IT WORKED"));
208	220	}
209	221
210	222	test "array mult operator" {
211	223	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	224	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
212	225
213	226	try expect(mem.eql(u8, "ab" ** 5, "ababababab"));
214	227	}
...	...	@@ -218,6 +231,7 @@ const OpaqueB = opaque {};
218	231
219	232	test "opaque types" {
220	233	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	234	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
221	235
222	236	try expect(OpaqueA != OpaqueB);
223	237
...	...	@@ -289,6 +303,8 @@ test "function closes over local const" {
289	303	}
290	304
291	305	test "volatile load and store" {
	306	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	307
292	308	var number: i32 = 1234;
293	309	const ptr = @as(*volatile i32, &number);
294	310	ptr.* += 1;
...	...	@@ -304,6 +320,7 @@ fn fB() []const u8 {
304	320
305	321	test "call function pointer in struct" {
306	322	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	323	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
307	324
308	325	try expect(mem.eql(u8, f3(true), "a"));
309	326	try expect(mem.eql(u8, f3(false), "b"));
...	...	@@ -327,6 +344,7 @@ const FnPtrWrapper = struct {
327	344
328	345	test "const ptr from var variable" {
329	346	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
	347	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
330	348
331	349	var x: u64 = undefined;
332	350	var y: u64 = undefined;
...	...	@@ -345,6 +363,7 @@ test "call result of if else expression" {
345	363	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
346	364	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
347	365	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	366	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
348	367
349	368	try expect(mem.eql(u8, f2(true), "a"));
350	369	try expect(mem.eql(u8, f2(false), "b"));
...	...	@@ -354,6 +373,8 @@ fn f2(x: bool) []const u8 {
354	373	}
355	374
356	375	test "variable is allowed to be a pointer to an opaque type" {
	376	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	377
357	378	var x: i32 = 1234;
358	379	_ = hereIsAnOpaqueType(@ptrCast(*OpaqueA, &x));
359	380	}
...	...	@@ -366,6 +387,7 @@ test "take address of parameter" {
366	387	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
367	388	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
368	389	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	390	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
369	391
370	392	try testTakeAddressOfParameter(12.34);
371	393	}
...	...	@@ -375,6 +397,8 @@ fn testTakeAddressOfParameter(f: f32) !void {
375	397	}
376	398
377	399	test "pointer to void return type" {
	400	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	401
378	402	try testPointerToVoidReturnType();
379	403	}
380	404	fn testPointerToVoidReturnType() anyerror!void {
...	...	@@ -391,6 +415,7 @@ test "array 2D const double ptr" {
391	415	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
392	416	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
393	417	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
	418	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
394	419
395	420	const rect_2d_vertexes = [_][1]f32{
396	421	[_]f32{1.0},
...	...	@@ -404,6 +429,7 @@ test "array 2D const double ptr with offset" {
404	429	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
405	430	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
406	431	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
	432	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
407	433
408	434	const rect_2d_vertexes = [_][2]f32{
409	435	[_]f32{ 3.0, 4.239 },
...	...	@@ -417,6 +443,7 @@ test "array 3D const double ptr with offset" {
417	443	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
418	444	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
419	445	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
	446	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
420	447
421	448	const rect_3d_vertexes = [_][2][2]f32{
422	449	[_][2]f32{
...	...	@@ -450,6 +477,7 @@ fn nine() u8 {
450	477	test "struct inside function" {
451	478	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
452	479	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	480	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
453	481
454	482	try testStructInFn();
455	483	comptime try testStructInFn();
...	...	@@ -471,6 +499,7 @@ fn testStructInFn() !void {
471	499
472	500	test "fn call returning scalar optional in equality expression" {
473	501	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	502	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
474	503	try expect(getNull() == null);
475	504	}
476	505
...	...	@@ -481,6 +510,7 @@ fn getNull() ?*i32 {
481	510	test "global variable assignment with optional unwrapping with var initialized to undefined" {
482	511	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
483	512	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	513	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
484	514
485	515	const S = struct {
486	516	var data: i32 = 1234;
...	...	@@ -569,11 +599,15 @@ test "comptime cast fn to ptr" {
569	599	}
570	600
571	601	test "equality compare fn ptrs" {
	602	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	603
572	604	var a = &emptyFn;
573	605	try expect(a == a);
574	606	}
575	607
576	608	test "self reference through fn ptr field" {
	609	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	610
577	611	const S = struct {
578	612	const A = struct {
579	613	f: *const fn (A) u8,
...	...	@@ -591,6 +625,7 @@ test "self reference through fn ptr field" {
591	625
592	626	test "global variable initialized to global variable array element" {
593	627	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	628	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
594	629
595	630	try expect(global_ptr == &gdt[0]);
596	631	}
...	...	@@ -622,6 +657,7 @@ test "global constant is loaded with a runtime-known index" {
622	657
623	658	test "multiline string literal is null terminated" {
624	659	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	660	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
625	661
626	662	const s1 =
627	663	\\one
...	...	@@ -636,6 +672,7 @@ test "string escapes" {
636	672	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
637	673	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
638	674	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	675	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
639	676
640	677	try expectEqualStrings("\"", "\x22");
641	678	try expectEqualStrings("\'", "\x27");
...	...	@@ -653,6 +690,8 @@ test "explicit cast optional pointers" {
653	690	}
654	691
655	692	test "pointer comparison" {
	693	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	694
656	695	const a = @as([]const u8, "a");
657	696	const b = &a;
658	697	try expect(ptrEql(b, b));
...	...	@@ -665,6 +704,7 @@ test "string concatenation" {
665	704	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
666	705	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
667	706	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	707	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
668	708
669	709	const a = "OK" ++ " IT " ++ "WORKED";
670	710	const b = "OK IT WORKED";
...	...	@@ -692,6 +732,7 @@ test "comptime manyptr concatenation" {
692	732	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
693	733	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
694	734	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	735	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
695	736
696	737	const s = "epic";
697	738	const actual = manyptrConcat(s);
...	...	@@ -713,6 +754,7 @@ test "result location is optional inside error union" {
713	754	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
714	755	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
715	756	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	757	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
716	758
717	759	const x = maybe(true) catch unreachable;
718	760	try expect(x.? == 42);
...	...	@@ -728,6 +770,7 @@ fn maybe(x: bool) anyerror!?u32 {
728	770	test "auto created variables have correct alignment" {
729	771	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
730	772	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	773	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
731	774
732	775	const S = struct {
733	776	fn foo(str: [*]const u8) u32 {
...	...	@@ -748,6 +791,7 @@ test "extern variable with non-pointer opaque type" {
748	791	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
749	792	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
750	793	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
	794	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
751	795
752	796	@export(var_to_export, .{ .name = "opaque_extern_var" });
753	797	try expect(@ptrCast(align(1) u32, &opaque_extern_var). == 42);
...	...	@@ -830,6 +874,7 @@ test "labeled block implicitly ends in a break" {
830	874	test "catch in block has correct result location" {
831	875	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
832	876	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	877	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
833	878
834	879	const S = struct {
835	880	fn open() error{A}!@This() {
...	...	@@ -847,6 +892,8 @@ test "catch in block has correct result location" {
847	892	}
848	893
849	894	test "labeled block with runtime branch forwards its result location type to break statements" {
	895	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	896
850	897	const E = enum { a, b };
851	898	var a = false;
852	899	const e: E = blk: {
...	...	@@ -1004,6 +1051,7 @@ comptime {
1004	1051
1005	1052	test "switch inside @as gets correct type" {
1006	1053	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	1054	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1007	1055
1008	1056	var a: u32 = 0;
1009	1057	var b: [2]u32 = undefined;
...	...	@@ -1014,6 +1062,8 @@ test "switch inside @as gets correct type" {
1014	1062	}
1015	1063
1016	1064	test "inline call of function with a switch inside the return statement" {
	1065	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1066
1017	1067	const S = struct {
1018	1068	inline fn foo(x: anytype) @TypeOf(x) {
1019	1069	return switch (x) {
...	...	@@ -1029,6 +1079,7 @@ test "namespace lookup ignores decl causing the lookup" {
1029	1079	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
1030	1080	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1031	1081	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	1082	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1032	1083
1033	1084	if (builtin.zig_backend == .stage2_llvm) {
1034	1085	// regressed with LLVM 15
...	...	@@ -1096,6 +1147,7 @@ test "returning an opaque type from a function" {
1096	1147	test "orelse coercion as function argument" {
1097	1148	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1098	1149	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	1150	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1099	1151
1100	1152	const Loc = struct { start: i32 = -1 };
1101	1153	const Container = struct {
...	...	@@ -1112,6 +1164,8 @@ test "orelse coercion as function argument" {
1112	1164	}
1113	1165
1114	1166	test "runtime-known globals initialized with undefined" {
	1167	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1168
1115	1169	const S = struct {
1116	1170	var array: [10]u32 = [_]u32{ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
1117	1171	var vp: [*]u32 = undefined;
...	...	@@ -1131,6 +1185,7 @@ test "arrays and vectors with big integers" {
1131	1185	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
1132	1186	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
1133	1187	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
	1188	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1134	1189
1135	1190	// TODO: only aarch64-windows didn't pass in the PR that added this code.
1136	1191	// figure out why if you can run this target.

test/behavior/bit_shifting.zig+1

...	...	@@ -64,6 +64,7 @@ test "sharded table" {
64	64	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
65	65	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
66	66	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	67	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
67	68
68	69	// realistic 16-way sharding
69	70	try testShardedTable(u32, 4, 8);

test/behavior/bitcast.zig+15

...	...	@@ -9,6 +9,7 @@ const native_endian = builtin.target.cpu.arch.endian();
9	9
10	10	test "@bitCast iX -> uX (32, 64)" {
11	11	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
	12	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
12	13
13	14	const bit_values = [_]usize{ 32, 64 };
14	15
...	...	@@ -22,6 +23,7 @@ test "@bitCast iX -> uX (8, 16, 128)" {
22	23	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
23	24	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
24	25	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	26	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
25	27
26	28	const bit_values = [_]usize{ 8, 16, 128 };
27	29
...	...	@@ -37,6 +39,7 @@ test "@bitCast iX -> uX exotic integers" {
37	39	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
38	40	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
39	41	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	42	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
40	43
41	44	const bit_values = [_]usize{ 1, 48, 27, 512, 493, 293, 125, 204, 112 };
42	45
...	...	@@ -83,6 +86,7 @@ test "bitcast uX to bytes" {
83	86	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
84	87	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
85	88	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	89	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
86	90
87	91	const bit_values = [_]usize{ 1, 48, 27, 512, 493, 293, 125, 204, 112 };
88	92	inline for (bit_values) \|bits\| {
...	...	@@ -150,6 +154,8 @@ test "bitcast literal [4]u8 param to u32" {
150	154	}
151	155
152	156	test "bitcast generates a temporary value" {
	157	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	158
153	159	var y = @as(u16, 0x55AA);
154	160	const x = @bitCast(u16, @bitCast([2]u8, y));
155	161	try expect(y == x);
...	...	@@ -159,6 +165,7 @@ test "@bitCast packed structs at runtime and comptime" {
159	165	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
160	166	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
161	167	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	168	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
162	169
163	170	const Full = packed struct {
164	171	number: u16,
...	...	@@ -184,6 +191,7 @@ test "@bitCast packed structs at runtime and comptime" {
184	191	test "@bitCast extern structs at runtime and comptime" {
185	192	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
186	193	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	194	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
187	195
188	196	const Full = extern struct {
189	197	number: u16,
...	...	@@ -216,6 +224,7 @@ test "bitcast packed struct to integer and back" {
216	224	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
217	225	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
218	226	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	227	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
219	228
220	229	const LevelUpMove = packed struct {
221	230	move_id: u9,
...	...	@@ -237,6 +246,7 @@ test "bitcast packed struct to integer and back" {
237	246	test "implicit cast to error union by returning" {
238	247	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
239	248	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	249	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
240	250
241	251	const S = struct {
242	252	fn entry() !void {
...	...	@@ -292,6 +302,7 @@ test "@bitCast packed struct of floats" {
292	302	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
293	303	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
294	304	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	305	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
295	306
296	307	const Foo = packed struct {
297	308	a: f16 = 0,
...	...	@@ -328,6 +339,7 @@ test "comptime @bitCast packed struct to int and back" {
328	339	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
329	340	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
330	341	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	342	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
331	343
332	344	if (builtin.zig_backend == .stage2_llvm and native_endian == .Big) {
333	345	// https://github.com/ziglang/zig/issues/13782
...	...	@@ -368,6 +380,7 @@ test "comptime bitcast with fields following f80" {
368	380	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
369	381	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
370	382	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	383	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
371	384
372	385	const FloatT = extern struct { f: f80, x: u128 align(16) };
373	386	const x: FloatT = .{ .f = 0.5, .x = 123 };
...	...	@@ -383,6 +396,7 @@ test "bitcast vector to integer and back" {
383	396	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
384	397	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
385	398	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
	399	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
386	400
387	401	const arr: [16]bool = [_]bool{ true, false } ++ [_]bool{true} ** 14;
388	402	var x = @splat(16, true);
...	...	@@ -408,6 +422,7 @@ test "bitcast nan float does modify signaling bit" {
408	422	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
409	423	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
410	424	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
	425	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
411	426	// TODO: https://github.com/ziglang/zig/issues/14366
412	427	if (builtin.cpu.arch == .arm and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
413	428

test/behavior/bitreverse.zig+5

...	...	@@ -5,6 +5,7 @@ const minInt = std.math.minInt;
5	5
6	6	test "@bitReverse large exotic integer" {
7	7	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
	8	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
8	9
9	10	try expect(@bitReverse(@as(u95, 0x123456789abcdef111213141)) == 0x4146424447bd9eac8f351624);
10	11	}
...	...	@@ -15,6 +16,7 @@ test "@bitReverse" {
15	16	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
16	17	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
17	18	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	19	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
18	20
19	21	comptime try testBitReverse();
20	22	try testBitReverse();
...	...	@@ -100,6 +102,7 @@ test "bitReverse vectors u8" {
100	102	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
101	103	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
102	104	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	105	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
103	106
104	107	comptime try vector8();
105	108	try vector8();
...	...	@@ -118,6 +121,7 @@ test "bitReverse vectors u16" {
118	121	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
119	122	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
120	123	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	124	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
121	125
122	126	comptime try vector16();
123	127	try vector16();
...	...	@@ -136,6 +140,7 @@ test "bitReverse vectors u24" {
136	140	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
137	141	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
138	142	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	143	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
139	144
140	145	comptime try vector24();
141	146	try vector24();

test/behavior/bool.zig+3

...	...	@@ -1,4 +1,5 @@
1	1	const std = @import("std");
	2	const builtin = @import("builtin");
2	3	const expect = std.testing.expect;
3	4
4	5	test "bool literals" {
...	...	@@ -7,6 +8,8 @@ test "bool literals" {
7	8	}
8	9
9	10	test "cast bool to int" {
	11	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	12
10	13	const t = true;
11	14	const f = false;
12	15	try expect(@boolToInt(t) == @as(u32, 1));

test/behavior/bugs/10138.zig+1

...	...	@@ -5,6 +5,7 @@ test "registers get overwritten when ignoring return" {
5	5	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
6	6	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
7	7	if (builtin.cpu.arch != .x86_64 or builtin.os.tag != .linux) return error.SkipZigTest;
	8	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
8	9
9	10	const fd = open();
10	11	_ = write(fd, "a", 1);

test/behavior/bugs/10147.zig+1

...	...	@@ -7,6 +7,7 @@ test "test calling @clz on both vector and scalar inputs" {
7	7	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
8	8	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
9	9	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	10	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
10	11
11	12	var x: u32 = 0x1;
12	13	var y: @Vector(4, u32) = [_]u32{ 0x1, 0x1, 0x1, 0x1 };

test/behavior/bugs/10684.zig+1

...	...	@@ -7,6 +7,7 @@ test "slicing slices" {
7	7	if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO
8	8	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
9	9	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	10	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
10	11
11	12	const foo = "1234";
12	13	const bar = foo[0..4];

test/behavior/bugs/1076.zig+1

...	...	@@ -6,6 +6,7 @@ const expect = std.testing.expect;
6	6	test "comptime code should not modify constant data" {
7	7	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
8	8	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	9	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
9	10
10	11	try testCastPtrOfArrayToSliceAndPtr();
11	12	comptime try testCastPtrOfArrayToSliceAndPtr();

test/behavior/bugs/10970.zig+1

...	...	@@ -7,6 +7,7 @@ test "breaking from a loop in an if statement" {
7	7	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
8	8	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
9	9	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	10	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
10	11
11	12	var cond = true;
12	13	const opt = while (cond) {

test/behavior/bugs/11046.zig+1

...	...	@@ -13,6 +13,7 @@ test "fixed" {
13	13	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
14	14	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
15	15	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	16	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
16	17
17	18	bar() catch \|err\| switch (err) {
18	19	error.Foo => {}, // error: expected (inferred error set of bar), found error{Foo}

test/behavior/bugs/11100.zig+4

...	...	@@ -1,4 +1,6 @@
1	1	const std = @import("std");
	2	const builtin = @import("builtin");
	3
2	4	pub fn do() bool {
3	5	inline for (.{"a"}) \|_\| {
4	6	if (true) return false;
...	...	@@ -7,5 +9,7 @@ pub fn do() bool {
7	9	}
8	10
9	11	test "bug" {
	12	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	13
10	14	try std.testing.expect(!do());
11	15	}

test/behavior/bugs/11139.zig+1

...	...	@@ -6,6 +6,7 @@ test "store array of array of structs at comptime" {
6	6	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
7	7	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
8	8	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	9	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
9	10
10	11	try expect(storeArrayOfArrayOfStructs() == 15);
11	12	comptime try expect(storeArrayOfArrayOfStructs() == 15);

test/behavior/bugs/11165.zig+2

...	...	@@ -2,6 +2,7 @@ const builtin = @import("builtin");
2	2
3	3	test "bytes" {
4	4	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	5	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
5	6
6	7	const S = struct {
7	8	a: u32,
...	...	@@ -23,6 +24,7 @@ test "bytes" {
23	24
24	25	test "aggregate" {
25	26	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	27	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
26	28
27	29	const S = struct {
28	30	a: u32,

test/behavior/bugs/11179.zig+1

...	...	@@ -1,4 +1,5 @@
1	1	const std = @import("std");
	2	const builtin = @import("builtin");
2	3	const Type = std.builtin.Type;
3	4
4	5	test "Tuple" {

test/behavior/bugs/11213.zig+2

...	...	@@ -3,6 +3,8 @@ const builtin = @import("builtin");
3	3	const testing = std.testing;
4	4
5	5	test {
	6	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	7
6	8	const g: error{Test}!void = error.Test;
7	9
8	10	var v: u32 = 0;

test/behavior/bugs/11787.zig+1

...	...	@@ -7,6 +7,7 @@ test "slicing zero length array field of struct" {
7	7	if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO
8	8	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
9	9	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	10	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
10	11
11	12	const S = struct {
12	13	a: [0]usize,

test/behavior/bugs/11816.zig+1

...	...	@@ -4,6 +4,7 @@ const builtin = @import("builtin");
4	4	test {
5	5	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
6	6	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	7	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
7	8
8	9	var x: u32 = 3;
9	10	const val: usize = while (true) switch (x) {

test/behavior/bugs/11995.zig+2

...	...	@@ -22,6 +22,8 @@ test {
22	22	if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO
23	23	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
24	24	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	25	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	26
25	27	var string: [5]u8 = "hello".*;
26	28	const arg_data = wuffs_base__slice_u8{ .ptr = @ptrCast([*c]u8, &string), .len = string.len };
27	29	var arg_meta = wuffs_base__io_buffer_meta{ .wi = 1, .ri = 2, .pos = 3, .closed = true };

test/behavior/bugs/12000.zig+2

...	...	@@ -10,6 +10,8 @@ test {
10	10	if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO
11	11	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
12	12	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	13	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	14
13	15	var t: T = .{ .next = null };
14	16	try std.testing.expect(t.next == null);
15	17	}

test/behavior/bugs/12025.zig+4

...	...	@@ -1,4 +1,8 @@
	1	const builtin = @import("builtin");
	2
1	3	test {
	4	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	5
2	6	comptime var st = .{
3	7	.foo = &1,
4	8	.bar = &2,

test/behavior/bugs/12033.zig+3

...	...	@@ -1,6 +1,9 @@
1	1	const std = @import("std");
	2	const builtin = @import("builtin");
2	3
3	4	test {
	5	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	6
4	7	const string = "Hello!\x00World!";
5	8	try std.testing.expect(@TypeOf(string) == *const [13:0]u8);
6	9

test/behavior/bugs/12043.zig+3

...	...	@@ -1,4 +1,5 @@
1	1	const std = @import("std");
	2	const builtin = @import("builtin");
2	3	const expect = std.testing.expect;
3	4
4	5	var ok = false;
...	...	@@ -6,6 +7,8 @@ fn foo(x: anytype) void {
6	7	ok = x;
7	8	}
8	9	test {
	10	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	11
9	12	const x = &foo;
10	13	x(true);
11	14	try expect(ok);

test/behavior/bugs/12051.zig+2

...	...	@@ -7,6 +7,8 @@ test {
7	7	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
8	8	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
9	9	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	10	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	11
10	12	const x = X{};
11	13	try std.testing.expectEqual(@as(u16, 0), x.y.a);
12	14	try std.testing.expectEqual(false, x.y.b);

test/behavior/bugs/12092.zig+2

...	...	@@ -18,6 +18,8 @@ test {
18	18	if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO
19	19	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
20	20	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	21	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	22
21	23	var baz: u32 = 24;
22	24	try takeFoo(&.{
23	25	.a = .{

test/behavior/bugs/12119.zig+2

...	...	@@ -9,6 +9,8 @@ test {
9	9	if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO
10	10	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
11	11	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	12	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	13
12	14	const zerox32: u8x32 = [_]u8{0} ** 32;
13	15	const bigsum: u32x8 = @bitCast(u32x8, zerox32);
14	16	try std.testing.expectEqual(0, @reduce(.Add, bigsum));

test/behavior/bugs/12142.zig+2

...	...	@@ -23,6 +23,8 @@ test {
23	23	if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO
24	24	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
25	25	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	26	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	27
26	28	const test_struct = Test{
27	29	.holders = &.{
28	30	Holder{

test/behavior/bugs/12450.zig+2

...	...	@@ -14,6 +14,8 @@ test {
14	14	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
15	15	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
16	16	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	17	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	18
17	19	var f1: align(16) Foo = @alignCast(16, @ptrCast(align(1) Foo, &buffer[0]));
18	20	try expect(@typeInfo(@TypeOf(f1)).Pointer.alignment == 16);
19	21	try expect(@ptrToInt(f1) == @ptrToInt(&f1.a));

test/behavior/bugs/12551.zig+1

...	...	@@ -4,6 +4,7 @@ const builtin = @import("builtin");
4	4	test {
5	5	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
6	6	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	7	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
7	8
8	9	try std.testing.expect(for ([1]u8{0}) \|x\| {
9	10	if (x == 0) break true;

test/behavior/bugs/12571.zig+1

...	...	@@ -14,6 +14,7 @@ const Entry = packed struct {
14	14	test {
15	15	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
16	16	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	17	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
17	18
18	19	const frame = Frame{ .num = 0x7FDE };
19	20	var entry = Entry{ .other = 0, .frame = .{ .num = 0xFFFFF } };

test/behavior/bugs/12644.zig+3

...	...	@@ -1,4 +1,5 @@
1	1	const std = @import("std");
	2	const builtin = @import("builtin");
2	3
3	4	inline fn foo(comptime T: type) !T {
4	5	return error.AnError;
...	...	@@ -9,6 +10,8 @@ fn main0() !void {
9	10	}
10	11
11	12	test "issue12644" {
	13	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	14
12	15	main0() catch \|e\| {
13	16	try std.testing.expect(e == error.AnError);
14	17	};

test/behavior/bugs/12680.zig+1

...	...	@@ -11,6 +11,7 @@ test "export a function twice" {
11	11	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
12	12	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
13	13	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	14	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
14	15	if (builtin.os.tag == .macos and builtin.zig_backend == .stage2_c) {
15	16	// TODO: test.c: error: aliases are not supported on darwin
16	17	return error.SkipZigTest;

test/behavior/bugs/1277.zig+1

...	...	@@ -16,6 +16,7 @@ test "don't emit an LLVM global for a const function when it's in an optional in
16	16	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
17	17	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
18	18	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	19	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
19	20
20	21	try std.testing.expect(s.f.?() == 1234);
21	22	}

test/behavior/bugs/12776.zig+1

...	...	@@ -32,6 +32,7 @@ test {
32	32	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
33	33	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
34	34	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
	35	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
35	36	if (builtin.zig_backend == .stage2_x86_64) {
36	37	// Careful enabling this test, fails randomly.
37	38	return error.SkipZigTest;

test/behavior/bugs/12801-2.zig+1

...	...	@@ -18,6 +18,7 @@ test {
18	18	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
19	19	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
20	20	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	21	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
21	22
22	23	const a: Auto = .{ .offset = 16, .capacity = Auto.capacity };
23	24	try std.testing.expect(a.capacity() == 32);

test/behavior/bugs/12890.zig+1

...	...	@@ -11,6 +11,7 @@ fn a(b: []u3, c: u3) void {
11	11	test {
12	12	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
13	13	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	14	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
14	15
15	16	var arr: [8]u3 = undefined;
16	17	a(&arr, 5);

test/behavior/bugs/12891.zig+14

...	...	@@ -7,21 +7,29 @@ test "issue12891" {
7	7	try std.testing.expect(i < f);
8	8	}
9	9	test "nan" {
	10	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	11
10	12	const f = comptime std.math.nan(f64);
11	13	var i: usize = 0;
12	14	try std.testing.expect(!(f < i));
13	15	}
14	16	test "inf" {
	17	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	18
15	19	const f = comptime std.math.inf(f64);
16	20	var i: usize = 0;
17	21	try std.testing.expect(f > i);
18	22	}
19	23	test "-inf < 0" {
	24	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	25
20	26	const f = comptime -std.math.inf(f64);
21	27	var i: usize = 0;
22	28	try std.testing.expect(f < i);
23	29	}
24	30	test "inf >= 1" {
	31	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	32
25	33	const f = comptime std.math.inf(f64);
26	34	var i: usize = 1;
27	35	try std.testing.expect(f >= i);
...	...	@@ -29,6 +37,7 @@ test "inf >= 1" {
29	37	test "isNan(nan * 1)" {
30	38	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
31	39	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	40	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
32	41
33	42	const nan_times_one = comptime std.math.nan(f64) * 1;
34	43	try std.testing.expect(std.math.isNan(nan_times_one));
...	...	@@ -36,6 +45,7 @@ test "isNan(nan * 1)" {
36	45	test "runtime isNan(nan * 1)" {
37	46	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
38	47	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	48	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
39	49
40	50	const nan_times_one = std.math.nan(f64) * 1;
41	51	try std.testing.expect(std.math.isNan(nan_times_one));
...	...	@@ -43,6 +53,7 @@ test "runtime isNan(nan * 1)" {
43	53	test "isNan(nan * 0)" {
44	54	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
45	55	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	56	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
46	57
47	58	const nan_times_zero = comptime std.math.nan(f64) * 0;
48	59	try std.testing.expect(std.math.isNan(nan_times_zero));
...	...	@@ -52,6 +63,7 @@ test "isNan(nan * 0)" {
52	63	test "isNan(inf * 0)" {
53	64	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
54	65	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	66	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
55	67
56	68	const inf_times_zero = comptime std.math.inf(f64) * 0;
57	69	try std.testing.expect(std.math.isNan(inf_times_zero));
...	...	@@ -61,6 +73,7 @@ test "isNan(inf * 0)" {
61	73	test "runtime isNan(nan * 0)" {
62	74	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
63	75	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	76	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
64	77
65	78	const nan_times_zero = std.math.nan(f64) * 0;
66	79	try std.testing.expect(std.math.isNan(nan_times_zero));
...	...	@@ -70,6 +83,7 @@ test "runtime isNan(nan * 0)" {
70	83	test "runtime isNan(inf * 0)" {
71	84	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
72	85	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	86	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
73	87
74	88	const inf_times_zero = std.math.inf(f64) * 0;
75	89	try std.testing.expect(std.math.isNan(inf_times_zero));

test/behavior/bugs/12928.zig+8

...	...	@@ -1,5 +1,7 @@
1	1	const std = @import("std");
	2	const builtin = @import("builtin");
2	3	const expect = std.testing.expect;
	4
3	5	const A = extern struct {
4	6	value: *volatile B,
5	7	};
...	...	@@ -7,11 +9,15 @@ const B = extern struct {
7	9	a: u32,
8	10	b: i32,
9	11	};
	12
10	13	test {
	14	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	15
11	16	var a: *A = undefined;
12	17	try expect(@TypeOf(&a.value.a) == *volatile u32);
13	18	try expect(@TypeOf(&a.value.b) == *volatile i32);
14	19	}
	20
15	21	const C = extern struct {
16	22	value: *volatile D,
17	23	};
...	...	@@ -20,6 +26,8 @@ const D = extern union {
20	26	b: i32,
21	27	};
22	28	test {
	29	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	30
23	31	var c: *C = undefined;
24	32	try expect(@TypeOf(&c.value.a) == *volatile u32);
25	33	try expect(@TypeOf(&c.value.b) == *volatile i32);

test/behavior/bugs/12972.zig+1

...	...	@@ -6,6 +6,7 @@ test {
6	6	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
7	7	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
8	8	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	9	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
9	10
10	11	const c: u8 = 42;
11	12	f(&[_:null]?u8{c});

test/behavior/bugs/12984.zig+1

...	...	@@ -14,6 +14,7 @@ pub const CustomDraw = DeleagateWithContext(fn (?OnConfirm) void);
14	14	test "simple test" {
15	15	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
16	16	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	17	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
17	18
18	19	var c: CustomDraw = undefined;
19	20	_ = c;

test/behavior/bugs/13064.zig+1

...	...	@@ -6,6 +6,7 @@ test {
6	6	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
7	7	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
8	8	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	9	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
9	10
10	11	var x: [10][10]u32 = undefined;
11	12

test/behavior/bugs/13065.zig+1

...	...	@@ -11,6 +11,7 @@ test {
11	11	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
12	12	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
13	13	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	14	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
14	15
15	16	var x = U{ .array = undefined };
16	17

test/behavior/bugs/13068.zig+1

...	...	@@ -9,6 +9,7 @@ test {
9	9	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
10	10	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
11	11	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	12	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
12	13
13	14	list.items.len = 0;
14	15	}

test/behavior/bugs/13069.zig+1

...	...	@@ -6,6 +6,7 @@ test {
6	6	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
7	7	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
8	8	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	9	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
9	10
10	11	var opt_x: ?[3]f32 = [_]f32{0.0} ** 3;
11	12

test/behavior/bugs/13113.zig+2

...	...	@@ -11,6 +11,8 @@ test {
11	11	if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO
12	12	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
13	13	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	14	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	15
14	16	const foo = Foo{
15	17	.a = 1,
16	18	.b = 2,

test/behavior/bugs/13128.zig+1

...	...	@@ -17,6 +17,7 @@ test "runtime union init, most-aligned field != largest" {
17	17	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
18	18	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
19	19	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	20	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
20	21
21	22	var x: u8 = 1;
22	23	try foo(.{ .x = x });

test/behavior/bugs/13159.zig+2

...	...	@@ -11,6 +11,8 @@ const Bar = packed struct {
11	11
12	12	test {
13	13	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	14	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	15
14	16	var foo = Bar.Baz.fizz;
15	17	try expect(foo == .fizz);
16	18	}

test/behavior/bugs/13285.zig+1

...	...	@@ -6,6 +6,7 @@ const Crasher = struct {
6	6
7	7	test {
8	8	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	9	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
9	10
10	11	var a: Crasher = undefined;
11	12	var crasher_ptr = &a;

test/behavior/bugs/13366.zig+1

...	...	@@ -18,6 +18,7 @@ test {
18	18	if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO
19	19	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
20	20	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	21	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
21	22
22	23	var a: u32 = 16;
23	24	var reason = .{ .c_import = .{ .a = a } };

test/behavior/bugs/13664.zig+1

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

test/behavior/bugs/13785.zig+1

...	...	@@ -6,6 +6,7 @@ test {
6	6	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
7	7	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
8	8	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	9	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
9	10
10	11	var a: u8 = 0;
11	12	try std.io.null_writer.print("\n{} {}\n", .{ a, S{} });

test/behavior/bugs/1381.zig+1

...	...	@@ -17,6 +17,7 @@ test "union that needs padding bytes inside an array" {
17	17	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
18	18	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
19	19	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	20	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
20	21
21	22	var as = [_]A{
22	23	A{ .B = B{ .D = 1 } },

test/behavior/bugs/1442.zig+2

...	...	@@ -10,6 +10,8 @@ test "const error union field alignment" {
10	10	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
11	11	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
12	12	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	13	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	14
13	15	var union_or_err: anyerror!Union = Union{ .Color = 1234 };
14	16	try std.testing.expect((union_or_err catch unreachable).Color == 1234);
15	17	}

test/behavior/bugs/14854.zig+3

...	...	@@ -1,6 +1,9 @@
1	1	const testing = @import("std").testing;
	2	const builtin = @import("builtin");
2	3
3	4	test {
	5	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	6
4	7	try testing.expect(getGeneric(u8, getU8) == 123);
5	8	}
6	9

test/behavior/bugs/1500.zig+2

...	...	@@ -6,6 +6,8 @@ const A = struct {
6	6	const B = *const fn (A) void;
7	7
8	8	test "allow these dependencies" {
	9	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	10
9	11	var a: A = undefined;
10	12	var b: B = undefined;
11	13	if (false) {

test/behavior/bugs/1607.zig+2

...	...	@@ -14,6 +14,8 @@ test "slices pointing at the same address as global array." {
14	14	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
15	15	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
16	16	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	17	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	18
17	19	try checkAddress(&a);
18	20	comptime try checkAddress(&a);
19	21	}

test/behavior/bugs/1735.zig+2

...	...	@@ -44,6 +44,8 @@ const a = struct {
44	44	test "initialization" {
45	45	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
46	46	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	47	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	48
47	49	var t = a.init();
48	50	try std.testing.expect(t.foo.len == 0);
49	51	}

test/behavior/bugs/1741.zig+1

...	...	@@ -5,6 +5,7 @@ test "fixed" {
5	5	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
6	6	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
7	7	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	8	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
8	9
9	10	const x: f32 align(128) = 12.34;
10	11	try std.testing.expect(@ptrToInt(&x) % 128 == 0);

test/behavior/bugs/1851.zig+1

...	...	@@ -7,6 +7,7 @@ test "allocation and looping over 3-byte integer" {
7	7	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
8	8	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
9	9	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	10	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
10	11
11	12	if (builtin.zig_backend == .stage2_llvm and builtin.os.tag == .macos) {
12	13	return error.SkipZigTest; // TODO

test/behavior/bugs/1914.zig+4

...	...	@@ -12,6 +12,8 @@ const b_list: []B = &[_]B{};
12	12	const a = A{ .b_list_pointer = &b_list };
13	13
14	14	test "segfault bug" {
	15	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	16
15	17	const assert = std.debug.assert;
16	18	const obj = B{ .a_pointer = &a };
17	19	assert(obj.a_pointer == &a); // this makes zig crash
...	...	@@ -28,5 +30,7 @@ pub const B2 = struct {
28	30	var b_value = B2{ .pointer_array = &[_]*A2{} };
29	31
30	32	test "basic stuff" {
	33	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	34
31	35	std.debug.assert(&b_value == &b_value);
32	36	}

test/behavior/bugs/2006.zig+1

...	...	@@ -7,6 +7,7 @@ const S = struct {
7	7	};
8	8	test "bug 2006" {
9	9	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	10	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
10	11
11	12	var a: S = undefined;
12	13	a = S{ .p = undefined };

test/behavior/bugs/2114.zig+1

...	...	@@ -14,6 +14,7 @@ test "fixed" {
14	14	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
15	15	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
16	16	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	17	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
17	18
18	19	try testCtz();
19	20	comptime try testCtz();

test/behavior/bugs/2578.zig+1

...	...	@@ -15,6 +15,7 @@ test "fixed" {
15	15	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
16	16	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
17	17	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	18	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
18	19
19	20	bar(t);
20	21	}

test/behavior/bugs/2622.zig+1

...	...	@@ -7,6 +7,7 @@ test "reslice of undefined global var slice" {
7	7	if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO
8	8	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
9	9	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	10	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
10	11
11	12	var mem: [100]u8 = [_]u8{0} ** 100;
12	13	buf = &mem;

test/behavior/bugs/2692.zig+1

...	...	@@ -7,6 +7,7 @@ fn foo(a: []u8) void {
7	7	test "address of 0 length array" {
8	8	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
9	9	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	10	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
10	11
11	12	var pt: [0]u8 = undefined;
12	13	foo(&pt);

test/behavior/bugs/3007.zig+1

...	...	@@ -22,6 +22,7 @@ test "fixed" {
22	22	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
23	23	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
24	24	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	25	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
25	26
26	27	default_foo = get_foo() catch null; // This Line
27	28	try std.testing.expect(!default_foo.?.free);

test/behavior/bugs/3046.zig+1

...	...	@@ -16,6 +16,7 @@ test "fixed" {
16	16	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
17	17	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
18	18	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	19	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
19	20
20	21	some_struct = SomeStruct{
21	22	.field = couldFail() catch @as(i32, 0),

test/behavior/bugs/3112.zig+2

...	...	@@ -15,6 +15,8 @@ test "zig test crash" {
15	15	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
16	16	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
17	17	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	18	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	19
18	20	var global: State = undefined;
19	21	global.enter = prev;
20	22	global.enter(null);

test/behavior/bugs/3367.zig+2

...	...	@@ -10,6 +10,8 @@ const Mixin = struct {
10	10	};
11	11
12	12	test "container member access usingnamespace decls" {
	13	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	14
13	15	var foo = Foo{};
14	16	foo.two();
15	17	}

test/behavior/bugs/3742.zig+2

...	...	@@ -40,5 +40,7 @@ test "fixed" {
40	40	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
41	41	if (builtin.zig_backend == .stage2_llvm and
42	42	builtin.cpu.arch == .aarch64 and builtin.os.tag == .windows) return error.SkipZigTest;
	43	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	44
43	45	ArgSerializer.serializeCommand(GET.init("banana"));
44	46	}

test/behavior/bugs/3779.zig+5

...	...	@@ -8,6 +8,7 @@ const ptr_tag_name: [*:0]const u8 = tag_name;
8	8	test "@tagName() returns a string literal" {
9	9	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
10	10	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	11	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
11	12
12	13	try std.testing.expect(*const [13:0]u8 == @TypeOf(tag_name));
13	14	try std.testing.expect(std.mem.eql(u8, "TestEnumValue", tag_name));
...	...	@@ -21,6 +22,7 @@ const ptr_error_name: [*:0]const u8 = error_name;
21	22	test "@errorName() returns a string literal" {
22	23	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
23	24	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	25	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
24	26
25	27	try std.testing.expect(*const [13:0]u8 == @TypeOf(error_name));
26	28	try std.testing.expect(std.mem.eql(u8, "TestErrorCode", error_name));
...	...	@@ -34,6 +36,7 @@ const ptr_type_name: [*:0]const u8 = type_name;
34	36	test "@typeName() returns a string literal" {
35	37	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
36	38	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	39	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
37	40
38	41	try std.testing.expect(*const [type_name.len:0]u8 == @TypeOf(type_name));
39	42	try std.testing.expect(std.mem.eql(u8, "behavior.bugs.3779.TestType", type_name));
...	...	@@ -47,6 +50,7 @@ const expected_contents = "hello zig\n";
47	50	test "@embedFile() returns a string literal" {
48	51	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
49	52	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	53	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
50	54
51	55	try std.testing.expect(*const [expected_contents.len:0]u8 == @TypeOf(actual_contents));
52	56	try std.testing.expect(std.mem.eql(u8, expected_contents, actual_contents));
...	...	@@ -61,6 +65,7 @@ fn testFnForSrc() std.builtin.SourceLocation {
61	65	test "@src() returns a struct containing 0-terminated string slices" {
62	66	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
63	67	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	68	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
64	69
65	70	const src = testFnForSrc();
66	71	try std.testing.expect([:0]const u8 == @TypeOf(src.file));

test/behavior/bugs/421.zig+1

...	...	@@ -5,6 +5,7 @@ test "bitCast to array" {
5	5	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
6	6	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
7	7	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	8	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
8	9
9	10	comptime try testBitCastArray();
10	11	try testBitCastArray();

test/behavior/bugs/4328.zig+5

...	...	@@ -17,6 +17,8 @@ const S = extern struct {
17	17	};
18	18
19	19	test "Extern function calls in @TypeOf" {
	20	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	21
20	22	const Test = struct {
21	23	fn test_fn_1(a: anytype, b: anytype) @TypeOf(c_printf("%d %s\n", a, b)) {
22	24	return 0;
...	...	@@ -37,6 +39,8 @@ test "Extern function calls in @TypeOf" {
37	39	}
38	40
39	41	test "Peer resolution of extern function calls in @TypeOf" {
	42	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	43
40	44	const Test = struct {
41	45	fn test_fn() @TypeOf(c_ftell(null), c_fputs(null, null)) {
42	46	return 0;
...	...	@@ -54,6 +58,7 @@ test "Peer resolution of extern function calls in @TypeOf" {
54	58	test "Extern function calls, dereferences and field access in @TypeOf" {
55	59	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
56	60	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	61	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
57	62
58	63	const Test = struct {
59	64	fn test_fn_1(a: c_long) @TypeOf(c_fopen("test", "r").*) {

test/behavior/bugs/4954.zig+1

...	...	@@ -8,6 +8,7 @@ test "crash" {
8	8	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
9	9	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
10	10	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	11	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
11	12
12	13	var buf: [4096]u8 = undefined;
13	14	f(&buf);

test/behavior/bugs/529.zig+1

...	...	@@ -16,6 +16,7 @@ test "issue 529 fixed" {
16	16	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
17	17	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
18	18	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	19	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
19	20
20	21	@import("529_other_file.zig").issue529(null);
21	22	issue529(null);

test/behavior/bugs/5398.zig+1

...	...	@@ -22,6 +22,7 @@ test "assignment of field with padding" {
22	22	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
23	23	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
24	24	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	25	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
25	26
26	27	renderable = Renderable{
27	28	.mesh = Mesh{ .id = 0 },

test/behavior/bugs/6047.zig+1

...	...	@@ -14,6 +14,7 @@ test "`try`ing an if/else expression" {
14	14	if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO
15	15	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
16	16	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	17	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
17	18
18	19	try @import("std").testing.expectError(error.Test, getError2());
19	20	}

test/behavior/bugs/6456.zig+1

...	...	@@ -13,6 +13,7 @@ const text =
13	13	test "issue 6456" {
14	14	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
15	15	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	16	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
16	17
17	18	comptime {
18	19	var fields: []const StructField = &[0]StructField{};

test/behavior/bugs/656.zig+2

...	...	@@ -14,6 +14,8 @@ test "optional if after an if in a switch prong of a switch with 2 prongs in an
14	14	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
15	15	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
16	16	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	17	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	18
17	19	try foo(false, true);
18	20	}
19	21

test/behavior/bugs/6781.zig+1

...	...	@@ -68,6 +68,7 @@ test "fixed" {
68	68	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
69	69	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
70	70	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	71	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
71	72
72	73	var buffer align(@alignOf(JournalHeader)) = [_]u8{0} ** 65536;
73	74	var entry = std.mem.bytesAsValue(JournalHeader, buffer[0..@sizeOf(JournalHeader)]);

test/behavior/bugs/6905.zig+1

...	...	@@ -6,6 +6,7 @@ test "sentinel-terminated 0-length slices" {
6	6	if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO
7	7	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
8	8	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	9	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
9	10
10	11	var u32s: [4]u32 = [_]u32{ 0, 1, 2, 3 };
11	12

test/behavior/bugs/6947.zig+1

...	...	@@ -9,6 +9,7 @@ test {
9	9	if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO
10	10	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
11	11	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	12	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
12	13
13	14	var slice: []void = undefined;
14	15	destroy(&slice[0]);

test/behavior/bugs/7047.zig+3

...	...	@@ -1,4 +1,5 @@
1	1	const std = @import("std");
	2	const builtin = @import("builtin");
2	3
3	4	const U = union(enum) {
4	5	T: type,
...	...	@@ -14,6 +15,8 @@ fn S(comptime query: U) type {
14	15	}
15	16
16	17	test "compiler doesn't consider equal unions with different 'type' payload" {
	18	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	19
17	20	const s1 = S(U{ .T = u32 }).tag();
18	21	try std.testing.expectEqual(u32, s1);
19	22

test/behavior/bugs/718.zig+1

...	...	@@ -13,6 +13,7 @@ test "zero keys with @memset" {
13	13	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
14	14	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
15	15	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	16	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
16	17
17	18	@memset(@ptrCast([*]u8, &keys)[0..@sizeOf(@TypeOf(keys))], 0);
18	19	try expect(!keys.up);

test/behavior/bugs/7187.zig+2

...	...	@@ -3,6 +3,8 @@ const builtin = @import("builtin");
3	3	const expect = std.testing.expect;
4	4
5	5	test "miscompilation with bool return type" {
	6	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	7
6	8	var x: usize = 1;
7	9	var y: bool = getFalse();
8	10	_ = y;

test/behavior/bugs/726.zig+2

...	...	@@ -5,6 +5,7 @@ test "@ptrCast from const to nullable" {
5	5	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
6	6	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
7	7	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	8	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
8	9
9	10	const c: u8 = 4;
10	11	var x: ?const u8 = @ptrCast(?const u8, &c);
...	...	@@ -15,6 +16,7 @@ test "@ptrCast from var in empty struct to nullable" {
15	16	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
16	17	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
17	18	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	19	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
18	20
19	21	const container = struct {
20	22	var c: u8 = 4;

test/behavior/bugs/7325.zig+1

...	...	@@ -82,6 +82,7 @@ test {
82	82	if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO
83	83	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
84	84	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	85	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
85	86
86	87	var param: ParamType = .{
87	88	.one_of = .{ .name = "name" },

test/behavior/bugs/8277.zig+2

...	...	@@ -2,6 +2,8 @@ const std = @import("std");
2	2	const builtin = @import("builtin");
3	3
4	4	test "@sizeOf reified union zero-size payload fields" {
	5	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	6
5	7	comptime {
6	8	try std.testing.expect(0 == @sizeOf(@Type(@typeInfo(union {}))));
7	9	try std.testing.expect(0 == @sizeOf(@Type(@typeInfo(union { a: void }))));

test/behavior/bugs/828.zig+1

...	...	@@ -31,6 +31,7 @@ fn constCount(comptime cb: *const CountBy, comptime unused: u32) void {
31	31
32	32	test "comptime struct return should not return the same instance" {
33	33	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	34	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
34	35
35	36	//the first parameter must be passed by reference to trigger the bug
36	37	//a second parameter is required to trigger the bug

test/behavior/bugs/8646.zig+1

...	...	@@ -11,6 +11,7 @@ test {
11	11	if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO
12	12	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
13	13	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	14	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
14	15
15	16	try std.testing.expect(array[0].len == 1);
16	17	try std.testing.expectEqualStrings("hello", array[0][0]);

test/behavior/bugs/920.zig+1

...	...	@@ -62,6 +62,7 @@ test "bug 920 fixed" {
62	62	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
63	63	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
64	64	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	65	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
65	66
66	67	const NormalDist1 = blk: {
67	68	break :blk ZigTableGen(true, norm_r, norm_v, norm_f, norm_f_inv, norm_zero_case);

test/behavior/bugs/9584.zig+1

...	...	@@ -47,6 +47,7 @@ test {
47	47	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
48	48	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
49	49	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	50	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
50	51
51	52	var flags = A{
52	53	.a = false,

test/behavior/byteswap.zig+4

...	...	@@ -8,6 +8,7 @@ test "@byteSwap integers" {
8	8	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
9	9	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
10	10	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
	11	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
11	12
12	13	const ByteSwapIntTest = struct {
13	14	fn run() !void {
...	...	@@ -66,6 +67,7 @@ test "@byteSwap vectors u8" {
66	67	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
67	68	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
68	69	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	70	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
69	71
70	72	comptime try vector8();
71	73	try vector8();
...	...	@@ -84,6 +86,7 @@ test "@byteSwap vectors u16" {
84	86	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
85	87	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
86	88	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	89	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
87	90
88	91	comptime try vector16();
89	92	try vector16();
...	...	@@ -102,6 +105,7 @@ test "@byteSwap vectors u24" {
102	105	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
103	106	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
104	107	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	108	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
105	109
106	110	comptime try vector24();
107	111	try vector24();

test/behavior/byval_arg_var.zig+1

...	...	@@ -5,6 +5,7 @@ var result: []const u8 = "wrong";
5	5
6	6	test "pass string literal byvalue to a generic var param" {
7	7	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	8	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
8	9
9	10	start();
10	11	blowUpStack(10);

test/behavior/call.zig+12

...	...	@@ -24,6 +24,7 @@ test "basic invocations" {
24	24	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
25	25	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
26	26	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	27	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
27	28
28	29	const foo = struct {
29	30	fn foo() i32 {
...	...	@@ -56,6 +57,7 @@ test "tuple parameters" {
56	57	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
57	58	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
58	59	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	60	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
59	61
60	62	const add = struct {
61	63	fn add(a: i32, b: i32) i32 {
...	...	@@ -88,6 +90,7 @@ test "result location of function call argument through runtime condition and st
88	90	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
89	91	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
90	92	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	93	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
91	94
92	95	const E = enum { a, b };
93	96	const S = struct {
...	...	@@ -106,6 +109,7 @@ test "result location of function call argument through runtime condition and st
106	109
107	110	test "function call with 40 arguments" {
108	111	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	112	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
109	113
110	114	const S = struct {
111	115	fn doTheTest(thirty_nine: i32) !void {
...	...	@@ -265,6 +269,7 @@ test "forced tail call" {
265	269	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
266	270	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
267	271	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	272	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
268	273
269	274	if (builtin.zig_backend == .stage2_llvm) {
270	275	// Only attempt this test on targets we know have tail call support in LLVM.
...	...	@@ -298,6 +303,7 @@ test "inline call preserves tail call" {
298	303	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
299	304	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
300	305	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	306	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
301	307
302	308	if (builtin.zig_backend == .stage2_llvm) {
303	309	// Only attempt this test on targets we know have tail call support in LLVM.
...	...	@@ -329,6 +335,7 @@ test "inline call preserves tail call" {
329	335	test "inline call doesn't re-evaluate non generic struct" {
330	336	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
331	337	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	338	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
332	339
333	340	const S = struct {
334	341	fn foo(f: struct { a: u8, b: u8 }) !void {
...	...	@@ -367,6 +374,8 @@ test "Enum constructed by @Type passed as generic argument" {
367	374	}
368	375
369	376	test "generic function with generic function parameter" {
	377	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	378
370	379	const S = struct {
371	380	fn f(comptime a: fn (anytype) anyerror!void, b: anytype) anyerror!void {
372	381	try a(b);
...	...	@@ -379,6 +388,8 @@ test "generic function with generic function parameter" {
379	388	}
380	389
381	390	test "recursive inline call with comptime known argument" {
	391	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	392
382	393	const S = struct {
383	394	inline fn foo(x: i32) i32 {
384	395	if (x <= 0) {
...	...	@@ -395,6 +406,7 @@ test "recursive inline call with comptime known argument" {
395	406	test "inline while with @call" {
396	407	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
397	408	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	409	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
398	410
399	411	const S = struct {
400	412	fn inc(a: *u32) void {

test/behavior/cast.zig+88

...	...	@@ -97,6 +97,7 @@ test "@intToFloat" {
97	97	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
98	98	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
99	99	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	100	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
100	101
101	102	const S = struct {
102	103	fn doTheTest() !void {
...	...	@@ -119,6 +120,7 @@ test "@intToFloat(f80)" {
119	120	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
120	121	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
121	122	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	123	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
122	124
123	125	const S = struct {
124	126	fn doTheTest(comptime Int: type) !void {
...	...	@@ -154,6 +156,7 @@ test "@floatToInt" {
154	156	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
155	157	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
156	158	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	159	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
157	160
158	161	try testFloatToInts();
159	162	comptime try testFloatToInts();
...	...	@@ -176,6 +179,7 @@ fn expectFloatToInt(comptime F: type, f: F, comptime I: type, i: I) !void {
176	179	test "implicitly cast indirect pointer to maybe-indirect pointer" {
177	180	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
178	181	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	182	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
179	183
180	184	const S = struct {
181	185	const Self = @This();
...	...	@@ -204,12 +208,16 @@ test "implicitly cast indirect pointer to maybe-indirect pointer" {
204	208	}
205	209
206	210	test "@intCast comptime_int" {
	211	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	212
207	213	const result = @intCast(i32, 1234);
208	214	try expect(@TypeOf(result) == i32);
209	215	try expect(result == 1234);
210	216	}
211	217
212	218	test "@floatCast comptime_int and comptime_float" {
	219	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	220
213	221	{
214	222	const result = @floatCast(f16, 1234);
215	223	try expect(@TypeOf(result) == f16);
...	...	@@ -236,6 +244,7 @@ test "coerce undefined to optional" {
236	244	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
237	245	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
238	246	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	247	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
239	248
240	249	try expect(MakeType(void).getNull() == null);
241	250	try expect(MakeType(void).getNonNull() != null);
...	...	@@ -256,6 +265,7 @@ fn MakeType(comptime T: type) type {
256	265	test "implicit cast from [N]T to [c]T" {
257	266	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
258	267	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	268	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
259	269
260	270	var x: [4]u16 = [4]u16{ 0, 1, 2, 3 };
261	271	var y: [*c]u16 = &x;
...	...	@@ -267,6 +277,8 @@ test "implicit cast from [N]T to [c]T" {
267	277	}
268	278
269	279	test "usize to void" {
	280	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	281
270	282	var i = @as(usize, 0);
271	283	var v = @ptrCast(*void, &i);
272	284	v.* = {};
...	...	@@ -317,6 +329,7 @@ test "peer result null and comptime_int" {
317	329	test "const ?[]const T to [c]const [c]const T" {
318	330	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
319	331	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	332	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
320	333
321	334	var array = [_]u8{ 'o', 'k' };
322	335	const opt_array_ptr: ?[*]const u8 = &array;
...	...	@@ -329,6 +342,7 @@ test "const ?[]const T to [c]const [c]const T" {
329	342	test "array coersion to undefined at runtime" {
330	343	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
331	344	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	345	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
332	346
333	347	@setRuntimeSafety(true);
334	348
...	...	@@ -359,6 +373,7 @@ test "return u8 coercing into ?u32 return type" {
359	373	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
360	374	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
361	375	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	376	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
362	377
363	378	const S = struct {
364	379	fn doTheTest() !void {
...	...	@@ -380,6 +395,7 @@ test "cast from ?[]T to ??[]T" {
380	395	test "peer type unsigned int to signed" {
381	396	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
382	397	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	398	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
383	399
384	400	var w: u31 = 5;
385	401	var x: u8 = 7;
...	...	@@ -392,6 +408,7 @@ test "peer type unsigned int to signed" {
392	408	test "expected [c]const u8, found [:0]const u8" {
393	409	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
394	410	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	411	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
395	412
396	413	var a: [*:0]const u8 = "hello";
397	414	var b: [*c]const u8 = a;
...	...	@@ -403,6 +420,7 @@ test "explicit cast from integer to error type" {
403	420	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
404	421	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
405	422	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	423	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
406	424
407	425	try testCastIntToErr(error.ItBroke);
408	426	comptime try testCastIntToErr(error.ItBroke);
...	...	@@ -417,6 +435,7 @@ test "peer resolve array and const slice" {
417	435	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
418	436	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
419	437	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	438	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
420	439
421	440	try testPeerResolveArrayConstSlice(true);
422	441	comptime try testPeerResolveArrayConstSlice(true);
...	...	@@ -432,6 +451,7 @@ test "implicitly cast from T to anyerror!?T" {
432	451	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
433	452	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
434	453	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	454	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
435	455
436	456	try castToOptionalTypeError(1);
437	457	comptime try castToOptionalTypeError(1);
...	...	@@ -457,6 +477,7 @@ fn castToOptionalTypeError(z: i32) !void {
457	477	test "implicitly cast from [0]T to anyerror![]T" {
458	478	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
459	479	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	480	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
460	481
461	482	try testCastZeroArrayToErrSliceMut();
462	483	comptime try testCastZeroArrayToErrSliceMut();
...	...	@@ -474,6 +495,7 @@ test "peer type resolution: [0]u8, []const u8, and anyerror![]u8" {
474	495	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
475	496	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
476	497	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	498	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
477	499
478	500	const S = struct {
479	501	fn doTheTest() anyerror!void {
...	...	@@ -505,6 +527,7 @@ fn peerTypeEmptyArrayAndSliceAndError(a: bool, slice: []u8) anyerror![]u8 {
505	527	test "implicit cast from *const [N]T to []const T" {
506	528	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
507	529	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	530	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
508	531
509	532	try testCastConstArrayRefToConstSlice();
510	533	comptime try testCastConstArrayRefToConstSlice();
...	...	@@ -530,6 +553,7 @@ fn testCastConstArrayRefToConstSlice() !void {
530	553	test "peer type resolution: error and [N]T" {
531	554	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
532	555	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	556	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
533	557
534	558	try expect(mem.eql(u8, try testPeerErrorAndArray(0), "OK"));
535	559	comptime try expect(mem.eql(u8, try testPeerErrorAndArray(0), "OK"));
...	...	@@ -554,6 +578,7 @@ fn testPeerErrorAndArray2(x: u8) anyerror![]const u8 {
554	578	test "single-item pointer of array to slice to unknown length pointer" {
555	579	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
556	580	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	581	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
557	582
558	583	try testCastPtrOfArrayToSliceAndPtr();
559	584	comptime try testCastPtrOfArrayToSliceAndPtr();
...	...	@@ -583,6 +608,7 @@ fn testCastPtrOfArrayToSliceAndPtr() !void {
583	608	test "cast [1][]const u8 to []const ?[]const u8" {
584	609	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
585	610	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	611	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
586	612
587	613	const window_name = [1][*]const u8{"window name"};
588	614	const x: []const ?[]const u8 = &window_name;
...	...	@@ -595,6 +621,7 @@ test "vector casts" {
595	621	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
596	622	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
597	623	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	624	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
598	625
599	626	const S = struct {
600	627	fn doTheTest() !void {
...	...	@@ -636,6 +663,7 @@ test "@floatCast cast down" {
636	663	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
637	664	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
638	665	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	666	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
639	667
640	668	{
641	669	var double: f64 = 0.001534;
...	...	@@ -652,6 +680,7 @@ test "@floatCast cast down" {
652	680	test "peer type resolution: unreachable, error set, unreachable" {
653	681	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
654	682	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	683	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
655	684
656	685	const Error = error{
657	686	FileDescriptorAlreadyPresentInSet,
...	...	@@ -686,6 +715,7 @@ test "peer type resolution: error set supersets" {
686	715	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
687	716	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
688	717	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	718	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
689	719
690	720	const a: error{ One, Two } = undefined;
691	721	const b: error{One} = undefined;
...	...	@@ -715,6 +745,7 @@ test "peer type resolution: disjoint error sets" {
715	745	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
716	746	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
717	747	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	748	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
718	749
719	750	const a: error{ One, Two } = undefined;
720	751	const b: error{Three} = undefined;
...	...	@@ -744,6 +775,7 @@ test "peer type resolution: error union and error set" {
744	775	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
745	776	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
746	777	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	778	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
747	779
748	780	const a: error{Three} = undefined;
749	781	const b: error{ One, Two }!u32 = undefined;
...	...	@@ -777,6 +809,7 @@ test "peer type resolution: error union after non-error" {
777	809	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
778	810	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
779	811	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	812	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
780	813
781	814	const a: u32 = undefined;
782	815	const b: error{ One, Two }!u32 = undefined;
...	...	@@ -810,6 +843,7 @@ test "peer cast *[0]T to E![]const T" {
810	843	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
811	844	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
812	845	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	846	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
813	847
814	848	var buffer: [5]u8 = "abcde".*;
815	849	var buf: anyerror![]const u8 = buffer[0..];
...	...	@@ -824,6 +858,7 @@ test "peer cast *[0]T to []const T" {
824	858	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
825	859	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
826	860	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	861	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
827	862
828	863	var buffer: [5]u8 = "abcde".*;
829	864	var buf: []const u8 = buffer[0..];
...	...	@@ -834,6 +869,7 @@ test "peer cast *[0]T to []const T" {
834	869
835	870	test "peer cast [N]T to []T" {
836	871	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	872	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
837	873
838	874	var array = [4:99]i32{ 1, 2, 3, 4 };
839	875	var dest: [*]i32 = undefined;
...	...	@@ -845,6 +881,7 @@ test "peer resolution of string literals" {
845	881	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
846	882	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
847	883	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	884	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
848	885
849	886	const S = struct {
850	887	const E = enum { a, b, c, d };
...	...	@@ -866,6 +903,7 @@ test "peer resolution of string literals" {
866	903	test "peer cast [:x]T to []T" {
867	904	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
868	905	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	906	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
869	907
870	908	const S = struct {
871	909	fn doTheTest() !void {
...	...	@@ -882,6 +920,7 @@ test "peer cast [:x]T to []T" {
882	920	test "peer cast [N:x]T to [N]T" {
883	921	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
884	922	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	923	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
885	924
886	925	const S = struct {
887	926	fn doTheTest() !void {
...	...	@@ -897,6 +936,7 @@ test "peer cast [N:x]T to [N]T" {
897	936	test "peer cast [N:x]T to [N]T" {
898	937	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
899	938	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	939	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
900	940
901	941	const S = struct {
902	942	fn doTheTest() !void {
...	...	@@ -912,6 +952,7 @@ test "peer cast [N:x]T to [N]T" {
912	952	test "peer cast [:x]T to []T" {
913	953	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
914	954	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	955	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
915	956
916	957	const S = struct {
917	958	fn doTheTest() !void {
...	...	@@ -932,6 +973,7 @@ test "peer cast [:x]T to [*:x]T" {
932	973	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
933	974	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
934	975	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	976	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
935	977
936	978	const S = struct {
937	979	fn doTheTest() !void {
...	...	@@ -952,6 +994,7 @@ test "peer cast [:x]T to [*:x]T" {
952	994	test "peer type resolution implicit cast to return type" {
953	995	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
954	996	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	997	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
955	998
956	999	const S = struct {
957	1000	fn doTheTest() !void {
...	...	@@ -972,6 +1015,7 @@ test "peer type resolution implicit cast to return type" {
972	1015	test "peer type resolution implicit cast to variable type" {
973	1016	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
974	1017	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	1018	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
975	1019
976	1020	const S = struct {
977	1021	fn doTheTest() !void {
...	...	@@ -996,6 +1040,7 @@ test "variable initialization uses result locations properly with regards to the
996	1040	test "cast between C pointer with different but compatible types" {
997	1041	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
998	1042	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	1043	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
999	1044
1000	1045	const S = struct {
1001	1046	fn foo(arg: [*]c_ushort) u16 {
...	...	@@ -1013,6 +1058,7 @@ test "cast between C pointer with different but compatible types" {
1013	1058	test "peer type resolve string lit with sentinel-terminated mutable slice" {
1014	1059	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1015	1060	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	1061	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1016	1062
1017	1063	var array: [4:0]u8 = undefined;
1018	1064	array[4] = 0; // TODO remove this when #4372 is solved
...	...	@@ -1022,6 +1068,8 @@ test "peer type resolve string lit with sentinel-terminated mutable slice" {
1022	1068	}
1023	1069
1024	1070	test "peer type resolve array pointers, one of them const" {
	1071	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1072
1025	1073	var array1: [4]u8 = undefined;
1026	1074	const array2: [5]u8 = undefined;
1027	1075	comptime try expect(@TypeOf(&array1, &array2) == []const u8);
...	...	@@ -1029,6 +1077,8 @@ test "peer type resolve array pointers, one of them const" {
1029	1077	}
1030	1078
1031	1079	test "peer type resolve array pointer and unknown pointer" {
	1080	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1081
1032	1082	const const_array: [4]u8 = undefined;
1033	1083	var array: [4]u8 = undefined;
1034	1084	var const_ptr: [*]const u8 = undefined;
...	...	@@ -1048,6 +1098,8 @@ test "peer type resolve array pointer and unknown pointer" {
1048	1098	}
1049	1099
1050	1100	test "comptime float casts" {
	1101	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1102
1051	1103	const a = @intToFloat(comptime_float, 1);
1052	1104	try expect(a == 1);
1053	1105	try expect(@TypeOf(a) == comptime_float);
...	...	@@ -1078,6 +1130,7 @@ test "implicit cast from []T to ?anyopaque" {
1078	1130	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1079	1131	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1080	1132	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	1133	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1081	1134
1082	1135	var a = [_]u8{ 3, 2, 1 };
1083	1136	var runtime_zero: usize = 0;
...	...	@@ -1093,6 +1146,8 @@ fn incrementVoidPtrArray(array: ?*anyopaque, len: usize) void {
1093	1146	}
1094	1147
1095	1148	test "compile time int to ptr of function" {
	1149	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1150
1096	1151	try foobar(FUNCTION_CONSTANT);
1097	1152	}
1098	1153
...	...	@@ -1109,6 +1164,7 @@ test "implicit ptr to *anyopaque" {
1109	1164	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1110	1165	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1111	1166	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	1167	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1112	1168
1113	1169	var a: u32 = 1;
1114	1170	var ptr: *align(@alignOf(u32)) anyopaque = &a;
...	...	@@ -1122,6 +1178,7 @@ test "implicit ptr to *anyopaque" {
1122	1178	test "return null from fn() anyerror!?&T" {
1123	1179	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1124	1180	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	1181	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1125	1182
1126	1183	const a = returnNullFromOptionalTypeErrorRef();
1127	1184	const b = returnNullLitFromOptionalTypeErrorRef();
...	...	@@ -1138,6 +1195,7 @@ fn returnNullLitFromOptionalTypeErrorRef() anyerror!?*A {
1138	1195	test "peer type resolution: [0]u8 and []const u8" {
1139	1196	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1140	1197	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	1198	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1141	1199
1142	1200	try expect(peerTypeEmptyArrayAndSlice(true, "hi").len == 0);
1143	1201	try expect(peerTypeEmptyArrayAndSlice(false, "hi").len == 1);
...	...	@@ -1158,6 +1216,7 @@ test "implicitly cast from [N]T to ?[]const T" {
1158	1216	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1159	1217	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1160	1218	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	1219	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1161	1220
1162	1221	try expect(mem.eql(u8, castToOptionalSlice().?, "hi"));
1163	1222	comptime try expect(mem.eql(u8, castToOptionalSlice().?, "hi"));
...	...	@@ -1172,6 +1231,7 @@ test "cast u128 to f128 and back" {
1172	1231	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1173	1232	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
1174	1233	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	1234	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1175	1235
1176	1236	comptime try testCast128();
1177	1237	try testCast128();
...	...	@@ -1193,6 +1253,7 @@ test "implicit cast from [N]T to ?[]T" {
1193	1253	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1194	1254	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1195	1255	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	1256	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1196	1257
1197	1258	var x: ?[*]u16 = null;
1198	1259	var y: [4]u16 = [4]u16{ 0, 1, 2, 3 };
...	...	@@ -1208,6 +1269,7 @@ test "implicit cast from T to ?anyopaque" {
1208	1269	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1209	1270	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1210	1271	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	1272	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1211	1273
1212	1274	var a: u8 = 1;
1213	1275	incrementVoidPtrValue(&a);
...	...	@@ -1221,6 +1283,7 @@ fn incrementVoidPtrValue(value: ?*anyopaque) void {
1221	1283	test "implicit cast *[0]T to E![]const u8" {
1222	1284	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1223	1285	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	1286	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1224	1287
1225	1288	var x = @as(anyerror![]const u8, &[0]u8{});
1226	1289	try expect((x catch unreachable).len == 0);
...	...	@@ -1228,10 +1291,14 @@ test "implicit cast *[0]T to E![]const u8" {
1228	1291
1229	1292	var global_array: [4]u8 = undefined;
1230	1293	test "cast from array reference to fn: comptime fn ptr" {
	1294	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1295
1231	1296	const f = @ptrCast(*align(1) const fn () callconv(.C) void, &global_array);
1232	1297	try expect(@ptrToInt(f) == @ptrToInt(&global_array));
1233	1298	}
1234	1299	test "cast from array reference to fn: runtime fn ptr" {
	1300	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1301
1235	1302	var f = @ptrCast(*align(1) const fn () callconv(.C) void, &global_array);
1236	1303	try expect(@ptrToInt(f) == @ptrToInt(&global_array));
1237	1304	}
...	...	@@ -1240,6 +1307,7 @@ test "*const [N]null u8 to ?[]const u8" {
1240	1307	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1241	1308	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1242	1309	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	1310	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1243	1311
1244	1312	const S = struct {
1245	1313	fn doTheTest() !void {
...	...	@@ -1253,6 +1321,8 @@ test "*const [N]null u8 to ?[]const u8" {
1253	1321	}
1254	1322
1255	1323	test "cast between [c]T and ?[:0]T on fn parameter" {
	1324	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1325
1256	1326	const S = struct {
1257	1327	const Handler = ?fn ([*c]const u8) callconv(.C) void;
1258	1328	fn addCallback(comptime handler: Handler) void {
...	...	@@ -1275,12 +1345,15 @@ test "assignment to optional pointer result loc" {
1275	1345	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1276	1346	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1277	1347	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	1348	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1278	1349
1279	1350	var foo: struct { ptr: ?*anyopaque } = .{ .ptr = &global_struct };
1280	1351	try expect(foo.ptr.? == @ptrCast(*anyopaque, &global_struct));
1281	1352	}
1282	1353
1283	1354	test "cast between *[N]void and []void" {
	1355	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1356
1284	1357	var a: [4]void = undefined;
1285	1358	var b: []void = &a;
1286	1359	try expect(b.len == 4);
...	...	@@ -1289,6 +1362,7 @@ test "cast between *[N]void and []void" {
1289	1362	test "peer resolve arrays of different size to const slice" {
1290	1363	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1291	1364	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	1365	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1292	1366
1293	1367	try expect(mem.eql(u8, boolToStr(true), "true"));
1294	1368	try expect(mem.eql(u8, boolToStr(false), "false"));
...	...	@@ -1305,6 +1379,7 @@ test "cast f16 to wider types" {
1305	1379	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
1306	1380	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
1307	1381	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	1382	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1308	1383
1309	1384	const S = struct {
1310	1385	fn doTheTest() !void {
...	...	@@ -1324,6 +1399,7 @@ test "cast f128 to narrower types" {
1324	1399	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
1325	1400	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
1326	1401	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	1402	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1327	1403
1328	1404	const S = struct {
1329	1405	fn doTheTest() !void {
...	...	@@ -1341,6 +1417,7 @@ test "peer type resolution: unreachable, null, slice" {
1341	1417	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1342	1418	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1343	1419	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	1420	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1344	1421
1345	1422	const S = struct {
1346	1423	fn doTheTest(num: usize, word: []const u8) !void {
...	...	@@ -1380,6 +1457,7 @@ test "cast compatible optional types" {
1380	1457	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1381	1458	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1382	1459	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	1460	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1383	1461
1384	1462	var a: ?[:0]const u8 = null;
1385	1463	var b: ?[]const u8 = a;
...	...	@@ -1389,6 +1467,7 @@ test "cast compatible optional types" {
1389	1467	test "coerce undefined single-item pointer of array to error union of slice" {
1390	1468	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1391	1469	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	1470	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1392	1471
1393	1472	const a = @as([*]u8, undefined)[0..0];
1394	1473	var b: error{a}![]const u8 = a;
...	...	@@ -1398,6 +1477,7 @@ test "coerce undefined single-item pointer of array to error union of slice" {
1398	1477
1399	1478	test "pointer to empty struct literal to mutable slice" {
1400	1479	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	1480	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1401	1481
1402	1482	var x: []i32 = &.{};
1403	1483	try expect(x.len == 0);
...	...	@@ -1409,6 +1489,7 @@ test "coerce between pointers of compatible differently-named floats" {
1409	1489	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
1410	1490	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
1411	1491	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	1492	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1412	1493
1413	1494	if (builtin.os.tag == .windows) {
1414	1495	// https://github.com/ziglang/zig/issues/12396
...	...	@@ -1463,6 +1544,7 @@ test "cast typed undefined to int" {
1463	1544
1464	1545	test "implicit cast from [:0]T to [*c]T" {
1465	1546	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	1547	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1466	1548
1467	1549	var a: [:0]const u8 = "foo";
1468	1550	var b: [*c]const u8 = a;
...	...	@@ -1485,6 +1567,7 @@ test "bitcast packed struct with u0" {
1485	1567
1486	1568	test "optional pointer coerced to optional allowzero pointer" {
1487	1569	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	1570	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1488	1571
1489	1572	var p: ?*u32 = undefined;
1490	1573	var q: ?*allowzero u32 = undefined;
...	...	@@ -1494,6 +1577,8 @@ test "optional pointer coerced to optional allowzero pointer" {
1494	1577	}
1495	1578
1496	1579	test "single item pointer to pointer to array to slice" {
	1580	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1581
1497	1582	var x: i32 = 1234;
1498	1583	try expect(@as([]const i32, @as(*[1]i32, &x))[0] == 1234);
1499	1584	const z1 = @as([]const i32, @as(*[1]i32, &x));
...	...	@@ -1502,6 +1587,7 @@ test "single item pointer to pointer to array to slice" {
1502	1587
1503	1588	test "peer type resolution forms error union" {
1504	1589	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
	1590	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1505	1591
1506	1592	var foo: i32 = 123;
1507	1593	const result = if (foo < 0) switch (-foo) {
...	...	@@ -1528,6 +1614,8 @@ test "@volatileCast without a result location" {
1528	1614	}
1529	1615
1530	1616	test "coercion from single-item pointer to @as to slice" {
	1617	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1618
1531	1619	var x: u32 = 1;
1532	1620
1533	1621	// Why the following line gets a compile error?

test/behavior/cast_int.zig+1

...	...	@@ -8,6 +8,7 @@ test "@intCast i32 to u7" {
8	8	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
9	9	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
10	10	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	11	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
11	12
12	13	var x: u128 = maxInt(u128);
13	14	var y: i32 = 120;

test/behavior/const_slice_child.zig+1

...	...	@@ -10,6 +10,7 @@ test "const slice child" {
10	10	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
11	11	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
12	12	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	13	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
13	14
14	15	const strs = [_][*]const u8{ "one", "two", "three" };
15	16	argv = &strs;

test/behavior/decltest.zig+4

...	...	@@ -1,7 +1,11 @@
	1	const builtin = @import("builtin");
	2
1	3	pub fn the_add_function(a: u32, b: u32) u32 {
2	4	return a + b;
3	5	}
4	6
5	7	test the_add_function {
	8	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	9
6	10	if (the_add_function(1, 2) != 3) unreachable;
7	11	}

test/behavior/defer.zig+9

...	...	@@ -5,6 +5,8 @@ const expectEqual = std.testing.expectEqual;
5	5	const expectError = std.testing.expectError;
6	6
7	7	test "break and continue inside loop inside defer expression" {
	8	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	9
8	10	testBreakContInDefer(10);
9	11	comptime testBreakContInDefer(10);
10	12	}
...	...	@@ -21,6 +23,8 @@ fn testBreakContInDefer(x: usize) void {
21	23	}
22	24
23	25	test "defer and labeled break" {
	26	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	27
24	28	var i = @as(usize, 0);
25	29
26	30	blk: {
...	...	@@ -34,6 +38,7 @@ test "defer and labeled break" {
34	38	test "errdefer does not apply to fn inside fn" {
35	39	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
36	40	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	41	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
37	42
38	43	if (testNestedFnErrDefer()) \|_\| @panic("expected error") else \|e\| try expect(e == error.Bad);
39	44	}
...	...	@@ -53,6 +58,7 @@ test "return variable while defer expression in scope to modify it" {
53	58	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
54	59	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
55	60	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	61	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
56	62
57	63	const S = struct {
58	64	fn doTheTest() !void {
...	...	@@ -94,6 +100,7 @@ test "mixing normal and error defers" {
94	100	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
95	101	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
96	102	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	103	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
97	104
98	105	try expect(runSomeErrorDefers(true) catch unreachable);
99	106	try expect(result[0] == 'c');
...	...	@@ -113,6 +120,7 @@ test "errdefer with payload" {
113	120	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
114	121	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
115	122	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	123	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
116	124
117	125	const S = struct {
118	126	fn foo() !i32 {
...	...	@@ -132,6 +140,7 @@ test "errdefer with payload" {
132	140	test "simple else prong doesn't emit an error for unreachable else prong" {
133	141	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
134	142	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	143	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
135	144
136	145	const S = struct {
137	146	fn foo() error{Foo}!void {

test/behavior/duplicated_test_names.zig+4

...	...	@@ -1,3 +1,5 @@
	1	const builtin = @import("builtin");
	2
1	3	const Namespace = struct {
2	4	test "thingy" {}
3	5	};
...	...	@@ -13,5 +15,7 @@ comptime {
13	15	test "thingy" {}
14	16
15	17	test thingy {
	18	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	19
16	20	if (thingy(1, 2) != 3) unreachable;
17	21	}

test/behavior/empty_tuple_fields.zig+2

...	...	@@ -4,6 +4,7 @@ const builtin = @import("builtin");
4	4	test "empty file level struct" {
5	5	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
6	6	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	7	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
7	8
8	9	const T = @import("empty_file_level_struct.zig");
9	10	const info = @typeInfo(T);
...	...	@@ -15,6 +16,7 @@ test "empty file level struct" {
15	16	test "empty file level union" {
16	17	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
17	18	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	19	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
18	20
19	21	const T = @import("empty_file_level_union.zig");
20	22	const info = @typeInfo(T);

test/behavior/empty_union.zig+6

...	...	@@ -12,6 +12,7 @@ test "switch on empty enum" {
12	12
13	13	test "switch on empty enum with a specified tag type" {
14	14	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
	15	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
15	16
16	17	const E = enum(u8) {};
17	18	var e: E = undefined;
...	...	@@ -21,6 +22,7 @@ test "switch on empty enum with a specified tag type" {
21	22	test "switch on empty auto numbered tagged union" {
22	23	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
23	24	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
	25	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
24	26
25	27	const U = union(enum(u8)) {};
26	28	var u: U = undefined;
...	...	@@ -50,6 +52,8 @@ test "empty extern union" {
50	52	}
51	53
52	54	test "empty union passed as argument" {
	55	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	56
53	57	const U = union(enum) {
54	58	fn f(u: @This()) void {
55	59	switch (u) {}
...	...	@@ -59,6 +63,8 @@ test "empty union passed as argument" {
59	63	}
60	64
61	65	test "empty enum passed as argument" {
	66	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	67
62	68	const E = enum {
63	69	fn f(e: @This()) void {
64	70	switch (e) {}

test/behavior/enum.zig+23

...	...	@@ -27,6 +27,7 @@ const IntToEnumNumber = enum { Zero, One, Two, Three, Four };
27	27	test "int to enum" {
28	28	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
29	29	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	30	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
30	31
31	32	try testIntToEnumEval(3);
32	33	}
...	...	@@ -575,6 +576,8 @@ test "enum literal equality" {
575	576	}
576	577
577	578	test "enum literal cast to enum" {
	579	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	580
578	581	const Color = enum { Auto, Off, On };
579	582
580	583	var color1: Color = .Auto;
...	...	@@ -617,6 +620,7 @@ test "enum with specified tag values" {
617	620	test "non-exhaustive enum" {
618	621	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
619	622	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	623	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
620	624
621	625	const S = struct {
622	626	const E = enum(u8) { a, b, _ };
...	...	@@ -659,6 +663,8 @@ test "non-exhaustive enum" {
659	663	}
660	664
661	665	test "empty non-exhaustive enum" {
	666	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	667
662	668	const S = struct {
663	669	const E = enum(u8) { _ };
664	670
...	...	@@ -680,6 +686,7 @@ test "empty non-exhaustive enum" {
680	686	test "single field non-exhaustive enum" {
681	687	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
682	688	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	689	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
683	690
684	691	const S = struct {
685	692	const E = enum(u8) { a, _ };
...	...	@@ -852,6 +859,8 @@ fn doALoopThing(id: EnumWithOneMember) void {
852	859	}
853	860
854	861	test "comparison operator on enum with one member is comptime-known" {
	862	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	863
855	864	doALoopThing(EnumWithOneMember.Eof);
856	865	}
857	866
...	...	@@ -865,6 +874,8 @@ test "switch on enum with one member is comptime-known" {
865	874	}
866	875
867	876	test "method call on an enum" {
	877	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	878
868	879	const S = struct {
869	880	const E = enum {
870	881	one,
...	...	@@ -904,6 +915,7 @@ test "enum literal casting to tagged union" {
904	915	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
905	916	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
906	917	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	918	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
907	919
908	920	const Arch = union(enum) {
909	921	x86_64,
...	...	@@ -929,6 +941,7 @@ const Bar = enum { A, B, C, D };
929	941	test "enum literal casting to error union with payload enum" {
930	942	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
931	943	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	944	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
932	945
933	946	var bar: error{B}!Bar = undefined;
934	947	bar = .B; // should never cast to the error set
...	...	@@ -940,6 +953,7 @@ test "constant enum initialization with differing sizes" {
940	953	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
941	954	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
942	955	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	956	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
943	957
944	958	try test3_1(test3_foo);
945	959	try test3_2(test3_bar);
...	...	@@ -982,6 +996,7 @@ test "@tagName" {
982	996	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
983	997	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
984	998	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	999	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
985	1000
986	1001	try expect(mem.eql(u8, testEnumTagNameBare(BareNumber.Three), "Three"));
987	1002	comptime try expect(mem.eql(u8, testEnumTagNameBare(BareNumber.Three), "Three"));
...	...	@@ -997,6 +1012,7 @@ test "@tagName non-exhaustive enum" {
997	1012	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
998	1013	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
999	1014	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	1015	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1000	1016
1001	1017	try expect(mem.eql(u8, testEnumTagNameBare(NonExhaustive.B), "B"));
1002	1018	comptime try expect(mem.eql(u8, testEnumTagNameBare(NonExhaustive.B), "B"));
...	...	@@ -1007,6 +1023,7 @@ test "@tagName is null-terminated" {
1007	1023	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
1008	1024	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1009	1025	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	1026	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1010	1027
1011	1028	const S = struct {
1012	1029	fn doTheTest(n: BareNumber) !void {
...	...	@@ -1021,6 +1038,7 @@ test "tag name with assigned enum values" {
1021	1038	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
1022	1039	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1023	1040	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	1041	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1024	1042
1025	1043	const LocalFoo = enum(u8) {
1026	1044	A = 1,
...	...	@@ -1033,6 +1051,7 @@ test "tag name with assigned enum values" {
1033	1051	test "@tagName on enum literals" {
1034	1052	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1035	1053	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	1054	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1036	1055
1037	1056	try expect(mem.eql(u8, @tagName(.FooBar), "FooBar"));
1038	1057	comptime try expect(mem.eql(u8, @tagName(.FooBar), "FooBar"));
...	...	@@ -1042,6 +1061,7 @@ test "enum literal casting to optional" {
1042	1061	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
1043	1062	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1044	1063	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	1064	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1045	1065
1046	1066	var bar: ?Bar = undefined;
1047	1067	bar = .B;
...	...	@@ -1070,6 +1090,7 @@ test "bit field access with enum fields" {
1070	1090	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
1071	1091	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1072	1092	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	1093	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1073	1094
1074	1095	var data = bit_field_1;
1075	1096	try expect(getA(&data) == A.Two);
...	...	@@ -1110,6 +1131,7 @@ test "tag name functions are unique" {
1110	1131	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
1111	1132	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1112	1133	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	1134	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1113	1135
1114	1136	{
1115	1137	const E = enum { a, b };
...	...	@@ -1128,6 +1150,7 @@ test "tag name functions are unique" {
1128	1150	test "size of enum with only one tag which has explicit integer tag type" {
1129	1151	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1130	1152	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	1153	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1131	1154
1132	1155	const E = enum(u8) { nope = 10 };
1133	1156	const S0 = struct { e: E };

test/behavior/error.zig+39

...	...	@@ -16,12 +16,14 @@ fn expectError(expected_err: anyerror, observed_err_union: anytype) !void {
16	16	}
17	17
18	18	test "error values" {
	19	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
19	20	const a = @errorToInt(error.err1);
20	21	const b = @errorToInt(error.err2);
21	22	try expect(a != b);
22	23	}
23	24
24	25	test "redefinition of error values allowed" {
	26	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
25	27	shouldBeNotEqual(error.AnError, error.SecondError);
26	28	}
27	29	fn shouldBeNotEqual(a: anyerror, b: anyerror) void {
...	...	@@ -30,6 +32,7 @@ fn shouldBeNotEqual(a: anyerror, b: anyerror) void {
30	32
31	33	test "error binary operator" {
32	34	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	35	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
33	36
34	37	const a = errBinaryOperatorG(true) catch 3;
35	38	const b = errBinaryOperatorG(false) catch 3;
...	...	@@ -61,12 +64,14 @@ pub fn baz() anyerror!i32 {
61	64
62	65	test "error wrapping" {
63	66	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	67	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
64	68
65	69	try expect((baz() catch unreachable) == 15);
66	70	}
67	71
68	72	test "unwrap simple value from error" {
69	73	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	74	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
70	75
71	76	const i = unwrapSimpleValueFromErrorDo() catch unreachable;
72	77	try expect(i == 13);
...	...	@@ -77,6 +82,7 @@ fn unwrapSimpleValueFromErrorDo() anyerror!isize {
77	82
78	83	test "error return in assignment" {
79	84	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	85	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
80	86
81	87	doErrReturnInAssignment() catch unreachable;
82	88	}
...	...	@@ -99,6 +105,7 @@ test "syntax: optional operator in front of error union operator" {
99	105	test "widen cast integer payload of error union function call" {
100	106	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
101	107	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	108	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
102	109
103	110	const S = struct {
104	111	fn errorable() !u64 {
...	...	@@ -124,6 +131,7 @@ test "debug info for optional error set" {
124	131
125	132	test "implicit cast to optional to error union to return result loc" {
126	133	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	134	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
127	135
128	136	const S = struct {
129	137	fn entry() !void {
...	...	@@ -144,11 +152,13 @@ test "implicit cast to optional to error union to return result loc" {
144	152	}
145	153
146	154	test "fn returning empty error set can be passed as fn returning any error" {
	155	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
147	156	entry();
148	157	comptime entry();
149	158	}
150	159
151	160	test "fn returning empty error set can be passed as fn returning any error - pointer" {
	161	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
152	162	entryPtr();
153	163	comptime entryPtr();
154	164	}
...	...	@@ -216,6 +226,7 @@ fn testErrorSetType() !void {
216	226
217	227	test "explicit error set cast" {
218	228	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	229	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
219	230
220	231	try testExplicitErrorSetCast(Set1.A);
221	232	comptime try testExplicitErrorSetCast(Set1.A);
...	...	@@ -234,6 +245,7 @@ fn testExplicitErrorSetCast(set1: Set1) !void {
234	245
235	246	test "comptime test error for empty error set" {
236	247	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	248	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
237	249
238	250	try testComptimeTestErrorEmptySet(1234);
239	251	comptime try testComptimeTestErrorEmptySet(1234);
...	...	@@ -269,6 +281,7 @@ test "inferred empty error set comptime catch" {
269	281	}
270	282
271	283	test "error inference with an empty set" {
	284	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
272	285	const S = struct {
273	286	const Struct = struct {
274	287	pub fn func() (error{})!usize {
...	...	@@ -291,6 +304,7 @@ test "error inference with an empty set" {
291	304
292	305	test "error union peer type resolution" {
293	306	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	307	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
294	308
295	309	try testErrorUnionPeerTypeResolution(1);
296	310	}
...	...	@@ -322,6 +336,7 @@ fn quux_1() !i32 {
322	336
323	337	test "error: Zero sized error set returned with value payload crash" {
324	338	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	339	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
325	340
326	341	_ = try foo3(0);
327	342	_ = comptime try foo3(0);
...	...	@@ -334,6 +349,7 @@ fn foo3(b: usize) Error!usize {
334	349
335	350	test "error: Infer error set from literals" {
336	351	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	352	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
337	353
338	354	_ = nullLiteral("n") catch \|err\| handleErrors(err);
339	355	_ = floatLiteral("n") catch \|err\| handleErrors(err);
...	...	@@ -373,6 +389,7 @@ test "nested error union function call in optional unwrap" {
373	389	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
374	390	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
375	391	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	392	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
376	393
377	394	const S = struct {
378	395	const Foo = struct {
...	...	@@ -419,6 +436,7 @@ test "nested error union function call in optional unwrap" {
419	436	test "return function call to error set from error union function" {
420	437	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
421	438	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	439	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
422	440
423	441	const S = struct {
424	442	fn errorable() anyerror!i32 {
...	...	@@ -437,6 +455,7 @@ test "optional error set is the same size as error set" {
437	455	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
438	456	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
439	457	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	458	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
440	459
441	460	comptime try expect(@sizeOf(?anyerror) == @sizeOf(anyerror));
442	461	comptime try expect(@alignOf(?anyerror) == @alignOf(anyerror));
...	...	@@ -452,6 +471,7 @@ test "optional error set is the same size as error set" {
452	471	test "nested catch" {
453	472	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
454	473	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	474	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
455	475
456	476	const S = struct {
457	477	fn entry() !void {
...	...	@@ -476,6 +496,7 @@ test "nested catch" {
476	496
477	497	test "function pointer with return type that is error union with payload which is pointer of parent struct" {
478	498	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	499	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
479	500
480	501	const S = struct {
481	502	const Foo = struct {
...	...	@@ -501,6 +522,7 @@ test "return result loc as peer result loc in inferred error set function" {
501	522	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
502	523	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
503	524	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	525	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
504	526
505	527	const S = struct {
506	528	fn doTheTest() !void {
...	...	@@ -532,6 +554,7 @@ test "error payload type is correctly resolved" {
532	554	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
533	555	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
534	556	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	557	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
535	558
536	559	const MyIntWrapper = struct {
537	560	const Self = @This();
...	...	@@ -561,6 +584,7 @@ test "@errorName" {
561	584	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
562	585	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
563	586	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	587	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
564	588
565	589	try expect(mem.eql(u8, @errorName(error.AnError), "AnError"));
566	590	try expect(mem.eql(u8, @errorName(error.ALongerErrorName), "ALongerErrorName"));
...	...	@@ -574,6 +598,7 @@ test "@errorName sentinel length matches slice length" {
574	598	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
575	599	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
576	600	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	601	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
577	602
578	603	const name = testBuiltinErrorName(error.FooBar);
579	604	const length: usize = 6;
...	...	@@ -647,6 +672,7 @@ test "peer type resolution of two different error unions" {
647	672	}
648	673
649	674	test "coerce error set to the current inferred error set" {
	675	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
650	676	const S = struct {
651	677	fn foo() !void {
652	678	var a = false;
...	...	@@ -665,6 +691,7 @@ test "error union payload is properly aligned" {
665	691	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
666	692	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
667	693	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	694	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
668	695
669	696	const S = struct {
670	697	a: u128,
...	...	@@ -697,6 +724,7 @@ test "ret_ptr doesn't cause own inferred error set to be resolved" {
697	724	test "simple else prong allowed even when all errors handled" {
698	725	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
699	726	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	727	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
700	728
701	729	const S = struct {
702	730	fn foo() !u8 {
...	...	@@ -725,6 +753,7 @@ test "pointer to error union payload" {
725	753	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
726	754	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
727	755	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	756	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
728	757
729	758	var err_union: anyerror!u8 = 15;
730	759
...	...	@@ -758,6 +787,7 @@ test "error union of noreturn used with if" {
758	787	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
759	788	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
760	789	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	790	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
761	791
762	792	NoReturn.a = 64;
763	793	if (NoReturn.loop()) {
...	...	@@ -772,6 +802,7 @@ test "error union of noreturn used with try" {
772	802	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
773	803	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
774	804	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	805	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
775	806
776	807	NoReturn.a = 64;
777	808	const err = NoReturn.testTry();
...	...	@@ -783,6 +814,7 @@ test "error union of noreturn used with catch" {
783	814	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
784	815	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
785	816	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	817	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
786	818
787	819	NoReturn.a = 64;
788	820	const err = NoReturn.testCatch();
...	...	@@ -793,6 +825,7 @@ test "alignment of wrapping an error union payload" {
793	825	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
794	826	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
795	827	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	828	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
796	829
797	830	const S = struct {
798	831	const I = extern struct { x: i128 };
...	...	@@ -807,6 +840,7 @@ test "alignment of wrapping an error union payload" {
807	840
808	841	test "compare error union and error set" {
809	842	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	843	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
810	844
811	845	var a: anyerror = error.Foo;
812	846	var b: anyerror!u32 = error.Bar;
...	...	@@ -835,6 +869,8 @@ fn non_errorable() void {
835	869	}
836	870
837	871	test "catch within a function that calls no errorable functions" {
	872	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	873
838	874	non_errorable();
839	875	}
840	876
...	...	@@ -842,6 +878,7 @@ test "error from comptime string" {
842	878	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
843	879	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
844	880	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	881	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
845	882
846	883	const name = "Weird error name!";
847	884	const S = struct {
...	...	@@ -865,6 +902,7 @@ test "field access of anyerror results in smaller error set" {
865	902	test "optional error union return type" {
866	903	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
867	904	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	905	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
868	906
869	907	const S = struct {
870	908	fn foo() ?anyerror!u32 {
...	...	@@ -878,6 +916,7 @@ test "optional error union return type" {
878	916	test "optional error set return type" {
879	917	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
880	918	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	919	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
881	920
882	921	const E = error{ A, B };
883	922	const S = struct {

test/behavior/eval.zig+54

...	...	@@ -5,6 +5,8 @@ const expect = std.testing.expect;
5	5	const expectEqual = std.testing.expectEqual;
6	6
7	7	test "compile time recursion" {
	8	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	9
8	10	try expect(some_data.len == 21);
9	11	}
10	12	var some_data: [@intCast(usize, fibonacci(7))]u8 = undefined;
...	...	@@ -21,6 +23,7 @@ test "static add one" {
21	23	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
22	24	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
23	25	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	26	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
24	27
25	28	try expect(should_be_1235 == 1235);
26	29	}
...	...	@@ -45,6 +48,8 @@ test "inline variable gets result of const if" {
45	48	}
46	49
47	50	test "static function evaluation" {
	51	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	52
48	53	try expect(statically_added_number == 3);
49	54	}
50	55	const statically_added_number = staticAdd(1, 2);
...	...	@@ -72,6 +77,7 @@ fn constExprEvalOnSingleExprBlocksFn(x: i32, b: bool) i32 {
72	77	test "constant expressions" {
73	78	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
74	79	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	80	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
75	81
76	82	var array: [array_size]u8 = undefined;
77	83	try expect(@sizeOf(@TypeOf(array)) == 20);
...	...	@@ -140,6 +146,7 @@ test "pointer to type" {
140	146	test "a type constructed in a global expression" {
141	147	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
142	148	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	149	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
143	150
144	151	var l: List = undefined;
145	152	l.array[0] = 10;
...	...	@@ -198,6 +205,8 @@ test "@setEvalBranchQuota" {
198	205	}
199	206
200	207	test "constant struct with negation" {
	208	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	209
201	210	try expect(vertices[0].x == @as(f32, -0.6));
202	211	}
203	212	const Vertex = struct {
...	...	@@ -302,6 +311,8 @@ fn performFn(comptime prefix_char: u8, start_value: i32) i32 {
302	311	}
303	312
304	313	test "comptime iterate over fn ptr list" {
	314	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	315
305	316	try expect(performFn('t', 1) == 6);
306	317	try expect(performFn('o', 0) == 1);
307	318	try expect(performFn('w', 99) == 99);
...	...	@@ -340,6 +351,7 @@ fn doesAlotT(comptime T: type, value: usize) T {
340	351	test "@setEvalBranchQuota at same scope as generic function call" {
341	352	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
342	353	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	354	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
343	355
344	356	try expect(doesAlotT(u32, 2) == 2);
345	357	}
...	...	@@ -376,6 +388,8 @@ test "zero extend from u0 to u1" {
376	388	}
377	389
378	390	test "return 0 from function that has u0 return type" {
	391	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	392
379	393	const S = struct {
380	394	fn foo_zero() u0 {
381	395	return 0;
...	...	@@ -391,6 +405,7 @@ test "return 0 from function that has u0 return type" {
391	405	test "statically initialized struct" {
392	406	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
393	407	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	408	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
394	409
395	410	st_init_str_foo.x += 1;
396	411	try expect(st_init_str_foo.x == 14);
...	...	@@ -405,6 +420,8 @@ var st_init_str_foo = StInitStrFoo{
405	420	};
406	421
407	422	test "inline for with same type but different values" {
	423	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	424
408	425	var res: usize = 0;
409	426	inline for ([_]type{ [2]u8, [1]u8, [2]u8 }) \|T\| {
410	427	var a: T = undefined;
...	...	@@ -440,6 +457,7 @@ test "binary math operator in partially inlined function" {
440	457	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
441	458	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
442	459	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	460	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
443	461
444	462	var s: [4]u32 = undefined;
445	463	var b: [16]u8 = undefined;
...	...	@@ -459,6 +477,7 @@ test "comptime shl" {
459	477	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
460	478	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
461	479	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	480	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
462	481
463	482	var a: u128 = 3;
464	483	var b: u7 = 63;
...	...	@@ -486,6 +505,7 @@ test "comptime bitwise operators" {
486	505	test "comptime shlWithOverflow" {
487	506	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
488	507	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
	508	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
489	509
490	510	const ct_shifted = @shlWithOverflow(~@as(u64, 0), 16)[0];
491	511	var a = ~@as(u64, 0);
...	...	@@ -497,6 +517,7 @@ test "comptime shlWithOverflow" {
497	517	test "const ptr to variable data changes at runtime" {
498	518	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
499	519	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	520	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
500	521
501	522	try expect(foo_ref.name[0] == 'a');
502	523	foo_ref.name = "b";
...	...	@@ -516,6 +537,7 @@ test "runtime 128 bit integer division" {
516	537	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
517	538	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
518	539	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	540	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
519	541
520	542	var a: u128 = 152313999999999991610955792383;
521	543	var b: u128 = 10000000000000000000;
...	...	@@ -526,6 +548,7 @@ test "runtime 128 bit integer division" {
526	548	test "@tagName of @typeInfo" {
527	549	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
528	550	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	551	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
529	552
530	553	const str = @tagName(@typeInfo(u8));
531	554	try expect(std.mem.eql(u8, str, "Int"));
...	...	@@ -535,6 +558,7 @@ test "static eval list init" {
535	558	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
536	559	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
537	560	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	561	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
538	562
539	563	try expect(static_vec3.data[2] == 1.0);
540	564	try expect(vec3(0.0, 0.0, 3.0).data[2] == 3.0);
...	...	@@ -566,6 +590,7 @@ test "inlined loop has array literal with elided runtime scope on first iteratio
566	590	test "ptr to local array argument at comptime" {
567	591	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
568	592	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	593	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
569	594
570	595	comptime {
571	596	var bytes: [10]u8 = undefined;
...	...	@@ -602,6 +627,7 @@ const hi1 = "hi";
602	627	const hi2 = hi1;
603	628	test "const global shares pointer with other same one" {
604	629	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	630	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
605	631
606	632	try assertEqualPtrs(&hi1[0], &hi2[0]);
607	633	comptime try expect(&hi1[0] == &hi2[0]);
...	...	@@ -637,6 +663,8 @@ pub fn TypeWithCompTimeSlice(comptime field_name: []const u8) type {
637	663	}
638	664
639	665	test "comptime function with mutable pointer is not memoized" {
	666	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	667
640	668	comptime {
641	669	var x: i32 = 1;
642	670	const ptr = &x;
...	...	@@ -728,6 +756,7 @@ test "array concatenation of function calls" {
728	756	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
729	757	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
730	758	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	759	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
731	760
732	761	var a = oneItem(3) ++ oneItem(4);
733	762	try expect(std.mem.eql(i32, &a, &[_]i32{ 3, 4 }));
...	...	@@ -737,6 +766,7 @@ test "array multiplication of function calls" {
737	766	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
738	767	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
739	768	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	769	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
740	770
741	771	var a = oneItem(3) ** scalar(2);
742	772	try expect(std.mem.eql(i32, &a, &[_]i32{ 3, 3 }));
...	...	@@ -754,6 +784,7 @@ test "array concatenation peer resolves element types - value" {
754	784	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
755	785	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
756	786	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	787	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
757	788
758	789	var a = [2]u3{ 1, 7 };
759	790	var b = [3]u8{ 200, 225, 255 };
...	...	@@ -770,6 +801,7 @@ test "array concatenation peer resolves element types - pointer" {
770	801	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
771	802	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
772	803	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	804	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
773	805
774	806	var a = [2]u3{ 1, 7 };
775	807	var b = [3]u8{ 200, 225, 255 };
...	...	@@ -788,6 +820,7 @@ test "array concatenation sets the sentinel - value" {
788	820	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
789	821	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
790	822	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	823	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
791	824
792	825	var a = [2]u3{ 1, 7 };
793	826	var b = [3:69]u8{ 200, 225, 255 };
...	...	@@ -805,6 +838,7 @@ test "array concatenation sets the sentinel - value" {
805	838	test "array concatenation sets the sentinel - pointer" {
806	839	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
807	840	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	841	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
808	842
809	843	var a = [2]u3{ 1, 7 };
810	844	var b = [3:69]u8{ 200, 225, 255 };
...	...	@@ -825,6 +859,7 @@ test "array multiplication sets the sentinel - value" {
825	859	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
826	860	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
827	861	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	862	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
828	863
829	864	var a = [2:7]u3{ 1, 6 };
830	865	var b = a ** 2;
...	...	@@ -841,6 +876,7 @@ test "array multiplication sets the sentinel - pointer" {
841	876	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
842	877	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
843	878	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	879	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
844	880
845	881	var a = [2:7]u3{ 1, 6 };
846	882	var b = &a ** 2;
...	...	@@ -965,6 +1001,7 @@ test "closure capture type of runtime-known parameter" {
965	1001
966	1002	test "comptime break passing through runtime condition converted to runtime break" {
967	1003	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	1004	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
968	1005
969	1006	const S = struct {
970	1007	fn doTheTest() !void {
...	...	@@ -998,6 +1035,7 @@ test "comptime break to outer loop passing through runtime condition converted t
998	1035	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
999	1036	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1000	1037	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	1038	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1001	1039
1002	1040	const S = struct {
1003	1041	fn doTheTest() !void {
...	...	@@ -1069,6 +1107,7 @@ test "comptime break operand passing through runtime switch converted to runtime
1069	1107	test "no dependency loop for alignment of self struct" {
1070	1108	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1071	1109	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	1110	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1072	1111
1073	1112	const S = struct {
1074	1113	fn doTheTest() !void {
...	...	@@ -1106,6 +1145,7 @@ test "no dependency loop for alignment of self struct" {
1106	1145	test "no dependency loop for alignment of self bare union" {
1107	1146	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1108	1147	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	1148	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1109	1149
1110	1150	const S = struct {
1111	1151	fn doTheTest() !void {
...	...	@@ -1143,6 +1183,7 @@ test "no dependency loop for alignment of self bare union" {
1143	1183	test "no dependency loop for alignment of self tagged union" {
1144	1184	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1145	1185	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	1186	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1146	1187
1147	1188	const S = struct {
1148	1189	fn doTheTest() !void {
...	...	@@ -1186,6 +1227,7 @@ test "storing an array of type in a field" {
1186	1227	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1187	1228	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1188	1229	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	1230	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1189	1231
1190	1232	const S = struct {
1191	1233	fn doTheTest() void {
...	...	@@ -1214,6 +1256,7 @@ test "storing an array of type in a field" {
1214	1256	test "pass pointer to field of comptime-only type as a runtime parameter" {
1215	1257	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1216	1258	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	1259	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1217	1260
1218	1261	const S = struct {
1219	1262	const Mixed = struct {
...	...	@@ -1331,6 +1374,7 @@ test "lazy value is resolved as slice operand" {
1331	1374	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1332	1375	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1333	1376	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	1377	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1334	1378
1335	1379	const A = struct { a: u32 };
1336	1380	var a: [512]u64 = undefined;
...	...	@@ -1388,6 +1432,7 @@ test "inline for inside a runtime condition" {
1388	1432
1389	1433	test "continue in inline for inside a comptime switch" {
1390	1434	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	1435	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1391	1436
1392	1437	const arr = .{ 1, 2, 3 };
1393	1438	var count: u8 = 0;
...	...	@@ -1453,6 +1498,7 @@ test "continue nested inline for loop in named block expr" {
1453	1498
1454	1499	test "x and false is comptime-known false" {
1455	1500	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	1501	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1456	1502
1457	1503	const T = struct {
1458	1504	var x: u32 = 0;
...	...	@@ -1480,6 +1526,7 @@ test "x and false is comptime-known false" {
1480	1526
1481	1527	test "x or true is comptime-known true" {
1482	1528	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	1529	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1483	1530
1484	1531	const T = struct {
1485	1532	var x: u32 = 0;
...	...	@@ -1510,6 +1557,7 @@ test "non-optional and optional array elements concatenated" {
1510	1557	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1511	1558	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
1512	1559	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	1560	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1513	1561
1514	1562	const array = [1]u8{'A'} ++ [1]?u8{null};
1515	1563	var index: usize = 0;
...	...	@@ -1540,6 +1588,8 @@ test "comptime function turns function value to function pointer" {
1540	1588	}
1541	1589
1542	1590	test "container level const and var have unique addresses" {
	1591	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1592
1543	1593	const S = struct {
1544	1594	x: i32,
1545	1595	y: i32,
...	...	@@ -1596,6 +1646,8 @@ test "result of nested switch assigned to variable" {
1596	1646	}
1597	1647
1598	1648	test "inline for loop of functions returning error unions" {
	1649	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1650
1599	1651	const T1 = struct {
1600	1652	fn v() error{}!usize {
1601	1653	return 1;
...	...	@@ -1649,6 +1701,8 @@ test "early exit in container level const" {
1649	1701	}
1650	1702
1651	1703	test "@inComptime" {
	1704	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1705
1652	1706	const S = struct {
1653	1707	fn inComptime() bool {
1654	1708	return @inComptime();

test/behavior/field_parent_ptr.zig+7

...	...	@@ -4,6 +4,8 @@ const builtin = @import("builtin");
4	4	test "@fieldParentPtr non-first field" {
5	5	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
6	6	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	7	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	8
7	9	try testParentFieldPtr(&foo.c);
8	10	comptime try testParentFieldPtr(&foo.c);
9	11	}
...	...	@@ -12,6 +14,8 @@ test "@fieldParentPtr first field" {
12	14	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
13	15	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
14	16	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	17	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	18
15	19	try testParentFieldPtrFirst(&foo.a);
16	20	comptime try testParentFieldPtrFirst(&foo.a);
17	21	}
...	...	@@ -51,6 +55,7 @@ test "@fieldParentPtr untagged union" {
51	55	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
52	56	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
53	57	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	58	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
54	59
55	60	try testFieldParentPtrUnion(&bar.c);
56	61	comptime try testFieldParentPtrUnion(&bar.c);
...	...	@@ -78,6 +83,7 @@ test "@fieldParentPtr tagged union" {
78	83	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
79	84	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
80	85	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	86	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
81	87
82	88	try testFieldParentPtrTaggedUnion(&bar_tagged.c);
83	89	comptime try testFieldParentPtrTaggedUnion(&bar_tagged.c);
...	...	@@ -105,6 +111,7 @@ test "@fieldParentPtr extern union" {
105	111	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
106	112	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
107	113	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	114	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
108	115
109	116	try testFieldParentPtrExternUnion(&bar_extern.c);
110	117	comptime try testFieldParentPtrExternUnion(&bar_extern.c);

test/behavior/floatop.zig+51

...	...	@@ -58,6 +58,7 @@ test "different sized float comparisons" {
58	58	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
59	59	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
60	60	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	61	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
61	62
62	63	try testDifferentSizedFloatComparisons();
63	64	comptime try testDifferentSizedFloatComparisons();
...	...	@@ -101,6 +102,7 @@ test "@sqrt" {
101	102	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
102	103	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
103	104	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	105	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
104	106
105	107	comptime try testSqrt();
106	108	try testSqrt();
...	...	@@ -138,6 +140,7 @@ test "@sqrt with vectors" {
138	140	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
139	141	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
140	142	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	143	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
141	144
142	145	comptime try testSqrtWithVectors();
143	146	try testSqrtWithVectors();
...	...	@@ -157,6 +160,7 @@ test "more @sqrt f16 tests" {
157	160	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
158	161	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
159	162	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	163	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
160	164
161	165	// TODO these are not all passing at comptime
162	166	try expect(@sqrt(@as(f16, 0.0)) == 0.0);
...	...	@@ -181,6 +185,7 @@ test "another, possibly redundant @sqrt test" {
181	185	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
182	186	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
183	187	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
	188	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
184	189
185	190	try testSqrtLegacy(f64, 12.0);
186	191	comptime try testSqrtLegacy(f64, 12.0);
...	...	@@ -207,6 +212,7 @@ test "@sin" {
207	212	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
208	213	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
209	214	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	215	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
210	216
211	217	comptime try testSin();
212	218	try testSin();
...	...	@@ -227,6 +233,7 @@ test "@sin with vectors" {
227	233	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
228	234	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
229	235	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	236	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
230	237
231	238	comptime try testSinWithVectors();
232	239	try testSinWithVectors();
...	...	@@ -246,6 +253,7 @@ test "@cos" {
246	253	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
247	254	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
248	255	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	256	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
249	257
250	258	comptime try testCos();
251	259	try testCos();
...	...	@@ -266,6 +274,7 @@ test "@cos with vectors" {
266	274	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
267	275	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
268	276	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	277	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
269	278
270	279	comptime try testCosWithVectors();
271	280	try testCosWithVectors();
...	...	@@ -285,6 +294,7 @@ test "@exp" {
285	294	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
286	295	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
287	296	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	297	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
288	298
289	299	comptime try testExp();
290	300	try testExp();
...	...	@@ -304,6 +314,7 @@ test "@exp with vectors" {
304	314	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
305	315	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
306	316	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	317	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
307	318
308	319	comptime try testExpWithVectors();
309	320	try testExpWithVectors();
...	...	@@ -323,6 +334,7 @@ test "@exp2" {
323	334	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
324	335	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
325	336	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	337	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
326	338
327	339	comptime try testExp2();
328	340	try testExp2();
...	...	@@ -342,6 +354,7 @@ test "@exp2 with @vectors" {
342	354	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
343	355	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
344	356	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	357	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
345	358
346	359	comptime try testExp2WithVectors();
347	360	try testExp2WithVectors();
...	...	@@ -361,6 +374,7 @@ test "@log" {
361	374	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
362	375	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
363	376	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	377	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
364	378
365	379	comptime try testLog();
366	380	try testLog();
...	...	@@ -392,6 +406,7 @@ test "@log with @vectors" {
392	406	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
393	407	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
394	408	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	409	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
395	410
396	411	{
397	412	var v: @Vector(4, f32) = [_]f32{ 1.1, 2.2, 0.3, 0.4 };
...	...	@@ -408,6 +423,7 @@ test "@log2" {
408	423	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
409	424	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
410	425	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	426	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
411	427
412	428	comptime try testLog2();
413	429	try testLog2();
...	...	@@ -427,6 +443,7 @@ test "@log2 with vectors" {
427	443	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
428	444	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
429	445	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	446	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
430	447	// https://github.com/ziglang/zig/issues/13681
431	448	if (builtin.zig_backend == .stage2_llvm and
432	449	builtin.cpu.arch == .aarch64 and
...	...	@@ -450,6 +467,7 @@ test "@log10" {
450	467	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
451	468	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
452	469	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	470	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
453	471
454	472	comptime try testLog10();
455	473	try testLog10();
...	...	@@ -469,6 +487,7 @@ test "@log10 with vectors" {
469	487	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
470	488	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
471	489	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	490	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
472	491
473	492	comptime try testLog10WithVectors();
474	493	try testLog10WithVectors();
...	...	@@ -487,6 +506,7 @@ test "@fabs" {
487	506	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
488	507	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
489	508	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	509	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
490	510
491	511	comptime try testFabs();
492	512	try testFabs();
...	...	@@ -515,6 +535,7 @@ test "@fabs with vectors" {
515	535	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
516	536	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
517	537	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	538	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
518	539
519	540	comptime try testFabsWithVectors();
520	541	try testFabsWithVectors();
...	...	@@ -534,6 +555,7 @@ test "another, possibly redundant, @fabs test" {
534	555	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
535	556	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
536	557	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
	558	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
537	559
538	560	try testFabsLegacy(f128, 12.0);
539	561	comptime try testFabsLegacy(f128, 12.0);
...	...	@@ -555,6 +577,7 @@ test "@fabs f80" {
555	577	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
556	578	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
557	579	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
	580	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
558	581
559	582	try testFabsLegacy(f80, 12.0);
560	583	comptime try testFabsLegacy(f80, 12.0);
...	...	@@ -571,6 +594,7 @@ test "a third @fabs test, surely there should not be three fabs tests" {
571	594	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
572	595	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
573	596	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
	597	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
574	598
575	599	inline for ([_]type{ f16, f32, f64, f80, f128, c_longdouble }) \|T\| {
576	600	// normals
...	...	@@ -598,6 +622,7 @@ test "@floor" {
598	622	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
599	623	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
600	624	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	625	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
601	626
602	627	comptime try testFloor();
603	628	try testFloor();
...	...	@@ -622,6 +647,7 @@ test "@floor with vectors" {
622	647	!comptime std.Target.x86.featureSetHas(builtin.cpu.features, .sse4_1)) return error.SkipZigTest; // TODO
623	648	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
624	649	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	650	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
625	651
626	652	comptime try testFloorWithVectors();
627	653	try testFloorWithVectors();
...	...	@@ -640,6 +666,7 @@ test "another, possibly redundant, @floor test" {
640	666	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
641	667	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
642	668	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
	669	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
643	670
644	671	try testFloorLegacy(f64, 12.0);
645	672	comptime try testFloorLegacy(f64, 12.0);
...	...	@@ -659,6 +686,7 @@ test "@floor f80" {
659	686	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
660	687	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
661	688	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
	689	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
662	690
663	691	if (builtin.zig_backend == .stage2_llvm and builtin.os.tag == .windows) {
664	692	// https://github.com/ziglang/zig/issues/12602
...	...	@@ -674,6 +702,7 @@ test "@floor f128" {
674	702	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
675	703	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
676	704	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
	705	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
677	706
678	707	try testFloorLegacy(f128, 12.0);
679	708	comptime try testFloorLegacy(f128, 12.0);
...	...	@@ -689,6 +718,7 @@ test "@ceil" {
689	718	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
690	719	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
691	720	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	721	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
692	722
693	723	comptime try testCeil();
694	724	try testCeil();
...	...	@@ -713,6 +743,7 @@ test "@ceil with vectors" {
713	743	!comptime std.Target.x86.featureSetHas(builtin.cpu.features, .sse4_1)) return error.SkipZigTest; // TODO
714	744	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
715	745	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	746	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
716	747
717	748	comptime try testCeilWithVectors();
718	749	try testCeilWithVectors();
...	...	@@ -731,6 +762,7 @@ test "another, possibly redundant, @ceil test" {
731	762	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
732	763	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
733	764	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
	765	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
734	766
735	767	try testCeilLegacy(f64, 12.0);
736	768	comptime try testCeilLegacy(f64, 12.0);
...	...	@@ -750,6 +782,7 @@ test "@ceil f80" {
750	782	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
751	783	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
752	784	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
	785	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
753	786
754	787	if (builtin.zig_backend == .stage2_llvm and builtin.os.tag == .windows) {
755	788	// https://github.com/ziglang/zig/issues/12602
...	...	@@ -765,6 +798,7 @@ test "@ceil f128" {
765	798	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
766	799	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
767	800	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
	801	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
768	802
769	803	try testCeilLegacy(f128, 12.0);
770	804	comptime try testCeilLegacy(f128, 12.0);
...	...	@@ -804,6 +838,7 @@ test "@trunc with vectors" {
804	838	!comptime std.Target.x86.featureSetHas(builtin.cpu.features, .sse4_1)) return error.SkipZigTest; // TODO
805	839	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
806	840	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	841	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
807	842
808	843	comptime try testTruncWithVectors();
809	844	try testTruncWithVectors();
...	...	@@ -822,6 +857,7 @@ test "another, possibly redundant, @trunc test" {
822	857	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
823	858	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
824	859	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
	860	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
825	861
826	862	try testTruncLegacy(f64, 12.0);
827	863	comptime try testTruncLegacy(f64, 12.0);
...	...	@@ -841,6 +877,7 @@ test "@trunc f80" {
841	877	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
842	878	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
843	879	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
	880	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
844	881
845	882	if (builtin.zig_backend == .stage2_llvm and builtin.os.tag == .windows) {
846	883	// https://github.com/ziglang/zig/issues/12602
...	...	@@ -862,6 +899,7 @@ test "@trunc f128" {
862	899	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
863	900	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
864	901	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
	902	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
865	903
866	904	try testTruncLegacy(f128, 12.0);
867	905	comptime try testTruncLegacy(f128, 12.0);
...	...	@@ -886,6 +924,7 @@ test "negation f16" {
886	924	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
887	925	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
888	926	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	927	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
889	928
890	929	if (builtin.os.tag == .freebsd) {
891	930	// TODO file issue to track this failure
...	...	@@ -910,6 +949,7 @@ test "negation f32" {
910	949	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
911	950	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
912	951	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	952	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
913	953
914	954	const S = struct {
915	955	fn doTheTest() !void {
...	...	@@ -929,6 +969,7 @@ test "negation f64" {
929	969	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
930	970	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
931	971	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	972	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
932	973
933	974	const S = struct {
934	975	fn doTheTest() !void {
...	...	@@ -950,6 +991,7 @@ test "negation f80" {
950	991	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
951	992	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
952	993	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	994	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
953	995
954	996	const S = struct {
955	997	fn doTheTest() !void {
...	...	@@ -971,6 +1013,7 @@ test "negation f128" {
971	1013	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
972	1014	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
973	1015	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	1016	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
974	1017
975	1018	const S = struct {
976	1019	fn doTheTest() !void {
...	...	@@ -989,6 +1032,7 @@ test "negation f128" {
989	1032	test "eval @setFloatMode at compile-time" {
990	1033	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
991	1034	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	1035	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
992	1036
993	1037	const result = comptime fnWithFloatMode();
994	1038	try expect(result == 1234.0);
...	...	@@ -1014,6 +1058,7 @@ test "comptime fixed-width float zero divided by zero produces NaN" {
1014	1058	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1015	1059	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1016	1060	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	1061	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1017	1062
1018	1063	inline for (.{ f16, f32, f64, f80, f128 }) \|F\| {
1019	1064	try expect(math.isNan(@as(F, 0) / @as(F, 0)));
...	...	@@ -1025,6 +1070,7 @@ test "comptime fixed-width float non-zero divided by zero produces signed Inf" {
1025	1070	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1026	1071	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1027	1072	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	1073	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1028	1074
1029	1075	inline for (.{ f16, f32, f64, f80, f128 }) \|F\| {
1030	1076	const pos = @as(F, 1) / @as(F, 0);
...	...	@@ -1044,6 +1090,7 @@ test "nan negation f16" {
1044	1090	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1045	1091	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1046	1092	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	1093	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1047	1094
1048	1095	const nan_comptime = comptime math.nan(f16);
1049	1096	const neg_nan_comptime = -nan_comptime;
...	...	@@ -1062,6 +1109,7 @@ test "nan negation f32" {
1062	1109	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1063	1110	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1064	1111	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	1112	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1065	1113
1066	1114	const nan_comptime = comptime math.nan(f32);
1067	1115	const neg_nan_comptime = -nan_comptime;
...	...	@@ -1081,6 +1129,7 @@ test "nan negation f64" {
1081	1129	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1082	1130	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1083	1131	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	1132	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1084	1133
1085	1134	const nan_comptime = comptime math.nan(f64);
1086	1135	const neg_nan_comptime = -nan_comptime;
...	...	@@ -1101,6 +1150,7 @@ test "nan negation f128" {
1101	1150	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1102	1151	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1103	1152	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	1153	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1104	1154
1105	1155	const nan_comptime = comptime math.nan(f128);
1106	1156	const neg_nan_comptime = -nan_comptime;
...	...	@@ -1121,6 +1171,7 @@ test "nan negation f80" {
1121	1171	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1122	1172	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1123	1173	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	1174	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1124	1175
1125	1176	const nan_comptime = comptime math.nan(f80);
1126	1177	const neg_nan_comptime = -nan_comptime;

test/behavior/fn.zig+33

...	...	@@ -5,6 +5,8 @@ const expect = testing.expect;
5	5	const expectEqual = testing.expectEqual;
6	6
7	7	test "params" {
	8	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	9
8	10	try expect(testParamsAdd(22, 11) == 33);
9	11	}
10	12	fn testParamsAdd(a: i32, b: i32) i32 {
...	...	@@ -12,6 +14,8 @@ fn testParamsAdd(a: i32, b: i32) i32 {
12	14	}
13	15
14	16	test "local variables" {
	17	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	18
15	19	testLocVars(2);
16	20	}
17	21	fn testLocVars(b: i32) void {
...	...	@@ -20,6 +24,8 @@ fn testLocVars(b: i32) void {
20	24	}
21	25
22	26	test "mutable local variables" {
	27	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	28
23	29	var zero: i32 = 0;
24	30	try expect(zero == 0);
25	31
...	...	@@ -51,6 +57,8 @@ test "weird function name" {
51	57	}
52	58
53	59	test "assign inline fn to const variable" {
	60	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	61
54	62	const a = inlineFn;
55	63	a();
56	64	}
...	...	@@ -68,6 +76,8 @@ fn outer(y: u32) *const fn (u32) u32 {
68	76	}
69	77
70	78	test "return inner function which references comptime variable of outer function" {
	79	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	80
71	81	var func = outer(10);
72	82	try expect(func(3) == 7);
73	83	}
...	...	@@ -99,6 +109,7 @@ test "inline function call that calls optional function pointer, return pointer
99	109	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
100	110	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
101	111	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	112	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
102	113
103	114	const S = struct {
104	115	field: u32,
...	...	@@ -144,6 +155,7 @@ fn fnWithUnreachable() noreturn {
144	155
145	156	test "extern struct with stdcallcc fn pointer" {
146	157	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
	158	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
147	159
148	160	const S = extern struct {
149	161	ptr: *const fn () callconv(if (builtin.target.cpu.arch == .x86) .Stdcall else .C) i32,
...	...	@@ -174,12 +186,14 @@ test "function with complex callconv and return type expressions" {
174	186	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
175	187	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
176	188	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	189	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
177	190
178	191	try expect(fComplexCallconvRet(3).x == 9);
179	192	}
180	193
181	194	test "pass by non-copying value" {
182	195	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	196	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
183	197
184	198	try expect(addPointCoords(Point{ .x = 1, .y = 2 }) == 3);
185	199	}
...	...	@@ -195,6 +209,7 @@ fn addPointCoords(pt: Point) i32 {
195	209
196	210	test "pass by non-copying value through var arg" {
197	211	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	212	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
198	213
199	214	try expect((try addPointCoordsVar(Point{ .x = 1, .y = 2 })) == 3);
200	215	}
...	...	@@ -206,6 +221,7 @@ fn addPointCoordsVar(pt: anytype) !i32 {
206	221
207	222	test "pass by non-copying value as method" {
208	223	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	224	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
209	225
210	226	var pt = Point2{ .x = 1, .y = 2 };
211	227	try expect(pt.addPointCoords() == 3);
...	...	@@ -222,6 +238,7 @@ const Point2 = struct {
222	238
223	239	test "pass by non-copying value as method, which is generic" {
224	240	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	241	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
225	242
226	243	var pt = Point3{ .x = 1, .y = 2 };
227	244	try expect(pt.addPointCoords(i32) == 3);
...	...	@@ -239,6 +256,7 @@ const Point3 = struct {
239	256
240	257	test "pass by non-copying value as method, at comptime" {
241	258	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	259	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
242	260
243	261	comptime {
244	262	var pt = Point2{ .x = 1, .y = 2 };
...	...	@@ -250,6 +268,7 @@ test "implicit cast fn call result to optional in field result" {
250	268	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
251	269	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
252	270	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	271	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
253	272
254	273	const S = struct {
255	274	fn entry() !void {
...	...	@@ -276,6 +295,7 @@ test "implicit cast fn call result to optional in field result" {
276	295	test "void parameters" {
277	296	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
278	297	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	298	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
279	299
280	300	try voidFun(1, void{}, 2, {});
281	301	}
...	...	@@ -301,6 +321,7 @@ test "function pointers" {
301	321	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
302	322	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
303	323	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	324	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
304	325
305	326	const fns = [_]*const @TypeOf(fn1){
306	327	&fn1,
...	...	@@ -338,6 +359,7 @@ test "function call with anon list literal" {
338	359	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
339	360	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
340	361	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	362	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
341	363
342	364	const S = struct {
343	365	fn doTheTest() !void {
...	...	@@ -358,6 +380,7 @@ test "function call with anon list literal - 2D" {
358	380	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
359	381	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
360	382	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	383	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
361	384
362	385	const S = struct {
363	386	fn doTheTest() !void {
...	...	@@ -376,6 +399,8 @@ test "function call with anon list literal - 2D" {
376	399	}
377	400
378	401	test "ability to give comptime types and non comptime types to same parameter" {
	402	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	403
379	404	const S = struct {
380	405	fn doTheTest() !void {
381	406	var x: i32 = 1;
...	...	@@ -393,6 +418,8 @@ test "ability to give comptime types and non comptime types to same parameter" {
393	418	}
394	419
395	420	test "function with inferred error set but returning no error" {
	421	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	422
396	423	const S = struct {
397	424	fn foo() !void {}
398	425	};
...	...	@@ -403,6 +430,7 @@ test "function with inferred error set but returning no error" {
403	430
404	431	test "import passed byref to function in return type" {
405	432	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	433	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
406	434
407	435	const S = struct {
408	436	fn get() @import("std").ArrayListUnmanaged(i32) {
...	...	@@ -419,6 +447,7 @@ test "implicit cast function to function ptr" {
419	447	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
420	448	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
421	449	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
	450	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
422	451
423	452	const S1 = struct {
424	453	export fn someFunctionThatReturnsAValue() c_int {
...	...	@@ -437,6 +466,7 @@ test "implicit cast function to function ptr" {
437	466	test "method call with optional and error union first param" {
438	467	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
439	468	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	469	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
440	470
441	471	const S = struct {
442	472	x: i32 = 1234,
...	...	@@ -456,6 +486,7 @@ test "method call with optional and error union first param" {
456	486	test "method call with optional pointer first param" {
457	487	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
458	488	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	489	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
459	490
460	491	const S = struct {
461	492	x: i32 = 1234,
...	...	@@ -475,6 +506,7 @@ test "using @ptrCast on function pointers" {
475	506	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
476	507	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
477	508	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	509	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
478	510
479	511	const S = struct {
480	512	const A = struct { data: [4]u8 };
...	...	@@ -512,6 +544,7 @@ test "function returns function returning type" {
512	544
513	545	test "peer type resolution of inferred error set with non-void payload" {
514	546	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	547	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
515	548
516	549	const S = struct {
517	550	fn openDataFile(mode: enum { read, write }) !u32 {

test/behavior/fn_delegation.zig+1

...	...	@@ -34,6 +34,7 @@ fn custom(comptime T: type, comptime num: u64) fn (T) u64 {
34	34	test "fn delegation" {
35	35	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
36	36	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	37	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
37	38
38	39	const foo = Foo{};
39	40	try expect(foo.one() == 11);

test/behavior/fn_in_struct_in_comptime.zig+3

...	...	@@ -1,3 +1,4 @@
	1	const builtin = @import("builtin");
1	2	const expect = @import("std").testing.expect;
2	3
3	4	fn get_foo() fn (*u8) usize {
...	...	@@ -12,6 +13,8 @@ fn get_foo() fn (*u8) usize {
12	13	}
13	14
14	15	test "define a function in an anonymous struct in comptime" {
	16	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	17
15	18	const foo = get_foo();
16	19	try expect(foo(@intToPtr(*u8, 12345)) == 12345);
17	20	}

test/behavior/for.zig+22

...	...	@@ -7,6 +7,7 @@ const mem = std.mem;
7	7	test "continue in for loop" {
8	8	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
9	9	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	10	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
10	11
11	12	const array = [_]i32{ 1, 2, 3, 4, 5 };
12	13	var sum: i32 = 0;
...	...	@@ -21,6 +22,8 @@ test "continue in for loop" {
21	22	}
22	23
23	24	test "break from outer for loop" {
	25	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	26
24	27	try testBreakOuter();
25	28	comptime try testBreakOuter();
26	29	}
...	...	@@ -38,6 +41,8 @@ fn testBreakOuter() !void {
38	41	}
39	42
40	43	test "continue outer for loop" {
	44	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	45
41	46	try testContinueOuter();
42	47	comptime try testContinueOuter();
43	48	}
...	...	@@ -69,6 +74,7 @@ test "basic for loop" {
69	74	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
70	75	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
71	76	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	77	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
72	78
73	79	const expected_result = [_]u8{ 9, 8, 7, 6, 0, 1, 2, 3 } ** 3;
74	80
...	...	@@ -112,6 +118,7 @@ test "for with null and T peer types and inferred result location type" {
112	118	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
113	119	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
114	120	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	121	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
115	122
116	123	const S = struct {
117	124	fn doTheTest(slice: []const u8) !void {
...	...	@@ -132,6 +139,7 @@ test "for with null and T peer types and inferred result location type" {
132	139	test "2 break statements and an else" {
133	140	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
134	141	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	142	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
135	143
136	144	const S = struct {
137	145	fn entry(t: bool, f: bool) !void {
...	...	@@ -153,6 +161,7 @@ test "for loop with pointer elem var" {
153	161	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
154	162	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
155	163	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	164	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
156	165
157	166	const source = "abcdefg";
158	167	var target: [source.len]u8 = undefined;
...	...	@@ -179,6 +188,7 @@ fn mangleString(s: []u8) void {
179	188	test "for copies its payload" {
180	189	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
181	190	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	191	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
182	192
183	193	const S = struct {
184	194	fn doTheTest() !void {
...	...	@@ -198,6 +208,7 @@ test "for on slice with allowzero ptr" {
198	208	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
199	209	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
200	210	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	211	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
201	212
202	213	const S = struct {
203	214	fn doTheTest(slice: []const u8) !void {
...	...	@@ -213,6 +224,7 @@ test "for on slice with allowzero ptr" {
213	224	test "else continue outer for" {
214	225	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
215	226	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	227	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
216	228
217	229	var i: usize = 6;
218	230	var buf: [5]u8 = undefined;
...	...	@@ -226,6 +238,7 @@ test "else continue outer for" {
226	238
227	239	test "for loop with else branch" {
228	240	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	241	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
229	242
230	243	{
231	244	var x = [_]u32{ 1, 2 };
...	...	@@ -248,6 +261,7 @@ test "for loop with else branch" {
248	261	test "count over fixed range" {
249	262	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
250	263	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	264	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
251	265
252	266	var sum: usize = 0;
253	267	for (0..6) \|i\| {
...	...	@@ -260,6 +274,7 @@ test "count over fixed range" {
260	274	test "two counters" {
261	275	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
262	276	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	277	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
263	278
264	279	var sum: usize = 0;
265	280	for (0..10, 10..20) \|i, j\| {
...	...	@@ -273,6 +288,7 @@ test "two counters" {
273	288	test "1-based counter and ptr to array" {
274	289	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
275	290	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	291	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
276	292
277	293	var ok: usize = 0;
278	294
...	...	@@ -306,6 +322,7 @@ test "slice and two counters, one is offset and one is runtime" {
306	322	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
307	323	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
308	324	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	325	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
309	326
310	327	const slice: []const u8 = "blah";
311	328	var start: usize = 0;
...	...	@@ -334,6 +351,7 @@ test "two slices, one captured by-ref" {
334	351	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
335	352	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
336	353	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	354	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
337	355
338	356	var buf: [10]u8 = undefined;
339	357	const slice1: []const u8 = "blah";
...	...	@@ -353,6 +371,7 @@ test "raw pointer and slice" {
353	371	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
354	372	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
355	373	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	374	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
356	375
357	376	var buf: [10]u8 = undefined;
358	377	const slice: []const u8 = "blah";
...	...	@@ -372,6 +391,7 @@ test "raw pointer and counter" {
372	391	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
373	392	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
374	393	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	394	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
375	395
376	396	var buf: [10]u8 = undefined;
377	397	const ptr: [*]u8 = &buf;
...	...	@@ -390,6 +410,7 @@ test "inline for with slice as the comptime-known" {
390	410	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
391	411	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
392	412	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	413	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
393	414
394	415	const comptime_slice = "hello";
395	416	var runtime_i: usize = 3;
...	...	@@ -420,6 +441,7 @@ test "inline for with counter as the comptime-known" {
420	441	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
421	442	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
422	443	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	444	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
423	445
424	446	var runtime_slice = "hello";
425	447	var runtime_i: usize = 3;

test/behavior/generics.zig+24

...	...	@@ -5,6 +5,8 @@ const expect = testing.expect;
5	5	const expectEqual = testing.expectEqual;
6	6
7	7	test "one param, explicit comptime" {
	8	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	9
8	10	var x: usize = 0;
9	11	x += checkSize(i32);
10	12	x += checkSize(bool);
...	...	@@ -19,6 +21,7 @@ fn checkSize(comptime T: type) usize {
19	21	test "simple generic fn" {
20	22	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
21	23	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	24	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
22	25
23	26	try expect(max(i32, 3, -1) == 3);
24	27	try expect(max(u8, 1, 100) == 100);
...	...	@@ -59,6 +62,7 @@ test "fn with comptime args" {
59	62	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
60	63	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
61	64	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	65	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
62	66
63	67	try expect(gimmeTheBigOne(1234, 5678) == 5678);
64	68	try expect(shouldCallSameInstance(34, 12) == 34);
...	...	@@ -69,6 +73,7 @@ test "anytype params" {
69	73	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
70	74	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
71	75	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	76	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
72	77
73	78	try expect(max_i32(12, 34) == 34);
74	79	try expect(max_f64(1.2, 3.4) == 3.4);
...	...	@@ -93,6 +98,7 @@ fn max_f64(a: f64, b: f64) f64 {
93	98	test "type constructed by comptime function call" {
94	99	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
95	100	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	101	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
96	102
97	103	var l: SimpleList(10) = undefined;
98	104	l.array[0] = 10;
...	...	@@ -116,6 +122,7 @@ test "function with return type type" {
116	122	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
117	123	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
118	124	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	125	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
119	126
120	127	var list: List(i32) = undefined;
121	128	var list2: List(i32) = undefined;
...	...	@@ -147,6 +154,8 @@ fn GenericDataThing(comptime count: isize) type {
147	154	}
148	155
149	156	test "use generic param in generic param" {
	157	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	158
150	159	try expect(aGenericFn(i32, 3, 4) == 7);
151	160	}
152	161	fn aGenericFn(comptime T: type, comptime a: T, b: T) T {
...	...	@@ -157,6 +166,7 @@ test "generic fn with implicit cast" {
157	166	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
158	167	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
159	168	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	169	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
160	170
161	171	try expect(getFirstByte(u8, &[_]u8{13}) == 13);
162	172	try expect(getFirstByte(u16, &[_]u16{
...	...	@@ -175,6 +185,7 @@ test "generic fn keeps non-generic parameter types" {
175	185	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
176	186	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
177	187	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	188	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
178	189
179	190	const A = 128;
180	191
...	...	@@ -209,6 +220,7 @@ fn foo2(arg: anytype) bool {
209	220
210	221	test "generic struct" {
211	222	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	223	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
212	224
213	225	var a1 = GenNode(i32){
214	226	.value = 13,
...	...	@@ -249,6 +261,7 @@ test "generic function instantiation turns into comptime call" {
249	261	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
250	262	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
251	263	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	264	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
252	265
253	266	const S = struct {
254	267	fn doTheTest() !void {
...	...	@@ -298,6 +311,7 @@ test "generic function with void and comptime parameter" {
298	311	test "anonymous struct return type referencing comptime parameter" {
299	312	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
300	313	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	314	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
301	315
302	316	const S = struct {
303	317	pub fn extraData(comptime T: type, index: usize) struct { data: T, end: usize } {
...	...	@@ -316,6 +330,7 @@ test "generic function instantiation non-duplicates" {
316	330	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
317	331	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
318	332	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	333	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
319	334	if (builtin.os.tag == .wasi) return error.SkipZigTest;
320	335
321	336	const S = struct {
...	...	@@ -351,6 +366,8 @@ test "generic instantiation of tagged union with only one field" {
351	366	}
352	367
353	368	test "nested generic function" {
	369	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	370
354	371	const S = struct {
355	372	fn foo(comptime T: type, callback: *const fn (user_data: T) anyerror!void, data: T) anyerror!void {
356	373	try callback(data);
...	...	@@ -366,6 +383,8 @@ test "nested generic function" {
366	383	}
367	384
368	385	test "extern function used as generic parameter" {
	386	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	387
369	388	const S = struct {
370	389	extern fn usedAsGenericParameterFoo() void;
371	390	extern fn usedAsGenericParameterBar() void;
...	...	@@ -393,6 +412,8 @@ test "generic struct as parameter type" {
393	412	}
394	413
395	414	test "slice as parameter type" {
	415	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	416
396	417	const S = struct {
397	418	fn internComptimeString(comptime str: []const u8) *const []const u8 {
398	419	return &struct {
...	...	@@ -407,6 +428,8 @@ test "slice as parameter type" {
407	428	}
408	429
409	430	test "null sentinel pointer passed as generic argument" {
	431	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	432
410	433	const S = struct {
411	434	fn doTheTest(a: anytype) !void {
412	435	try std.testing.expect(@ptrToInt(a) == 8);
...	...	@@ -417,6 +440,7 @@ test "null sentinel pointer passed as generic argument" {
417	440
418	441	test "generic function passed as comptime argument" {
419	442	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	443	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
420	444
421	445	const S = struct {
422	446	fn doMath(comptime f: fn (type, i32, i32) error{Overflow}!i32, a: i32, b: i32) !void {

test/behavior/if.zig+5

...	...	@@ -45,6 +45,7 @@ var global_with_err: anyerror!u32 = error.SomeError;
45	45
46	46	test "unwrap mutable global var" {
47	47	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	48	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
48	49
49	50	if (global_with_val) \|v\| {
50	51	try expect(v == 0);
...	...	@@ -70,6 +71,8 @@ test "labeled break inside comptime if inside runtime if" {
70	71	}
71	72
72	73	test "const result loc, runtime if cond, else unreachable" {
	74	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	75
73	76	const Num = enum { One, Two };
74	77
75	78	var t = true;
...	...	@@ -115,6 +118,7 @@ test "if peer expressions inferred optional type" {
115	118	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
116	119	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
117	120	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	121	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
118	122
119	123	var self: []const u8 = "abcdef";
120	124	var index: usize = 0;
...	...	@@ -132,6 +136,7 @@ test "if-else expression with runtime condition result location is inferred opti
132	136	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
133	137	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
134	138	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	139	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
135	140
136	141	const A = struct { b: u64, c: u64 };
137	142	var d: bool = true;

test/behavior/inline_switch.zig+5

...	...	@@ -47,6 +47,7 @@ test "inline switch unions" {
47	47	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
48	48	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
49	49	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	50	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
50	51
51	52	var x: U = .a;
52	53	switch (x) {
...	...	@@ -72,6 +73,7 @@ test "inline switch unions" {
72	73	test "inline else bool" {
73	74	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
74	75	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	76	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
75	77
76	78	var a = true;
77	79	switch (a) {
...	...	@@ -83,6 +85,7 @@ test "inline else bool" {
83	85	test "inline else error" {
84	86	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
85	87	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	88	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
86	89
87	90	const Err = error{ a, b, c };
88	91	var a = Err.a;
...	...	@@ -138,6 +141,8 @@ test "inline else int all values" {
138	141	}
139	142
140	143	test "inline switch capture is set when switch operand is comptime known" {
	144	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	145
141	146	const U2 = union(enum) {
142	147	a: u32,
143	148	};

test/behavior/int128.zig+5

...	...	@@ -8,6 +8,7 @@ test "uint128" {
8	8	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
9	9	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
10	10	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	11	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
11	12
12	13	var buff: u128 = maxInt(u128);
13	14	try expect(buff == maxInt(u128));
...	...	@@ -26,6 +27,7 @@ test "undefined 128 bit int" {
26	27	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
27	28	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
28	29	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	30	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
29	31
30	32	@setRuntimeSafety(true);
31	33
...	...	@@ -43,6 +45,7 @@ test "int128" {
43	45	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
44	46	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
45	47	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	48	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
46	49
47	50	var buff: i128 = -1;
48	51	try expect(buff < 0 and (buff + 1) == 0);
...	...	@@ -66,6 +69,7 @@ test "truncate int128" {
66	69	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
67	70	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
68	71	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	72	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
69	73
70	74	{
71	75	var buff: u128 = maxInt(u128);
...	...	@@ -87,6 +91,7 @@ test "shift int128" {
87	91	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
88	92	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
89	93	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	94	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
90	95
91	96	const types = .{ u128, i128 };
92	97	inline for (types) \|t\| {

test/behavior/int_comparison_elision.zig+2

...	...	@@ -4,6 +4,8 @@ const maxInt = std.math.maxInt;
4	4	const builtin = @import("builtin");
5	5
6	6	test "int comparison elision" {
	7	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	8
7	9	testIntEdges(u0);
8	10	testIntEdges(i0);
9	11	testIntEdges(u1);

test/behavior/inttoptr.zig+1

...	...	@@ -14,6 +14,7 @@ test "mutate through ptr initialized with constant intToPtr value" {
14	14	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
15	15	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
16	16	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	17	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
17	18
18	19	forceCompilerAnalyzeBranchHardCodedPtrDereference(false);
19	20	}

test/behavior/ir_block_deps.zig+1

...	...	@@ -21,6 +21,7 @@ test "ir block deps" {
21	21	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
22	22	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
23	23	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	24	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
24	25
25	26	try expect((foo(1) catch unreachable) == 0);
26	27	try expect((foo(2) catch unreachable) == 0);

test/behavior/lower_strlit_to_vector.zig+1

...	...	@@ -6,6 +6,7 @@ test "strlit to vector" {
6	6	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
7	7	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
8	8	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
	9	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
9	10
10	11	const strlit = "0123456789abcdef0123456789ABCDEF";
11	12	const vec_from_strlit: @Vector(32, u8) = strlit.*;

test/behavior/math.zig+42

...	...	@@ -11,6 +11,7 @@ const math = std.math;
11	11	test "assignment operators" {
12	12	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
13	13	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	14	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
14	15
15	16	var i: u32 = 0;
16	17	i += 5;
...	...	@@ -64,6 +65,7 @@ test "@clz" {
64	65	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
65	66	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
66	67	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	68	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
67	69
68	70	try testClz();
69	71	comptime try testClz();
...	...	@@ -82,6 +84,7 @@ test "@clz big ints" {
82	84	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
83	85	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
84	86	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	87	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
85	88
86	89	try testClzBigInts();
87	90	comptime try testClzBigInts();
...	...	@@ -102,6 +105,7 @@ test "@clz vectors" {
102	105	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
103	106	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
104	107	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	108	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
105	109
106	110	try testClzVectors();
107	111	comptime try testClzVectors();
...	...	@@ -142,6 +146,7 @@ test "@ctz" {
142	146	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
143	147	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
144	148	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	149	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
145	150
146	151	try testCtz();
147	152	comptime try testCtz();
...	...	@@ -164,6 +169,7 @@ test "@ctz vectors" {
164	169	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
165	170	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
166	171	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	172	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
167	173
168	174	if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .aarch64) {
169	175	// This regressed with LLVM 14:
...	...	@@ -204,6 +210,7 @@ test "float equality" {
204	210	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
205	211	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
206	212	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	213	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
207	214
208	215	const x: f64 = 0.012;
209	216	const y: f64 = x + 1.0;
...	...	@@ -381,6 +388,7 @@ test "binary not 128-bit" {
381	388	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
382	389	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
383	390	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	391	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
384	392
385	393	try expect(comptime x: {
386	394	break :x ~@as(u128, 0x55555555_55555555_55555555_55555555) == 0xaaaaaaaa_aaaaaaaa_aaaaaaaa_aaaaaaaa;
...	...	@@ -404,6 +412,7 @@ test "division" {
404	412	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
405	413	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
406	414	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	415	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
407	416
408	417	try testDivision();
409	418	comptime try testDivision();
...	...	@@ -484,6 +493,7 @@ test "division half-precision floats" {
484	493	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
485	494	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
486	495	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	496	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
487	497
488	498	try testDivisionFP16();
489	499	comptime try testDivisionFP16();
...	...	@@ -564,6 +574,7 @@ fn testUnsignedNegationWrappingEval(x: u16) !void {
564	574	test "negation wrapping" {
565	575	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
566	576	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	577	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
567	578
568	579	try expectEqual(@as(u1, 1), negateWrap(u1, 1));
569	580	}
...	...	@@ -604,6 +615,8 @@ test "bit shift a u1" {
604	615	}
605	616
606	617	test "truncating shift right" {
	618	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	619
607	620	try testShrTrunc(maxInt(u16));
608	621	comptime try testShrTrunc(maxInt(u16));
609	622	}
...	...	@@ -618,6 +631,7 @@ test "f128" {
618	631	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
619	632	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
620	633	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	634	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
621	635
622	636	try test_f128();
623	637	comptime try test_f128();
...	...	@@ -647,6 +661,7 @@ test "128-bit multiplication" {
647	661	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
648	662	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
649	663	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	664	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
650	665
651	666	{
652	667	var a: i128 = 3;
...	...	@@ -672,6 +687,7 @@ test "@addWithOverflow" {
672	687	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
673	688	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
674	689	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	690	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
675	691
676	692	{
677	693	var a: u8 = 250;
...	...	@@ -717,6 +733,7 @@ test "@addWithOverflow" {
717	733	test "small int addition" {
718	734	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
719	735	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	736	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
720	737
721	738	var x: u2 = 0;
722	739	try expect(x == 0);
...	...	@@ -738,6 +755,7 @@ test "small int addition" {
738	755	test "basic @mulWithOverflow" {
739	756	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
740	757	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	758	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
741	759
742	760	{
743	761	var a: u8 = 86;
...	...	@@ -768,6 +786,7 @@ test "extensive @mulWithOverflow" {
768	786	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
769	787	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
770	788	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
	789	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
771	790
772	791	{
773	792	var a: u5 = 3;
...	...	@@ -932,6 +951,7 @@ test "@mulWithOverflow bitsize > 32" {
932	951	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
933	952	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
934	953	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	954	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
935	955
936	956	{
937	957	var a: u62 = 3;
...	...	@@ -990,6 +1010,7 @@ test "@subWithOverflow" {
990	1010	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
991	1011	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
992	1012	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	1013	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
993	1014
994	1015	{
995	1016	var a: u8 = 1;
...	...	@@ -1037,6 +1058,8 @@ test "@shlWithOverflow" {
1037	1058	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1038	1059	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1039	1060	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
	1061	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1062
1040	1063	{
1041	1064	var a: u4 = 2;
1042	1065	var b: u2 = 1;
...	...	@@ -1114,6 +1137,8 @@ test "overflow arithmetic with u0 values" {
1114	1137	}
1115	1138
1116	1139	test "allow signed integer division/remainder when values are comptime-known and positive or exact" {
	1140	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1141
1117	1142	try expect(5 / 3 == 1);
1118	1143	try expect(-5 / -3 == 1);
1119	1144	try expect(-6 / 3 == -2);
...	...	@@ -1132,6 +1157,7 @@ test "quad hex float literal parsing accurate" {
1132	1157	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1133	1158	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1134	1159	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	1160	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1135	1161
1136	1162	const a: f128 = 0x1.1111222233334444555566667777p+0;
1137	1163
...	...	@@ -1232,6 +1258,8 @@ fn testShlTrunc(x: u16) !void {
1232	1258	}
1233	1259
1234	1260	test "exact shift left" {
	1261	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1262
1235	1263	try testShlExact(0b00110101);
1236	1264	comptime try testShlExact(0b00110101);
1237	1265	}
...	...	@@ -1241,6 +1269,8 @@ fn testShlExact(x: u8) !void {
1241	1269	}
1242	1270
1243	1271	test "exact shift right" {
	1272	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1273
1244	1274	try testShrExact(0b10110100);
1245	1275	comptime try testShrExact(0b10110100);
1246	1276	}
...	...	@@ -1280,6 +1310,7 @@ test "remainder division" {
1280	1310	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1281	1311	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1282	1312	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	1313	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1283	1314	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
1284	1315
1285	1316	if (builtin.zig_backend == .stage2_llvm and builtin.os.tag == .windows) {
...	...	@@ -1316,6 +1347,7 @@ test "float remainder division using @rem" {
1316	1347	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1317	1348	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1318	1349	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	1350	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1319	1351	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
1320	1352
1321	1353	comptime try frem(f16);
...	...	@@ -1359,6 +1391,7 @@ test "float modulo division using @mod" {
1359	1391	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1360	1392	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
1361	1393	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	1394	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1362	1395
1363	1396	comptime try fmod(f16);
1364	1397	comptime try fmod(f32);
...	...	@@ -1401,6 +1434,7 @@ test "@round" {
1401	1434	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1402	1435	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
1403	1436	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	1437	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1404	1438
1405	1439	try testRound(f64, 12.0);
1406	1440	comptime try testRound(f64, 12.0);
...	...	@@ -1421,6 +1455,7 @@ test "@round f80" {
1421	1455	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1422	1456	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
1423	1457	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	1458	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1424	1459
1425	1460	try testRound(f80, 12.0);
1426	1461	comptime try testRound(f80, 12.0);
...	...	@@ -1432,6 +1467,7 @@ test "@round f128" {
1432	1467	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1433	1468	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
1434	1469	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	1470	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1435	1471
1436	1472	try testRound(f128, 12.0);
1437	1473	comptime try testRound(f128, 12.0);
...	...	@@ -1449,6 +1485,7 @@ test "vector integer addition" {
1449	1485	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1450	1486	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
1451	1487	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	1488	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1452	1489
1453	1490	const S = struct {
1454	1491	fn doTheTest() !void {
...	...	@@ -1470,6 +1507,7 @@ test "NaN comparison" {
1470	1507	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1471	1508	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
1472	1509	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	1510	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1473	1511
1474	1512	try testNanEqNan(f16);
1475	1513	try testNanEqNan(f32);
...	...	@@ -1487,6 +1525,7 @@ test "NaN comparison f80" {
1487	1525	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1488	1526	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
1489	1527	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	1528	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1490	1529
1491	1530	try testNanEqNan(f80);
1492	1531	comptime try testNanEqNan(f80);
...	...	@@ -1509,6 +1548,7 @@ test "vector comparison" {
1509	1548	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1510	1549	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
1511	1550	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	1551	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1512	1552
1513	1553	const S = struct {
1514	1554	fn doTheTest() !void {
...	...	@@ -1538,6 +1578,7 @@ test "signed zeros are represented properly" {
1538	1578	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1539	1579	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1540	1580	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	1581	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1541	1582
1542	1583	const S = struct {
1543	1584	fn doTheTest() !void {
...	...	@@ -1573,6 +1614,7 @@ test "absFloat" {
1573	1614	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1574	1615	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
1575	1616	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	1617	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1576	1618
1577	1619	try testAbsFloat();
1578	1620	comptime try testAbsFloat();

test/behavior/maximum_minimum.zig+11

...	...	@@ -8,6 +8,7 @@ test "@max" {
8	8	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
9	9	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
10	10	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	11	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
11	12
12	13	const S = struct {
13	14	fn doTheTest() !void {
...	...	@@ -27,6 +28,7 @@ test "@max on vectors" {
27	28	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
28	29	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
29	30	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	31	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
30	32
31	33	const S = struct {
32	34	fn doTheTest() !void {
...	...	@@ -54,6 +56,7 @@ test "@min" {
54	56	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
55	57	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
56	58	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	59	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
57	60
58	61	const S = struct {
59	62	fn doTheTest() !void {
...	...	@@ -73,6 +76,7 @@ test "@min for vectors" {
73	76	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
74	77	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
75	78	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	79	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
76	80
77	81	const S = struct {
78	82	fn doTheTest() !void {
...	...	@@ -122,6 +126,8 @@ test "@min/max for floats" {
122	126	}
123	127
124	128	test "@min/@max on lazy values" {
	129	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	130
125	131	const A = extern struct { u8_4: [4]u8 };
126	132	const B = extern struct { u8_16: [16]u8 };
127	133	const size = @max(@sizeOf(A), @sizeOf(B));
...	...	@@ -129,6 +135,8 @@ test "@min/@max on lazy values" {
129	135	}
130	136
131	137	test "@min/@max more than two arguments" {
	138	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	139
132	140	const x: u32 = 30;
133	141	const y: u32 = 10;
134	142	const z: u32 = 20;
...	...	@@ -142,6 +150,7 @@ test "@min/@max more than two vector arguments" {
142	150	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
143	151	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
144	152	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	153	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
145	154
146	155	const x: @Vector(2, u32) = .{ 3, 2 };
147	156	const y: @Vector(2, u32) = .{ 4, 1 };
...	...	@@ -154,6 +163,7 @@ test "@min/@max notices bounds" {
154	163	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
155	164	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
156	165	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	166	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
157	167
158	168	var x: u16 = 20;
159	169	const y = 30;
...	...	@@ -172,6 +182,7 @@ test "@min/@max notices vector bounds" {
172	182	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
173	183	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
174	184	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	185	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
175	186
176	187	var x: @Vector(2, u16) = .{ 140, 40 };
177	188	const y: @Vector(2, u64) = .{ 5, 100 };

test/behavior/member_func.zig+2

...	...	@@ -30,6 +30,7 @@ test "standard field calls" {
30	30	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
31	31	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
32	32	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	33	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
33	34
34	35	try expect(HasFuncs.one(0) == 1);
35	36	try expect(HasFuncs.two(0) == 2);
...	...	@@ -73,6 +74,7 @@ test "@field field calls" {
73	74	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
74	75	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
75	76	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	77	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
76	78
77	79	try expect(@field(HasFuncs, "one")(0) == 1);
78	80	try expect(@field(HasFuncs, "two")(0) == 2);

test/behavior/memcpy.zig+2

...	...	@@ -6,6 +6,7 @@ test "memcpy and memset intrinsics" {
6	6	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
7	7	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
8	8	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	9	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
9	10
10	11	try testMemcpyMemset();
11	12	try comptime testMemcpyMemset();
...	...	@@ -27,6 +28,7 @@ test "@memcpy with both operands single-ptr-to-array, one is null-terminated" {
27	28	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
28	29	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
29	30	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
	31	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
30	32
31	33	try testMemcpyBothSinglePtrArrayOneIsNullTerminated();
32	34	try comptime testMemcpyBothSinglePtrArrayOneIsNullTerminated();

test/behavior/memset.zig+7

...	...	@@ -6,6 +6,7 @@ test "@memset on array pointers" {
6	6	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
7	7	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
8	8	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
	9	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
9	10	if (builtin.zig_backend == .stage2_wasm) {
10	11	// TODO: implement memset when element ABI size > 1
11	12	return error.SkipZigTest;
...	...	@@ -38,6 +39,7 @@ test "@memset on slices" {
38	39	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
39	40	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
40	41	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
	42	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
41	43	if (builtin.zig_backend == .stage2_wasm) {
42	44	// TODO: implement memset when element ABI size > 1
43	45	// TODO: implement memset on slices
...	...	@@ -75,6 +77,7 @@ test "memset with bool element" {
75	77	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
76	78	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
77	79	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
	80	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
78	81	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
79	82
80	83	var buf: [5]bool = undefined;
...	...	@@ -87,6 +90,7 @@ test "memset with 1-byte struct element" {
87	90	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
88	91	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
89	92	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
	93	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
90	94	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
91	95
92	96	const S = struct { x: bool };
...	...	@@ -100,6 +104,7 @@ test "memset with 1-byte array element" {
100	104	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
101	105	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
102	106	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
	107	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
103	108	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
104	109
105	110	const A = [1]bool;
...	...	@@ -113,6 +118,7 @@ test "memset with large array element, runtime known" {
113	118	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
114	119	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
115	120	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
	121	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
116	122	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
117	123	if (builtin.zig_backend == .stage2_x86_64 and builtin.os.tag == .windows) return error.SkipZigTest;
118	124
...	...	@@ -131,6 +137,7 @@ test "memset with large array element, comptime known" {
131	137	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
132	138	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
133	139	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
	140	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
134	141	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
135	142	if (builtin.zig_backend == .stage2_x86_64 and builtin.os.tag == .windows) return error.SkipZigTest;
136	143

test/behavior/merge_error_sets.zig+1

...	...	@@ -13,6 +13,7 @@ fn foo() C!void {
13	13
14	14	test "merge error sets" {
15	15	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	16	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
16	17
17	18	if (foo()) {
18	19	@panic("unexpected");

test/behavior/muladd.zig+9

...	...	@@ -10,6 +10,7 @@ test "@mulAdd" {
10	10	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
11	11	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
12	12	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	13	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
13	14
14	15	comptime try testMulAdd();
15	16	try testMulAdd();
...	...	@@ -35,6 +36,7 @@ test "@mulAdd f16" {
35	36	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
36	37	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
37	38	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	39	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
38	40
39	41	comptime try testMulAdd16();
40	42	try testMulAdd16();
...	...	@@ -53,6 +55,7 @@ test "@mulAdd f80" {
53	55	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
54	56	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
55	57	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	58	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
56	59
57	60	comptime try testMulAdd80();
58	61	try testMulAdd80();
...	...	@@ -71,6 +74,7 @@ test "@mulAdd f128" {
71	74	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
72	75	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
73	76	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	77	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
74	78
75	79	comptime try testMulAdd128();
76	80	try testMulAdd128();
...	...	@@ -101,6 +105,7 @@ test "vector f16" {
101	105	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
102	106	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
103	107	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	108	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
104	109
105	110	comptime try vector16();
106	111	try vector16();
...	...	@@ -124,6 +129,7 @@ test "vector f32" {
124	129	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
125	130	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
126	131	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	132	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
127	133
128	134	comptime try vector32();
129	135	try vector32();
...	...	@@ -147,6 +153,7 @@ test "vector f64" {
147	153	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
148	154	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
149	155	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	156	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
150	157
151	158	comptime try vector64();
152	159	try vector64();
...	...	@@ -169,6 +176,7 @@ test "vector f80" {
169	176	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
170	177	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
171	178	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	179	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
172	180
173	181	comptime try vector80();
174	182	try vector80();
...	...	@@ -192,6 +200,7 @@ test "vector f128" {
192	200	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
193	201	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
194	202	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	203	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
195	204
196	205	comptime try vector128();
197	206	try vector128();

test/behavior/null.zig+7

...	...	@@ -32,6 +32,7 @@ test "test maybe object and get a pointer to the inner value" {
32	32	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
33	33	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
34	34	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	35	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
35	36
36	37	var maybe_bool: ?bool = true;
37	38
...	...	@@ -52,6 +53,7 @@ test "maybe return" {
52	53	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
53	54	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
54	55	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	56	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
55	57
56	58	try maybeReturnImpl();
57	59	comptime try maybeReturnImpl();
...	...	@@ -82,6 +84,7 @@ fn testTestNullRuntime(x: ?i32) !void {
82	84	test "optional void" {
83	85	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
84	86	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	87	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
85	88
86	89	try optionalVoidImpl();
87	90	comptime try optionalVoidImpl();
...	...	@@ -105,6 +108,7 @@ const Empty = struct {};
105	108	test "optional struct{}" {
106	109	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
107	110	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	111	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
108	112
109	113	_ = try optionalEmptyStructImpl();
110	114	_ = comptime try optionalEmptyStructImpl();
...	...	@@ -130,6 +134,7 @@ test "null with default unwrap" {
130	134
131	135	test "optional pointer to 0 bit type null value at runtime" {
132	136	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	137	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
133	138
134	139	const EmptyStruct = struct {};
135	140	var x: ?*EmptyStruct = null;
...	...	@@ -140,6 +145,7 @@ test "if var maybe pointer" {
140	145	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
141	146	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
142	147	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	148	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
143	149
144	150	try expect(shouldBeAPlus1(Particle{
145	151	.a = 14,
...	...	@@ -183,6 +189,7 @@ test "unwrap optional which is field of global var" {
183	189	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
184	190	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
185	191	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	192	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
186	193
187	194	struct_with_optional.field = null;
188	195	if (struct_with_optional.field) \|payload\| {

test/behavior/optional.zig+25

...	...	@@ -8,6 +8,7 @@ const expectEqualStrings = std.testing.expectEqualStrings;
8	8	test "passing an optional integer as a parameter" {
9	9	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
10	10	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	11	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
11	12
12	13	const S = struct {
13	14	fn entry() bool {
...	...	@@ -27,6 +28,7 @@ pub const EmptyStruct = struct {};
27	28
28	29	test "optional pointer to size zero struct" {
29	30	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	31	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
30	32
31	33	var e = EmptyStruct{};
32	34	var o: ?*EmptyStruct = &e;
...	...	@@ -34,6 +36,8 @@ test "optional pointer to size zero struct" {
34	36	}
35	37
36	38	test "equality compare optional pointers" {
	39	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	40
37	41	try testNullPtrsEql();
38	42	comptime try testNullPtrsEql();
39	43	}
...	...	@@ -58,6 +62,7 @@ test "optional with void type" {
58	62	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
59	63	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
60	64	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	65	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
61	66
62	67	const Foo = struct {
63	68	x: ?void,
...	...	@@ -71,6 +76,7 @@ test "address of unwrap optional" {
71	76	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
72	77	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
73	78	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	79	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
74	80
75	81	const S = struct {
76	82	const Foo = struct {
...	...	@@ -92,6 +98,7 @@ test "nested optional field in struct" {
92	98	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
93	99	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
94	100	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	101	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
95	102
96	103	const S2 = struct {
97	104	y: u8,
...	...	@@ -109,6 +116,7 @@ test "equality compare optional with non-optional" {
109	116	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
110	117	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
111	118	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	119	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
112	120
113	121	try test_cmp_optional_non_optional();
114	122	comptime try test_cmp_optional_non_optional();
...	...	@@ -146,6 +154,7 @@ fn test_cmp_optional_non_optional() !void {
146	154	test "unwrap function call with optional pointer return value" {
147	155	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
148	156	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	157	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
149	158
150	159	const S = struct {
151	160	fn entry() !void {
...	...	@@ -167,6 +176,7 @@ test "unwrap function call with optional pointer return value" {
167	176	test "nested orelse" {
168	177	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
169	178	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	179	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
170	180
171	181	const S = struct {
172	182	fn entry() !void {
...	...	@@ -193,6 +203,7 @@ test "nested orelse" {
193	203	test "self-referential struct through a slice of optional" {
194	204	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
195	205	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	206	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
196	207
197	208	const S = struct {
198	209	const Node = struct {
...	...	@@ -228,6 +239,7 @@ test "coerce an anon struct literal to optional struct" {
228	239	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
229	240	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
230	241	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	242	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
231	243
232	244	const S = struct {
233	245	const Struct = struct {
...	...	@@ -247,6 +259,7 @@ test "0-bit child type coerced to optional return ptr result location" {
247	259	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
248	260	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
249	261	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	262	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
250	263
251	264	const S = struct {
252	265	fn doTheTest() !void {
...	...	@@ -271,6 +284,7 @@ test "0-bit child type coerced to optional return ptr result location" {
271	284
272	285	test "0-bit child type coerced to optional" {
273	286	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	287	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
274	288
275	289	const S = struct {
276	290	fn doTheTest() !void {
...	...	@@ -298,6 +312,7 @@ test "array of optional unaligned types" {
298	312	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
299	313	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
300	314	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	315	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
301	316
302	317	const Enum = enum { one, two, three };
303	318
...	...	@@ -334,6 +349,7 @@ test "optional pointer to zero bit optional payload" {
334	349	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
335	350	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
336	351	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	352	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
337	353
338	354	const B = struct {
339	355	fn foo(_: *@This()) void {}
...	...	@@ -354,6 +370,7 @@ test "optional pointer to zero bit error union payload" {
354	370	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
355	371	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
356	372	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	373	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
357	374
358	375	const B = struct {
359	376	fn foo(_: *@This()) void {}
...	...	@@ -387,6 +404,7 @@ const NoReturn = struct {
387	404
388	405	test "optional of noreturn used with if" {
389	406	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	407	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
390	408
391	409	NoReturn.a = 64;
392	410	if (NoReturn.loop()) \|_\| {
...	...	@@ -398,6 +416,7 @@ test "optional of noreturn used with if" {
398	416
399	417	test "optional of noreturn used with orelse" {
400	418	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	419	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
401	420
402	421	NoReturn.a = 64;
403	422	const val = NoReturn.testOrelse();
...	...	@@ -405,6 +424,8 @@ test "optional of noreturn used with orelse" {
405	424	}
406	425
407	426	test "orelse on C pointer" {
	427	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	428
408	429	// TODO https://github.com/ziglang/zig/issues/6597
409	430	const foo: [*c]const u8 = "hey";
410	431	const d = foo orelse @compileError("bad");
...	...	@@ -415,6 +436,7 @@ test "alignment of wrapping an optional payload" {
415	436	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
416	437	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
417	438	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	439	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
418	440
419	441	const S = struct {
420	442	const I = extern struct { x: i128 };
...	...	@@ -431,6 +453,7 @@ test "Optional slice size is optimized" {
431	453	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
432	454	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
433	455	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	456	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
434	457
435	458	try expect(@sizeOf(?[]u8) == @sizeOf([]u8));
436	459	var a: ?[]const u8 = null;
...	...	@@ -442,6 +465,7 @@ test "Optional slice size is optimized" {
442	465	test "peer type resolution in nested if expressions" {
443	466	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
444	467	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
	468	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
445	469
446	470	const Thing = struct { n: i32 };
447	471	var a = false;
...	...	@@ -467,6 +491,7 @@ test "peer type resolution in nested if expressions" {
467	491	test "cast slice to const slice nested in error union and optional" {
468	492	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
469	493	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
	494	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
470	495
471	496	const S = struct {
472	497	fn inner() !?[]u8 {

test/behavior/packed-struct.zig+17

...	...	@@ -7,6 +7,7 @@ const native_endian = builtin.cpu.arch.endian();
7	7
8	8	test "flags in packed structs" {
9	9	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	10	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
10	11
11	12	const Flags1 = packed struct {
12	13	// first 8 bits
...	...	@@ -93,6 +94,7 @@ test "flags in packed structs" {
93	94
94	95	test "consistent size of packed structs" {
95	96	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	97	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
96	98
97	99	const TxData1 = packed struct { data: u8, _23: u23, full: bool = false };
98	100	const TxData2 = packed struct { data: u9, _22: u22, full: bool = false };
...	...	@@ -123,6 +125,7 @@ test "correct sizeOf and offsets in packed structs" {
123	125	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
124	126	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
125	127	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	128	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
126	129
127	130	const PStruct = packed struct {
128	131	bool_a: bool,
...	...	@@ -190,6 +193,7 @@ test "nested packed structs" {
190	193	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
191	194	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
192	195	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	196	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
193	197
194	198	const S1 = packed struct { a: u8, b: u8, c: u8 };
195	199
...	...	@@ -235,6 +239,7 @@ test "regular in irregular packed struct" {
235	239	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
236	240	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
237	241	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	242	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
238	243
239	244	const Irregular = packed struct {
240	245	bar: Regular = Regular{},
...	...	@@ -254,6 +259,7 @@ test "byte-aligned field pointer offsets" {
254	259	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
255	260	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
256	261	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	262	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
257	263
258	264	const S = struct {
259	265	const A = packed struct {
...	...	@@ -354,6 +360,7 @@ test "load pointer from packed struct" {
354	360	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
355	361	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
356	362	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	363	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
357	364
358	365	const A = struct {
359	366	index: u16,
...	...	@@ -375,6 +382,7 @@ test "@ptrToInt on a packed struct field" {
375	382	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
376	383	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
377	384	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	385	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
378	386
379	387	const S = struct {
380	388	const P = packed struct {
...	...	@@ -395,6 +403,7 @@ test "optional pointer in packed struct" {
395	403	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
396	404	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
397	405	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	406	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
398	407
399	408	const T = packed struct { ptr: ?*const u8 };
400	409	var n: u8 = 0;
...	...	@@ -409,6 +418,7 @@ test "nested packed struct field access test" {
409	418	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
410	419	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
411	420	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	421	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
412	422	//
413	423	const Vec2 = packed struct {
414	424	x: f32,
...	...	@@ -525,6 +535,7 @@ test "runtime init of unnamed packed struct type" {
525	535	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
526	536	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
527	537	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	538	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
528	539
529	540	var z: u8 = 123;
530	541	try (packed struct {
...	...	@@ -539,6 +550,7 @@ test "packed struct passed to callconv(.C) function" {
539	550	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
540	551	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
541	552	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	553	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
542	554
543	555	const S = struct {
544	556	const Packed = packed struct {
...	...	@@ -564,6 +576,8 @@ test "overaligned pointer to packed struct" {
564	576	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
565	577	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
566	578	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	579	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	580
567	581	const S = packed struct { a: u32, b: u32 };
568	582	var foo: S align(4) = .{ .a = 123, .b = 456 };
569	583	const ptr: *align(4) S = &foo;
...	...	@@ -584,6 +598,7 @@ test "packed struct initialized in bitcast" {
584	598	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
585	599	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
586	600	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	601	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
587	602
588	603	const T = packed struct { val: u8 };
589	604	var val: u8 = 123;
...	...	@@ -597,6 +612,7 @@ test "pointer to container level packed struct field" {
597	612	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
598	613	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
599	614	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	615	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
600	616
601	617	const S = packed struct(u32) {
602	618	test_bit: bool,
...	...	@@ -621,6 +637,7 @@ test "store undefined to packed result location" {
621	637	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
622	638	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
623	639	if (builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
	640	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
624	641	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
625	642
626	643	var x: u4 = 0;

test/behavior/packed_struct_explicit_backing_int.zig+1

...	...	@@ -9,6 +9,7 @@ test "packed struct explicit backing integer" {
9	9	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
10	10	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
11	11	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	12	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
12	13
13	14	const S1 = packed struct { a: u8, b: u8, c: u8 };
14	15

test/behavior/pointers.zig+23

...	...	@@ -5,6 +5,7 @@ const expect = testing.expect;
5	5	const expectError = testing.expectError;
6	6
7	7	test "dereference pointer" {
	8	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
8	9	comptime try testDerefPtr();
9	10	try testDerefPtr();
10	11	}
...	...	@@ -19,6 +20,7 @@ fn testDerefPtr() !void {
19	20	test "pointer arithmetic" {
20	21	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
21	22	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	23	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
22	24
23	25	var ptr: [*]const u8 = "abcd";
24	26
...	...	@@ -51,6 +53,7 @@ fn PtrOf(comptime T: type) type {
51	53
52	54	test "implicit cast single item pointer to C pointer and back" {
53	55	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	56	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
54	57
55	58	var y: u8 = 11;
56	59	var x: [*c]u8 = &y;
...	...	@@ -67,6 +70,7 @@ test "initialize const optional C pointer to null" {
67	70
68	71	test "assigning integer to C pointer" {
69	72	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	73	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
70	74
71	75	var x: i32 = 0;
72	76	var y: i32 = 1;
...	...	@@ -83,6 +87,7 @@ test "assigning integer to C pointer" {
83	87
84	88	test "C pointer comparison and arithmetic" {
85	89	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	90	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
86	91
87	92	const S = struct {
88	93	fn doTheTest() !void {
...	...	@@ -125,6 +130,7 @@ fn testDerefPtrOneVal() !void {
125	130	}
126	131
127	132	test "peer type resolution with C pointers" {
	133	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
128	134	var ptr_one: *u8 = undefined;
129	135	var ptr_many: [*]u8 = undefined;
130	136	var ptr_c: [*c]u8 = undefined;
...	...	@@ -140,6 +146,7 @@ test "peer type resolution with C pointers" {
140	146	}
141	147
142	148	test "peer type resolution with C pointer and const pointer" {
	149	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
143	150	var ptr_c: [*c]u8 = undefined;
144	151	const ptr_const: u8 = undefined;
145	152	try expect(@TypeOf(ptr_c, &ptr_const) == [*c]const u8);
...	...	@@ -149,6 +156,7 @@ test "implicit casting between C pointer and optional non-C pointer" {
149	156	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
150	157	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
151	158	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	159	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
152	160
153	161	var slice: []const u8 = "aoeu";
154	162	const opt_many_ptr: ?[*]const u8 = slice.ptr;
...	...	@@ -163,6 +171,7 @@ test "implicit cast error unions with non-optional to optional pointer" {
163	171	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
164	172	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
165	173	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	174	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
166	175
167	176	const S = struct {
168	177	fn doTheTest() !void {
...	...	@@ -191,6 +200,7 @@ test "allowzero pointer and slice" {
191	200	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
192	201	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
193	202	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	203	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
194	204
195	205	var ptr = @intToPtr([*]allowzero i32, 0);
196	206	var opt_ptr: ?[*]allowzero i32 = ptr;
...	...	@@ -209,6 +219,7 @@ test "assign null directly to C pointer and test null equality" {
209	219	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
210	220	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
211	221	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	222	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
212	223
213	224	var x: [*c]i32 = null;
214	225	try expect(x == null);
...	...	@@ -275,6 +286,7 @@ test "array initialization types" {
275	286	test "null terminated pointer" {
276	287	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
277	288	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	289	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
278	290
279	291	const S = struct {
280	292	fn doTheTest() !void {
...	...	@@ -292,6 +304,7 @@ test "null terminated pointer" {
292	304	test "allow any sentinel" {
293	305	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
294	306	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	307	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
295	308
296	309	const S = struct {
297	310	fn doTheTest() !void {
...	...	@@ -307,6 +320,7 @@ test "allow any sentinel" {
307	320	test "pointer sentinel with enums" {
308	321	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
309	322	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	323	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
310	324
311	325	const S = struct {
312	326	const Number = enum {
...	...	@@ -328,6 +342,7 @@ test "pointer sentinel with optional element" {
328	342	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
329	343	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
330	344	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	345	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
331	346
332	347	const S = struct {
333	348	fn doTheTest() !void {
...	...	@@ -344,6 +359,7 @@ test "pointer sentinel with +inf" {
344	359	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
345	360	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
346	361	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	362	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
347	363
348	364	const S = struct {
349	365	fn doTheTest() !void {
...	...	@@ -364,6 +380,7 @@ test "pointer to array at fixed address" {
364	380	}
365	381
366	382	test "pointer arithmetic affects the alignment" {
	383	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
367	384	{
368	385	var ptr: [*]align(8) u32 = undefined;
369	386	var x: usize = 1;
...	...	@@ -410,6 +427,7 @@ test "indexing array with sentinel returns correct type" {
410	427	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
411	428	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
412	429	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	430	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
413	431
414	432	var s: [:0]const u8 = "abc";
415	433	try testing.expectEqualSlices(u8, "*const u8", @typeName(@TypeOf(&s[0])));
...	...	@@ -418,6 +436,7 @@ test "indexing array with sentinel returns correct type" {
418	436	test "element pointer to slice" {
419	437	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
420	438	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	439	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
421	440
422	441	const S = struct {
423	442	fn doTheTest() !void {
...	...	@@ -440,6 +459,7 @@ test "element pointer to slice" {
440	459	test "element pointer arithmetic to slice" {
441	460	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
442	461	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	462	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
443	463
444	464	const S = struct {
445	465	fn doTheTest() !void {
...	...	@@ -464,6 +484,7 @@ test "element pointer arithmetic to slice" {
464	484
465	485	test "array slicing to slice" {
466	486	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	487	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
467	488
468	489	const S = struct {
469	490	fn doTheTest() !void {
...	...	@@ -494,6 +515,7 @@ test "ptrCast comptime known slice to C pointer" {
494	515	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
495	516	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
496	517	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	518	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
497	519
498	520	const s: [:0]const u8 = "foo";
499	521	var p = @ptrCast([*c]const u8, s);
...	...	@@ -504,6 +526,7 @@ test "ptrToInt on a generic function" {
504	526	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
505	527	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
506	528	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	529	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
507	530
508	531	const S = struct {
509	532	fn generic(i: anytype) @TypeOf(i) {

test/behavior/popcount.zig+3

...	...	@@ -7,6 +7,7 @@ test "@popCount integers" {
7	7	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
8	8	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
9	9	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	10	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
10	11
11	12	comptime try testPopCountIntegers();
12	13	try testPopCountIntegers();
...	...	@@ -17,6 +18,7 @@ test "@popCount 128bit integer" {
17	18	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
18	19	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
19	20	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	21	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
20	22
21	23	comptime {
22	24	try expect(@popCount(@as(u128, 0b11111111000110001100010000100001000011000011100101010001)) == 24);
...	...	@@ -71,6 +73,7 @@ test "@popCount vectors" {
71	73	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
72	74	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
73	75	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	76	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
74	77
75	78	comptime try testPopCountVectors();
76	79	try testPopCountVectors();

test/behavior/prefetch.zig+3

...	...	@@ -1,6 +1,9 @@
	1	const builtin = @import("builtin");
1	2	const std = @import("std");
2	3
3	4	test "@prefetch()" {
	5	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	6
4	7	var a: u32 = 42;
5	8
6	9	@prefetch(&a, .{});

test/behavior/ptrcast.zig+6

...	...	@@ -23,6 +23,7 @@ test "reinterpret an array over multiple elements, with no well-defined layout"
23	23	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
24	24	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
25	25	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	26	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
26	27
27	28	try testReinterpretWithOffsetAndNoWellDefinedLayout();
28	29	comptime try testReinterpretWithOffsetAndNoWellDefinedLayout();
...	...	@@ -130,6 +131,7 @@ test "lower reinterpreted comptime field ptr (with under-aligned fields)" {
130	131	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
131	132	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
132	133	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	134	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
133	135
134	136	// Test lowering a field ptr
135	137	comptime var bytes align(2) = [_]u8{ 1, 2, 3, 4, 5, 6 };
...	...	@@ -153,6 +155,7 @@ test "lower reinterpreted comptime field ptr" {
153	155	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
154	156	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
155	157	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	158	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
156	159
157	160	// Test lowering a field ptr
158	161	comptime var bytes align(4) = [_]u8{ 1, 2, 3, 4, 5, 6, 7, 8 };
...	...	@@ -174,6 +177,7 @@ test "lower reinterpreted comptime field ptr" {
174	177	test "reinterpret struct field at comptime" {
175	178	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
176	179	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	180	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
177	181
178	182	const numNative = comptime Bytes.init(0x12345678);
179	183	if (native_endian != .Little) {
...	...	@@ -241,6 +245,7 @@ test "implicit optional pointer to optional anyopaque pointer" {
241	245	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
242	246	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
243	247	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	248	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
244	249
245	250	var buf: [4]u8 = "aoeu".*;
246	251	var x: ?[*]u8 = &buf;
...	...	@@ -253,6 +258,7 @@ test "@ptrCast slice to slice" {
253	258	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
254	259	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
255	260	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	261	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
256	262
257	263	const S = struct {
258	264	fn foo(slice: []u32) []i32 {

test/behavior/pub_enum.zig+3

...	...	@@ -1,7 +1,10 @@
	1	const builtin = @import("builtin");
1	2	const other = @import("pub_enum/other.zig");
2	3	const expect = @import("std").testing.expect;
3	4
4	5	test "pub enum" {
	6	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	7
5	8	try pubEnumTest(other.APubEnum.Two);
6	9	}
7	10	fn pubEnumTest(foo: other.APubEnum) !void {

test/behavior/ref_var_in_if_after_if_2nd_switch_prong.zig+1

...	...	@@ -8,6 +8,7 @@ test "reference a variable in an if after an if in the 2nd switch prong" {
8	8	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
9	9	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
10	10	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	11	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
11	12
12	13	try foo(true, Num.Two, false, "aoeu");
13	14	try expect(!ok);

test/behavior/reflection.zig+1

...	...	@@ -28,6 +28,7 @@ fn dummy(a: bool, b: i32, c: f32) i32 {
28	28	test "reflection: @field" {
29	29	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
30	30	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	31	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
31	32
32	33	var f = Foo{
33	34	.one = 42,

test/behavior/return_address.zig+2

...	...	@@ -10,6 +10,8 @@ test "return address" {
10	10	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
11	11	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
12	12	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	13	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	14
13	15	_ = retAddr();
14	16	// TODO: #14938
15	17	try testing.expectEqual(0, comptime retAddr());

test/behavior/saturating_arithmetic.zig+7

...	...	@@ -9,6 +9,7 @@ test "saturating add" {
9	9	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
10	10	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
11	11	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	12	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
12	13
13	14	const S = struct {
14	15	fn doTheTest() !void {
...	...	@@ -56,6 +57,7 @@ test "saturating add 128bit" {
56	57	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
57	58	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
58	59	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	60	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
59	61
60	62	const S = struct {
61	63	fn doTheTest() !void {
...	...	@@ -81,6 +83,7 @@ test "saturating subtraction" {
81	83	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
82	84	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
83	85	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	86	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
84	87
85	88	const S = struct {
86	89	fn doTheTest() !void {
...	...	@@ -127,6 +130,7 @@ test "saturating subtraction 128bit" {
127	130	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
128	131	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
129	132	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	133	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
130	134
131	135	const S = struct {
132	136	fn doTheTest() !void {
...	...	@@ -154,6 +158,7 @@ test "saturating multiplication" {
154	158	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
155	159	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
156	160	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	161	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
157	162
158	163	if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .wasm32) {
159	164	// https://github.com/ziglang/zig/issues/9660
...	...	@@ -198,6 +203,7 @@ test "saturating shift-left" {
198	203	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
199	204	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
200	205	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	206	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
201	207
202	208	const S = struct {
203	209	fn doTheTest() !void {
...	...	@@ -237,6 +243,7 @@ test "saturating shl uses the LHS type" {
237	243	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
238	244	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
239	245	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	246	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
240	247
241	248	const lhs_const: u8 = 1;
242	249	var lhs_var: u8 = 1;

test/behavior/select.zig+2

...	...	@@ -9,6 +9,7 @@ test "@select vectors" {
9	9	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
10	10	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
11	11	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	12	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
12	13
13	14	comptime try selectVectors();
14	15	try selectVectors();
...	...	@@ -37,6 +38,7 @@ test "@select arrays" {
37	38	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
38	39	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
39	40	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	41	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
40	42
41	43	comptime try selectArrays();
42	44	try selectArrays();

test/behavior/shuffle.zig+3

...	...	@@ -8,6 +8,7 @@ test "@shuffle int" {
8	8	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
9	9	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
10	10	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	11	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
11	12
12	13	const S = struct {
13	14	fn doTheTest() !void {
...	...	@@ -49,6 +50,7 @@ test "@shuffle bool 1" {
49	50	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
50	51	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
51	52	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	53	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
52	54
53	55	const S = struct {
54	56	fn doTheTest() !void {
...	...	@@ -69,6 +71,7 @@ test "@shuffle bool 2" {
69	71	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
70	72	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
71	73	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	74	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
72	75
73	76	if (builtin.zig_backend == .stage2_llvm) {
74	77	// https://github.com/ziglang/zig/issues/3246

test/behavior/sizeof_and_typeof.zig+8

...	...	@@ -18,6 +18,8 @@ test "@sizeOf on compile-time types" {
18	18	}
19	19
20	20	test "@TypeOf() with multiple arguments" {
	21	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	22
21	23	{
22	24	var var_1: u32 = undefined;
23	25	var var_2: u8 = undefined;
...	...	@@ -75,6 +77,7 @@ const P = packed struct {
75	77
76	78	test "@offsetOf" {
77	79	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	80	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
78	81
79	82	// Packed structs have fixed memory layout
80	83	try expect(@offsetOf(P, "a") == 0);
...	...	@@ -137,6 +140,8 @@ test "@sizeOf(T) == 0 doesn't force resolving struct size" {
137	140	}
138	141
139	142	test "@TypeOf() has no runtime side effects" {
	143	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	144
140	145	const S = struct {
141	146	fn foo(comptime T: type, ptr: *T) T {
142	147	ptr.* += 1;
...	...	@@ -151,6 +156,8 @@ test "@TypeOf() has no runtime side effects" {
151	156
152	157	test "branching logic inside @TypeOf" {
153	158	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
	159	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	160
154	161	const S = struct {
155	162	var data: i32 = 0;
156	163	fn foo() anyerror!i32 {
...	...	@@ -264,6 +271,7 @@ test "runtime instructions inside typeof in comptime only scope" {
264	271	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
265	272	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
266	273	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	274	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
267	275
268	276	{
269	277	var y: i8 = 2;

test/behavior/slice.zig+32-1

...	...	@@ -29,6 +29,7 @@ comptime {
29	29
30	30	test "slicing" {
31	31	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	32	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
32	33
33	34	var array: [20]i32 = undefined;
34	35
...	...	@@ -64,6 +65,7 @@ test "comptime slice of undefined pointer of length 0" {
64	65
65	66	test "implicitly cast array of size 0 to slice" {
66	67	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	68	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
67	69
68	70	var msg = [_]u8{};
69	71	try assertLenIsZero(&msg);
...	...	@@ -120,6 +122,7 @@ test "slice of type" {
120	122
121	123	test "generic malloc free" {
122	124	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	125	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
123	126
124	127	const a = memAlloc(u8, 10) catch unreachable;
125	128	memFree(u8, a);
...	...	@@ -171,6 +174,7 @@ test "comptime pointer cast array and then slice" {
171	174	test "slicing zero length array" {
172	175	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
173	176	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	177	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
174	178
175	179	const s1 = ""[0..];
176	180	const s2 = ([_]u32{})[0..];
...	...	@@ -195,6 +199,8 @@ test "slicing pointer by length" {
195	199	const x = @intToPtr([*]i32, 0x1000)[0..0x500];
196	200	const y = x[0x100..];
197	201	test "compile time slice of pointer to hard coded address" {
	202	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	203
198	204	try expect(@ptrToInt(x) == 0x1000);
199	205	try expect(x.len == 0x500);
200	206
...	...	@@ -216,6 +222,7 @@ test "slice string literal has correct type" {
216	222
217	223	test "result location zero sized array inside struct field implicit cast to slice" {
218	224	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	225	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
219	226
220	227	const E = struct {
221	228	entries: []u32,
...	...	@@ -228,6 +235,7 @@ test "runtime safety lets us slice from len..len" {
228	235	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
229	236	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
230	237	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	238	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
231	239
232	240	var an_array = [_]u8{ 1, 2, 3 };
233	241	try expect(mem.eql(u8, sliceFromLenToLen(an_array[0..], 3, 3), ""));
...	...	@@ -238,8 +246,9 @@ fn sliceFromLenToLen(a_slice: []u8, start: usize, end: usize) []u8 {
238	246	}
239	247
240	248	test "C pointer" {
241		if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
242	249	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	250	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	251	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
243	252
244	253	var buf: [*c]const u8 = "kjdhfkjdhfdkjhfkfjhdfkjdhfkdjhfdkjhf";
245	254	var len: u32 = 10;
...	...	@@ -251,6 +260,7 @@ test "C pointer slice access" {
251	260	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
252	261	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
253	262	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	263	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
254	264
255	265	var buf: [10]u32 = [1]u32{42} ** 10;
256	266	const c_ptr = @ptrCast([*c]const u32, &buf);
...	...	@@ -280,6 +290,7 @@ fn sliceSum(comptime q: []const u8) i32 {
280	290	test "slice type with custom alignment" {
281	291	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
282	292	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	293	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
283	294
284	295	const LazilyResolvedType = struct {
285	296	anything: i32,
...	...	@@ -293,6 +304,7 @@ test "slice type with custom alignment" {
293	304
294	305	test "obtaining a null terminated slice" {
295	306	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	307	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
296	308
297	309	// here we have a normal array
298	310	var buf: [50]u8 = undefined;
...	...	@@ -335,6 +347,7 @@ test "empty array to slice" {
335	347	test "@ptrCast slice to pointer" {
336	348	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
337	349	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	350	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
338	351
339	352	const S = struct {
340	353	fn doTheTest() !void {
...	...	@@ -353,6 +366,7 @@ test "slice syntax resulting in pointer-to-array" {
353	366	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
354	367	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
355	368	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	369	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
356	370
357	371	const S = struct {
358	372	fn doTheTest() !void {
...	...	@@ -551,6 +565,7 @@ test "slice syntax resulting in pointer-to-array" {
551	565	test "slice pointer-to-array null terminated" {
552	566	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
553	567	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	568	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
554	569
555	570	comptime {
556	571	var array = [5:0]u8{ 1, 2, 3, 4, 5 };
...	...	@@ -569,6 +584,7 @@ test "slice pointer-to-array null terminated" {
569	584
570	585	test "slice pointer-to-array zero length" {
571	586	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	587	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
572	588
573	589	comptime {
574	590	{
...	...	@@ -603,6 +619,7 @@ test "type coercion of pointer to anon struct literal to pointer to slice" {
603	619	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
604	620	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
605	621	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	622	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
606	623
607	624	const S = struct {
608	625	const U = union {
...	...	@@ -655,6 +672,7 @@ test "array mult of slice gives ptr to array" {
655	672
656	673	test "slice bounds in comptime concatenation" {
657	674	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	675	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
658	676
659	677	const bs = comptime blk: {
660	678	const b = "........1........";
...	...	@@ -690,6 +708,7 @@ test "slice sentinel access at comptime" {
690	708	test "slicing array with sentinel as end index" {
691	709	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
692	710	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	711	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
693	712
694	713	const S = struct {
695	714	fn do() !void {
...	...	@@ -708,6 +727,7 @@ test "slicing array with sentinel as end index" {
708	727	test "slicing slice with sentinel as end index" {
709	728	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
710	729	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	730	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
711	731
712	732	const S = struct {
713	733	fn do() !void {
...	...	@@ -736,6 +756,8 @@ test "slice len modification at comptime" {
736	756	}
737	757
738	758	test "slice field ptr const" {
	759	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	760
739	761	const const_slice: []const u8 = "string";
740	762
741	763	const const_ptr_const_slice = &const_slice;
...	...	@@ -749,6 +771,7 @@ test "slice field ptr const" {
749	771
750	772	test "slice field ptr var" {
751	773	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	774	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
752	775
753	776	var var_slice: []const u8 = "string";
754	777
...	...	@@ -765,6 +788,7 @@ test "global slice field access" {
765	788	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
766	789	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
767	790	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	791	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
768	792
769	793	const S = struct {
770	794	var slice: []const u8 = undefined;
...	...	@@ -776,6 +800,8 @@ test "global slice field access" {
776	800	}
777	801
778	802	test "slice of void" {
	803	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	804
779	805	var n: usize = 10;
780	806	var arr: [12]void = undefined;
781	807	const slice = @as([]void, &arr)[0..n];
...	...	@@ -783,6 +809,8 @@ test "slice of void" {
783	809	}
784	810
785	811	test "slice with dereferenced value" {
	812	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	813
786	814	var a: usize = 0;
787	815	var idx: *usize = &a;
788	816	_ = blk: {
...	...	@@ -798,6 +826,7 @@ test "slice with dereferenced value" {
798	826
799	827	test "empty slice ptr is non null" {
800	828	if (builtin.zig_backend == .stage2_aarch64 and builtin.os.tag == .macos) return error.SkipZigTest; // TODO
	829	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
801	830
802	831	{
803	832	const empty_slice: []u8 = &[_]u8{};
...	...	@@ -816,6 +845,7 @@ test "empty slice ptr is non null" {
816	845	test "slice decays to many pointer" {
817	846	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
818	847	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
	848	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
819	849
820	850	var buf: [8]u8 = "abcdefg\x00".*;
821	851	const p: [*:0]const u8 = buf[0..7 :0];
...	...	@@ -826,6 +856,7 @@ test "write through pointer to optional slice arg" {
826	856	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
827	857	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
828	858	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
	859	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
829	860
830	861	const S = struct {
831	862	fn bar(foo: *?[]const u8) !void {

test/behavior/src.zig+3

...	...	@@ -17,6 +17,7 @@ test "@src" {
17	17	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
18	18	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
19	19	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	20	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
20	21
21	22	try doTheTest();
22	23	}
...	...	@@ -33,6 +34,8 @@ test "@src used as a comptime parameter" {
33	34	}
34	35
35	36	test "@src in tuple passed to anytype function" {
	37	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	38
36	39	const S = struct {
37	40	fn Foo(a: anytype) u32 {
38	41	return a[0].line;

test/behavior/struct.zig+53

...	...	@@ -11,6 +11,7 @@ top_level_field: i32,
11	11	test "top level fields" {
12	12	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
13	13	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	14	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
14	15
15	16	var instance = @This(){
16	17	.top_level_field = 1234,
...	...	@@ -89,6 +90,7 @@ test "structs" {
89	90	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
90	91	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
91	92	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	93	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
92	94
93	95	var foo: StructFoo = undefined;
94	96	@memset(@ptrCast([*]u8, &foo)[0..@sizeOf(StructFoo)], 0);
...	...	@@ -107,6 +109,7 @@ fn testMutation(foo: *StructFoo) void {
107	109
108	110	test "struct byval assign" {
109	111	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	112	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
110	113
111	114	var foo1: StructFoo = undefined;
112	115	var foo2: StructFoo = undefined;
...	...	@@ -119,6 +122,8 @@ test "struct byval assign" {
119	122	}
120	123
121	124	test "call struct static method" {
	125	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	126
122	127	const result = StructWithNoFields.add(3, 4);
123	128	try expect(result == 7);
124	129	}
...	...	@@ -126,6 +131,8 @@ test "call struct static method" {
126	131	const should_be_11 = StructWithNoFields.add(5, 6);
127	132
128	133	test "invoke static method in global scope" {
	134	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	135
129	136	try expect(should_be_11 == 11);
130	137	}
131	138
...	...	@@ -248,6 +255,7 @@ test "usingnamespace within struct scope" {
248	255	test "struct field init with catch" {
249	256	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
250	257	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	258	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
251	259
252	260	const S = struct {
253	261	fn doTheTest() !void {
...	...	@@ -274,6 +282,7 @@ const blah: packed struct {
274	282
275	283	test "bit field alignment" {
276	284	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	285
277	286	try expect(@TypeOf(&blah.b) == *align(1:3:1) const u3);
278	287	}
279	288
...	...	@@ -289,6 +298,7 @@ const Val = struct {
289	298	test "struct point to self" {
290	299	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
291	300	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	301	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
292	302
293	303	var root: Node = undefined;
294	304	root.val.x = 1;
...	...	@@ -305,6 +315,7 @@ test "struct point to self" {
305	315	test "void struct fields" {
306	316	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
307	317	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	318	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
308	319
309	320	const foo = VoidStructFieldsFoo{
310	321	.a = void{},
...	...	@@ -332,6 +343,7 @@ fn testReturnEmptyStructFromFn() EmptyStruct2 {
332	343
333	344	test "pass slice of empty struct to fn" {
334	345	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	346	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
335	347
336	348	try expect(testPassSliceOfEmptyStructToFn(&[_]EmptyStruct2{EmptyStruct2{}}) == 1);
337	349	}
...	...	@@ -343,6 +355,7 @@ test "self-referencing struct via array member" {
343	355	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
344	356	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
345	357	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	358	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
346	359
347	360	const T = struct {
348	361	children: [1]*@This(),
...	...	@@ -353,6 +366,8 @@ test "self-referencing struct via array member" {
353	366	}
354	367
355	368	test "empty struct method call" {
	369	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	370
356	371	const es = EmptyStruct{};
357	372	try expect(es.method() == 1234);
358	373	}
...	...	@@ -365,6 +380,7 @@ const EmptyStruct = struct {
365	380
366	381	test "align 1 field before self referential align 8 field as slice return type" {
367	382	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	383	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
368	384
369	385	const result = alloc(Expr);
370	386	try expect(result.len == 0);
...	...	@@ -388,6 +404,7 @@ test "packed struct" {
388	404	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
389	405	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
390	406	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	407	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
391	408
392	409	var foo = APackedStruct{
393	410	.x = 1,
...	...	@@ -416,6 +433,7 @@ test "packed struct 24bits" {
416	433	if (builtin.cpu.arch == .wasm32) return error.SkipZigTest; // TODO
417	434	if (builtin.cpu.arch == .arm) return error.SkipZigTest; // TODO
418	435	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	436	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
419	437
420	438	comptime {
421	439	std.debug.assert(@sizeOf(Foo24Bits) == @sizeOf(u24));
...	...	@@ -457,6 +475,7 @@ test "runtime struct initialization of bitfield" {
457	475	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
458	476	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
459	477	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	478	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
460	479
461	480	const s1 = Nibbles{
462	481	.x = x1,
...	...	@@ -495,6 +514,7 @@ test "packed struct fields are ordered from LSB to MSB" {
495	514	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
496	515	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
497	516	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	517	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
498	518
499	519	var all: u64 = 0x7765443322221111;
500	520	var bytes: [8]u8 align(@alignOf(Bitfields)) = undefined;
...	...	@@ -515,6 +535,7 @@ test "implicit cast packed struct field to const ptr" {
515	535	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
516	536	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
517	537	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	538	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
518	539
519	540	const LevelUpMove = packed struct {
520	541	move_id: u9,
...	...	@@ -533,6 +554,7 @@ test "implicit cast packed struct field to const ptr" {
533	554
534	555	test "zero-bit field in packed struct" {
535	556	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	557	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
536	558
537	559	const S = packed struct {
538	560	x: u10,
...	...	@@ -549,6 +571,7 @@ test "packed struct with non-ABI-aligned field" {
549	571	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
550	572	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
551	573	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
	574	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
552	575
553	576	const S = packed struct {
554	577	x: u9,
...	...	@@ -577,6 +600,7 @@ test "bit field access" {
577	600	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
578	601	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
579	602	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	603	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
580	604
581	605	var data = bit_field_1;
582	606	try expect(getA(&data) == 1);
...	...	@@ -631,6 +655,7 @@ test "packed array 24bits" {
631	655	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
632	656	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
633	657	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	658	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
634	659
635	660	comptime {
636	661	try expect(@sizeOf([9]Foo32Bits) == 9 * 4);
...	...	@@ -697,6 +722,7 @@ test "pointer to packed struct member in a stack variable" {
697	722	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
698	723	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
699	724	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	725	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
700	726
701	727	const S = packed struct {
702	728	a: u2,
...	...	@@ -723,6 +749,7 @@ test "packed struct with u0 field access" {
723	749	test "access to global struct fields" {
724	750	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
725	751	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	752	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
726	753
727	754	g_foo.bar.value = 42;
728	755	try expect(g_foo.bar.value == 42);
...	...	@@ -747,6 +774,7 @@ test "packed struct with fp fields" {
747	774	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
748	775	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
749	776	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	777	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
750	778
751	779	const S = packed struct {
752	780	data0: f32,
...	...	@@ -799,6 +827,7 @@ test "non-packed struct with u128 entry in union" {
799	827	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
800	828	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
801	829	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	830	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
802	831
803	832	const U = union(enum) {
804	833	Num: u128,
...	...	@@ -822,6 +851,7 @@ test "packed struct field passed to generic function" {
822	851	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
823	852	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
824	853	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	854	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
825	855
826	856	const S = struct {
827	857	const P = packed struct {
...	...	@@ -915,6 +945,8 @@ test "tuple assigned to variable" {
915	945	}
916	946
917	947	test "comptime struct field" {
	948	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	949
918	950	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
919	951	if (builtin.cpu.arch == .arm) return error.SkipZigTest; // TODO
920	952
...	...	@@ -933,6 +965,7 @@ test "tuple element initialized with fn call" {
933	965	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
934	966	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
935	967	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	968	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
936	969
937	970	const S = struct {
938	971	fn doTheTest() !void {
...	...	@@ -951,6 +984,7 @@ test "struct with union field" {
951	984	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
952	985	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
953	986	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	987	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
954	988
955	989	const Value = struct {
956	990	ref: u32 = 2,
...	...	@@ -971,6 +1005,7 @@ test "type coercion of anon struct literal to struct" {
971	1005	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
972	1006	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
973	1007	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	1008	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
974	1009
975	1010	const S = struct {
976	1011	const S2 = struct {
...	...	@@ -1008,6 +1043,7 @@ test "type coercion of pointer to anon struct literal to pointer to struct" {
1008	1043	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1009	1044	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1010	1045	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	1046	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1011	1047
1012	1048	const S = struct {
1013	1049	const S2 = struct {
...	...	@@ -1047,6 +1083,7 @@ test "packed struct with undefined initializers" {
1047	1083	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1048	1084	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
1049	1085	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	1086	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1050	1087
1051	1088	const S = struct {
1052	1089	const P = packed struct {
...	...	@@ -1115,6 +1152,7 @@ test "anon init through error unions and optionals" {
1115	1152	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1116	1153	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1117	1154	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	1155	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1118	1156
1119	1157	const S = struct {
1120	1158	a: u32,
...	...	@@ -1141,6 +1179,7 @@ test "anon init through optional" {
1141	1179	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1142	1180	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1143	1181	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	1182	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1144	1183
1145	1184	const S = struct {
1146	1185	a: u32,
...	...	@@ -1160,6 +1199,7 @@ test "anon init through error union" {
1160	1199	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1161	1200	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1162	1201	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	1202	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1163	1203
1164	1204	const S = struct {
1165	1205	a: u32,
...	...	@@ -1179,6 +1219,7 @@ test "typed init through error unions and optionals" {
1179	1219	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1180	1220	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1181	1221	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	1222	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1182	1223
1183	1224	const S = struct {
1184	1225	a: u32,
...	...	@@ -1239,6 +1280,7 @@ test "packed struct aggregate init" {
1239	1280	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1240	1281	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1241	1282	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	1283	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1242	1284
1243	1285	const S = struct {
1244	1286	fn foo(a: i2, b: i6) u8 {
...	...	@@ -1258,6 +1300,7 @@ test "packed struct field access via pointer" {
1258	1300	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1259	1301	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1260	1302	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	1303	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1261	1304
1262	1305	const S = struct {
1263	1306	fn doTheTest() !void {
...	...	@@ -1313,6 +1356,7 @@ test "under-aligned struct field" {
1313	1356	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1314	1357	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1315	1358	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	1359	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1316	1360
1317	1361	const U = extern union {
1318	1362	fd: i32,
...	...	@@ -1333,6 +1377,7 @@ test "under-aligned struct field" {
1333	1377	test "fieldParentPtr of a zero-bit field" {
1334	1378	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1335	1379	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	1380	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1336	1381
1337	1382	const S = struct {
1338	1383	fn testStruct(comptime A: type) !void {
...	...	@@ -1380,6 +1425,7 @@ test "fieldParentPtr of a zero-bit field" {
1380	1425
1381	1426	test "struct field has a pointer to an aligned version of itself" {
1382	1427	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	1428	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1383	1429
1384	1430	const E = struct {
1385	1431	next: *align(1) @This(),
...	...	@@ -1391,6 +1437,8 @@ test "struct field has a pointer to an aligned version of itself" {
1391	1437	}
1392	1438
1393	1439	test "struct has only one reference" {
	1440	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1441
1394	1442	const S = struct {
1395	1443	fn optionalStructParam(_: ?struct { x: u8 }) void {}
1396	1444	fn errorUnionStructParam(_: error{}!struct { x: u8 }) void {}
...	...	@@ -1439,6 +1487,7 @@ test "struct has only one reference" {
1439	1487	test "no dependency loop on pointer to optional struct" {
1440	1488	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1441	1489	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	1490	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1442	1491
1443	1492	const S = struct {
1444	1493	const A = struct { b: B };
...	...	@@ -1459,6 +1508,7 @@ test "discarded struct initialization works as expected" {
1459	1508
1460	1509	test "function pointer in struct returns the struct" {
1461	1510	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	1511	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1462	1512
1463	1513	const A = struct {
1464	1514	const A = @This();
...	...	@@ -1474,6 +1524,7 @@ test "function pointer in struct returns the struct" {
1474	1524
1475	1525	test "no dependency loop on optional field wrapped in generic function" {
1476	1526	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	1527	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1477	1528
1478	1529	const S = struct {
1479	1530	fn Atomic(comptime T: type) type {
...	...	@@ -1493,6 +1544,7 @@ test "no dependency loop on optional field wrapped in generic function" {
1493	1544	test "optional field init with tuple" {
1494	1545	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1495	1546	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	1547	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1496	1548
1497	1549	const S = struct {
1498	1550	a: ?struct { b: u32 },
...	...	@@ -1506,6 +1558,7 @@ test "optional field init with tuple" {
1506	1558
1507	1559	test "if inside struct init inside if" {
1508	1560	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	1561	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1509	1562
1510	1563	const MyStruct = struct { x: u32 };
1511	1564	const b: u32 = 5;

test/behavior/struct_contains_null_ptr_itself.zig+1

...	...	@@ -5,6 +5,7 @@ const builtin = @import("builtin");
5	5	test "struct contains null pointer which contains original struct" {
6	6	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
7	7	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	8	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
8	9
9	10	var x: ?*NodeLineComment = null;
10	11	try expect(x == null);

test/behavior/struct_contains_slice_of_itself.zig+2

...	...	@@ -13,6 +13,7 @@ const NodeAligned = struct {
13	13
14	14	test "struct contains slice of itself" {
15	15	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	16	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
16	17
17	18	var other_nodes = [_]Node{
18	19	Node{
...	...	@@ -53,6 +54,7 @@ test "struct contains slice of itself" {
53	54	test "struct contains aligned slice of itself" {
54	55	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
55	56	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	57	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
56	58
57	59	var other_nodes = [_]NodeAligned{
58	60	NodeAligned{

test/behavior/switch.zig+18

...	...	@@ -117,6 +117,7 @@ fn trueIfBoolFalseOtherwise(comptime T: type) bool {
117	117
118	118	test "switching on booleans" {
119	119	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	120	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
120	121
121	122	try testSwitchOnBools();
122	123	comptime try testSwitchOnBools();
...	...	@@ -214,6 +215,7 @@ fn poll() void {
214	215
215	216	test "switch on global mutable var isn't constant-folded" {
216	217	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	218	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
217	219
218	220	while (state < 2) {
219	221	poll();
...	...	@@ -230,6 +232,7 @@ test "switch prong with variable" {
230	232	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
231	233	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
232	234	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	235	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
233	236
234	237	try switchProngWithVarFn(SwitchProngWithVarEnum{ .One = 13 });
235	238	try switchProngWithVarFn(SwitchProngWithVarEnum{ .Two = 13.0 });
...	...	@@ -254,6 +257,7 @@ test "switch on enum using pointer capture" {
254	257	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
255	258	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
256	259	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	260	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
257	261
258	262	try testSwitchEnumPtrCapture();
259	263	comptime try testSwitchEnumPtrCapture();
...	...	@@ -314,6 +318,7 @@ test "switch on union with some prongs capturing" {
314	318	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
315	319	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
316	320	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	321	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
317	322
318	323	const X = union(enum) {
319	324	a,
...	...	@@ -344,12 +349,15 @@ fn returnsFalse() bool {
344	349	}
345	350	}
346	351	test "switch on const enum with var" {
	352	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	353
347	354	try expect(!returnsFalse());
348	355	}
349	356
350	357	test "anon enum literal used in switch on union enum" {
351	358	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
352	359	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	360	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
353	361
354	362	const Foo = union(enum) {
355	363	a: i32,
...	...	@@ -388,6 +396,7 @@ fn switchWithUnreachable(x: i32) i32 {
388	396
389	397	test "capture value of switch with all unreachable prongs" {
390	398	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	399	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
391	400
392	401	const x = return_a_number() catch \|err\| switch (err) {
393	402	else => unreachable,
...	...	@@ -401,6 +410,7 @@ fn return_a_number() anyerror!i32 {
401	410
402	411	test "switch on integer with else capturing expr" {
403	412	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	413	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
404	414
405	415	const S = struct {
406	416	fn doTheTest() !void {
...	...	@@ -420,6 +430,7 @@ test "else prong of switch on error set excludes other cases" {
420	430	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
421	431	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
422	432	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	433	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
423	434
424	435	const S = struct {
425	436	fn doTheTest() !void {
...	...	@@ -454,6 +465,7 @@ test "switch prongs with error set cases make a new error set type for capture v
454	465	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
455	466	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
456	467	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	468	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
457	469
458	470	const S = struct {
459	471	fn doTheTest() !void {
...	...	@@ -488,6 +500,7 @@ test "switch prongs with error set cases make a new error set type for capture v
488	500
489	501	test "return result loc and then switch with range implicit casted to error union" {
490	502	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	503	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
491	504
492	505	const S = struct {
493	506	fn doTheTest() !void {
...	...	@@ -528,6 +541,7 @@ test "switch prongs with cases with identical payload types" {
528	541	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
529	542	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
530	543	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	544	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
531	545
532	546	const Union = union(enum) {
533	547	A: usize,
...	...	@@ -571,6 +585,7 @@ test "switch prongs with cases with identical payload types" {
571	585	test "switch on pointer type" {
572	586	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
573	587	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	588	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
574	589
575	590	const S = struct {
576	591	const X = struct {
...	...	@@ -618,6 +633,7 @@ test "switch capture copies its payload" {
618	633	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
619	634	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
620	635	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	636	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
621	637
622	638	const S = struct {
623	639	fn doTheTest() !void {
...	...	@@ -692,6 +708,8 @@ test "switch item sizeof" {
692	708	}
693	709
694	710	test "comptime inline switch" {
	711	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	712
695	713	const U = union(enum) { a: type, b: type };
696	714	const value = comptime blk: {
697	715	var u: U = .{ .a = u32 };

test/behavior/switch_prong_err_enum.zig+1

...	...	@@ -24,6 +24,7 @@ test "switch prong returns error enum" {
24	24	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
25	25	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
26	26	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	27	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
27	28
28	29	switch (doThing(17) catch unreachable) {
29	30	FormValue.Address => \|payload\| {

test/behavior/switch_prong_implicit_cast.zig+1

...	...	@@ -18,6 +18,7 @@ test "switch prong implicit cast" {
18	18	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
19	19	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
20	20	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	21	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
21	22
22	23	const result = switch (foo(2) catch unreachable) {
23	24	FormValue.One => false,

test/behavior/this.zig+3

...	...	@@ -21,12 +21,15 @@ fn add(x: i32, y: i32) i32 {
21	21	}
22	22
23	23	test "this refer to module call private fn" {
	24	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	25
24	26	try expect(module.add(1, 2) == 3);
25	27	}
26	28
27	29	test "this refer to container" {
28	30	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
29	31	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	32	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
30	33
31	34	var pt: Point(i32) = undefined;
32	35	pt.x = 12;

test/behavior/threadlocal.zig+3

...	...	@@ -11,6 +11,7 @@ test "thread local variable" {
11	11	else => return error.SkipZigTest,
12	12	}; // TODO
13	13	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	14	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
14	15
15	16	const S = struct {
16	17	threadlocal var t: i32 = 1234;
...	...	@@ -28,6 +29,7 @@ test "pointer to thread local array" {
28	29	else => return error.SkipZigTest,
29	30	}; // TODO
30	31	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	32	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
31	33
32	34	const s = "Hello world";
33	35	std.mem.copy(u8, buffer[0..], s);
...	...	@@ -45,6 +47,7 @@ test "reference a global threadlocal variable" {
45	47	else => return error.SkipZigTest,
46	48	}; // TODO
47	49	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	50	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
48	51
49	52	_ = nrfx_uart_rx(&g_uart0);
50	53	}

test/behavior/translate_c_macros.zig+16

...	...	@@ -9,6 +9,7 @@ const latin1 = @cImport(@cInclude("behavior/translate_c_macros_not_utf8.h"));
9	9
10	10	test "casting to void with a macro" {
11	11	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	12	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
12	13
13	14	h.IGNORE_ME_1(42);
14	15	h.IGNORE_ME_2(42);
...	...	@@ -26,6 +27,7 @@ test "initializer list expression" {
26	27	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
27	28	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
28	29	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	30	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
29	31
30	32	try expectEqual(h.Color{
31	33	.r = 200,
...	...	@@ -38,6 +40,7 @@ test "initializer list expression" {
38	40	test "sizeof in macros" {
39	41	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
40	42	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	43	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
41	44
42	45	try expect(@as(c_int, @sizeOf(u32)) == h.MY_SIZEOF(u32));
43	46	try expect(@as(c_int, @sizeOf(u32)) == h.MY_SIZEOF2(u32));
...	...	@@ -45,6 +48,7 @@ test "sizeof in macros" {
45	48
46	49	test "reference to a struct type" {
47	50	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	51	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
48	52
49	53	try expect(@sizeOf(h.struct_Foo) == h.SIZE_OF_FOO);
50	54	}
...	...	@@ -54,6 +58,7 @@ test "cast negative integer to pointer" {
54	58	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
55	59	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
56	60	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	61	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
57	62
58	63	try expectEqual(@intToPtr(?*anyopaque, @bitCast(usize, @as(isize, -1))), h.MAP_FAILED);
59	64	}
...	...	@@ -64,6 +69,7 @@ test "casting to union with a macro" {
64	69	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
65	70	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
66	71	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	72	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
67	73
68	74	const l: c_long = 42;
69	75	const d: f64 = 2.0;
...	...	@@ -80,6 +86,7 @@ test "casting or calling a value with a paren-surrounded macro" {
80	86	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
81	87	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
82	88	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	89	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
83	90
84	91	const l: c_long = 42;
85	92	const casted = h.CAST_OR_CALL_WITH_PARENS(c_int, l);
...	...	@@ -99,6 +106,7 @@ test "nested comma operator" {
99	106	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
100	107	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
101	108	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	109	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
102	110
103	111	try expectEqual(@as(c_int, 3), h.NESTED_COMMA_OPERATOR);
104	112	try expectEqual(@as(c_int, 3), h.NESTED_COMMA_OPERATOR_LHS);
...	...	@@ -109,6 +117,7 @@ test "cast functions" {
109	117	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
110	118	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
111	119	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	120	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
112	121
113	122	const S = struct {
114	123	fn foo() void {}
...	...	@@ -122,6 +131,7 @@ test "large integer macro" {
122	131	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
123	132	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
124	133	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	134	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
125	135
126	136	try expectEqual(@as(c_ulonglong, 18446744073709550592), h.LARGE_INT);
127	137	}
...	...	@@ -131,6 +141,7 @@ test "string literal macro with embedded tab character" {
131	141	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
132	142	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
133	143	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	144	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
134	145
135	146	try expectEqualStrings("hello\t", h.EMBEDDED_TAB);
136	147	}
...	...	@@ -140,6 +151,7 @@ test "string and char literals that are not UTF-8 encoded. Issue #12784" {
140	151	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
141	152	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
142	153	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	154	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
143	155
144	156	try expectEqual(@as(u8, '\xA9'), latin1.UNPRINTABLE_CHAR);
145	157	try expectEqualStrings("\xA9\xA9\xA9", latin1.UNPRINTABLE_STRING);
...	...	@@ -151,6 +163,7 @@ test "Macro that uses division operator. Issue #13162" {
151	163	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
152	164	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
153	165	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	166	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
154	167
155	168	try expectEqual(@as(c_int, 42), h.DIVIDE_CONSTANT(@as(c_int, 42_000)));
156	169	try expectEqual(@as(c_uint, 42), h.DIVIDE_CONSTANT(@as(c_uint, 42_000)));
...	...	@@ -184,6 +197,7 @@ test "Macro that uses remainder operator. Issue #13346" {
184	197	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
185	198	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
186	199	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	200	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
187	201
188	202	try expectEqual(@as(c_int, 2_010), h.REMAINDER_CONSTANT(@as(c_int, 42_010)));
189	203	try expectEqual(@as(c_uint, 2_030), h.REMAINDER_CONSTANT(@as(c_uint, 42_030)));
...	...	@@ -214,5 +228,7 @@ test "Macro that uses remainder operator. Issue #13346" {
214	228	}
215	229
216	230	test "@typeInfo on @cImport result" {
	231	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	232
217	233	try expect(@typeInfo(h).Struct.decls.len > 1);
218	234	}

test/behavior/truncate.zig+1

...	...	@@ -65,6 +65,7 @@ test "truncate on vectors" {
65	65	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
66	66	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
67	67	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	68	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
68	69
69	70	const S = struct {
70	71	fn doTheTest() !void {

test/behavior/try.zig+5

...	...	@@ -4,6 +4,7 @@ const expect = std.testing.expect;
4	4
5	5	test "try on error union" {
6	6	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	7	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
7	8
8	9	try tryOnErrorUnionImpl();
9	10	comptime try tryOnErrorUnionImpl();
...	...	@@ -23,6 +24,8 @@ fn returnsTen() anyerror!i32 {
23	24	}
24	25
25	26	test "try without vars" {
	27	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	28
26	29	const result1 = if (failIfTrue(true)) 1 else \|_\| @as(i32, 2);
27	30	try expect(result1 == 2);
28	31
...	...	@@ -39,6 +42,8 @@ fn failIfTrue(ok: bool) anyerror!void {
39	42	}
40	43
41	44	test "try then not executed with assignment" {
	45	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	46
42	47	if (failIfTrue(true)) {
43	48	unreachable;
44	49	} else \|err\| {

test/behavior/tuple.zig+16

...	...	@@ -9,6 +9,7 @@ test "tuple concatenation" {
9	9	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
10	10	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
11	11	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	12	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
12	13
13	14	const S = struct {
14	15	fn doTheTest() !void {
...	...	@@ -52,6 +53,7 @@ test "more tuple concatenation" {
52	53	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
53	54	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
54	55	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	56	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
55	57
56	58	const T = struct {
57	59	fn consume_tuple(tuple: anytype, len: usize) !void {
...	...	@@ -212,6 +214,7 @@ test "fieldParentPtr of tuple" {
212	214	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
213	215	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
214	216	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	217	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
215	218
216	219	var x: u32 = 0;
217	220	const tuple = .{ x, x };
...	...	@@ -222,6 +225,7 @@ test "fieldParentPtr of anon struct" {
222	225	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
223	226	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
224	227	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	228	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
225	229
226	230	var x: u32 = 0;
227	231	const anon_st = .{ .foo = x, .bar = x };
...	...	@@ -242,6 +246,7 @@ test "offsetOf anon struct" {
242	246
243	247	test "initializing tuple with mixed comptime-runtime fields" {
244	248	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	249	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
245	250
246	251	var x: u32 = 15;
247	252	const T = @TypeOf(.{ @as(i32, -1234), @as(u32, 5678), x });
...	...	@@ -251,6 +256,7 @@ test "initializing tuple with mixed comptime-runtime fields" {
251	256
252	257	test "initializing anon struct with mixed comptime-runtime fields" {
253	258	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	259	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
254	260
255	261	var x: u32 = 15;
256	262	const T = @TypeOf(.{ .foo = @as(i32, -1234), .bar = x });
...	...	@@ -262,6 +268,7 @@ test "tuple in tuple passed to generic function" {
262	268	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
263	269	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
264	270	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	271	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
265	272
266	273	const S = struct {
267	274	fn pair(x: f32, y: f32) std.meta.Tuple(&.{ f32, f32 }) {
...	...	@@ -281,6 +288,7 @@ test "coerce tuple to tuple" {
281	288	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
282	289	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
283	290	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	291	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
284	292
285	293	const T = std.meta.Tuple(&.{u8});
286	294	const S = struct {
...	...	@@ -295,6 +303,7 @@ test "tuple type with void field" {
295	303	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
296	304	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
297	305	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	306	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
298	307
299	308	const T = std.meta.Tuple(&[_]type{void});
300	309	const x = T{{}};
...	...	@@ -302,6 +311,8 @@ test "tuple type with void field" {
302	311	}
303	312
304	313	test "zero sized struct in tuple handled correctly" {
	314	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	315
305	316	const State = struct {
306	317	const Self = @This();
307	318	data: @Type(.{
...	...	@@ -331,6 +342,7 @@ test "zero sized struct in tuple handled correctly" {
331	342	test "tuple type with void field and a runtime field" {
332	343	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
333	344	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	345	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
334	346
335	347	const T = std.meta.Tuple(&[_]type{ usize, void });
336	348	var t: T = .{ 5, {} };
...	...	@@ -341,6 +353,7 @@ test "branching inside tuple literal" {
341	353	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
342	354	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
343	355	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	356	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
344	357
345	358	const S = struct {
346	359	fn foo(a: anytype) !void {
...	...	@@ -356,6 +369,7 @@ test "tuple initialized with a runtime known value" {
356	369	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
357	370	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
358	371	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	372	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
359	373
360	374	const E = union(enum) { e: []const u8 };
361	375	const W = union(enum) { w: E };
...	...	@@ -370,6 +384,7 @@ test "tuple of struct concatenation and coercion to array" {
370	384	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
371	385	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
372	386	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	387	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
373	388
374	389	const StructWithDefault = struct { value: f32 = 42 };
375	390	const SomeStruct = struct { array: [4]StructWithDefault };
...	...	@@ -384,6 +399,7 @@ test "nested runtime conditionals in tuple initializer" {
384	399	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
385	400	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
386	401	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	402	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
387	403
388	404	var data: u8 = 0;
389	405	const x = .{

test/behavior/tuple_declarations.zig+2

...	...	@@ -7,6 +7,7 @@ const expectEqualStrings = testing.expectEqualStrings;
7	7	test "tuple declaration type info" {
8	8	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
9	9	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
	10	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
10	11
11	12	{
12	13	const T = struct { comptime u32 align(2) = 1, []const u8 };
...	...	@@ -56,6 +57,7 @@ test "tuple declaration type info" {
56	57	test "Tuple declaration usage" {
57	58	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
58	59	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
	60	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
59	61
60	62	const T = struct { u32, []const u8 };
61	63	var t: T = .{ 1, "foo" };

test/behavior/type.zig+5

...	...	@@ -203,6 +203,7 @@ test "Type.Opaque" {
203	203	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
204	204	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
205	205	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	206	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
206	207
207	208	const Opaque = @Type(.{
208	209	.Opaque = .{
...	...	@@ -261,6 +262,7 @@ test "Type.Struct" {
261	262	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
262	263	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
263	264	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	265	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
264	266
265	267	const A = @Type(@typeInfo(struct { x: u8, y: u32 }));
266	268	const infoA = @typeInfo(A).Struct;
...	...	@@ -348,6 +350,7 @@ test "Type.Struct" {
348	350	test "Type.Enum" {
349	351	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
350	352	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	353	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
351	354
352	355	const Foo = @Type(.{
353	356	.Enum = .{
...	...	@@ -384,6 +387,7 @@ test "Type.Union" {
384	387	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
385	388	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
386	389	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	390	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
387	391
388	392	const Untagged = @Type(.{
389	393	.Union = .{
...	...	@@ -487,6 +491,7 @@ test "Type.Fn" {
487	491	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
488	492	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
489	493	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	494	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
490	495
491	496	const some_opaque = opaque {};
492	497	const some_ptr = *some_opaque;

test/behavior/type_info.zig+10

...	...	@@ -160,6 +160,7 @@ test "type info: error set, error union info, anyerror" {
160	160	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
161	161	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
162	162	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	163	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
163	164
164	165	try testErrorSet();
165	166	comptime try testErrorSet();
...	...	@@ -191,6 +192,7 @@ test "type info: error set single value" {
191	192	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
192	193	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
193	194	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	195	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
194	196
195	197	const TestSet = error.One;
196	198
...	...	@@ -204,6 +206,7 @@ test "type info: error set merged" {
204	206	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
205	207	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
206	208	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	209	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
207	210
208	211	const TestSet = error{ One, Two } \|\| error{Three};
209	212
...	...	@@ -219,6 +222,7 @@ test "type info: enum info" {
219	222	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
220	223	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
221	224	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	225	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
222	226
223	227	try testEnum();
224	228	comptime try testEnum();
...	...	@@ -281,6 +285,7 @@ fn testUnion() !void {
281	285
282	286	test "type info: struct info" {
283	287	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	288	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
284	289
285	290	try testStruct();
286	291	comptime try testStruct();
...	...	@@ -349,6 +354,8 @@ fn testOpaque() !void {
349	354	}
350	355
351	356	test "type info: function type info" {
	357	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	358
352	359	try testFunction();
353	360	comptime try testFunction();
354	361	}
...	...	@@ -506,6 +513,7 @@ test "type info for async frames" {
506	513
507	514	test "Declarations are returned in declaration order" {
508	515	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	516	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
509	517
510	518	const S = struct {
511	519	const a = 1;
...	...	@@ -528,6 +536,7 @@ test "Struct.is_tuple for anon list literal" {
528	536
529	537	test "Struct.is_tuple for anon struct literal" {
530	538	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	539	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
531	540
532	541	const info = @typeInfo(@TypeOf(.{ .a = 0 }));
533	542	try expect(!info.Struct.is_tuple);
...	...	@@ -564,6 +573,7 @@ test "value from struct @typeInfo default_value can be loaded at comptime" {
564	573	test "@typeInfo decls and usingnamespace" {
565	574	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
566	575	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	576	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
567	577
568	578	const A = struct {
569	579	const x = 5;

test/behavior/typename.zig+8

...	...	@@ -15,6 +15,7 @@ test "anon fn param" {
15	15	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
16	16	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
17	17	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	18	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
18	19
19	20	// https://github.com/ziglang/zig/issues/9339
20	21	try expectEqualStringsIgnoreDigits(
...	...	@@ -40,6 +41,7 @@ test "anon field init" {
40	41	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
41	42	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
42	43	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	44	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
43	45
44	46	const Foo = .{
45	47	.T1 = struct {},
...	...	@@ -65,6 +67,7 @@ test "basic" {
65	67	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
66	68	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
67	69	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	70	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
68	71
69	72	try expectEqualStrings("i64", @typeName(i64));
70	73	try expectEqualStrings("usize", @typeName(usize));
...	...	@@ -88,6 +91,7 @@ test "top level decl" {
88	91	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
89	92	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
90	93	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	94	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
91	95
92	96	try expectEqualStrings(
93	97	"behavior.typename.A_Struct",
...	...	@@ -137,6 +141,7 @@ test "fn param" {
137	141	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
138	142	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
139	143	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	144	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
140	145
141	146	// https://github.com/ziglang/zig/issues/675
142	147	try expectEqualStrings(
...	...	@@ -207,6 +212,7 @@ test "local variable" {
207	212	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
208	213	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
209	214	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	215	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
210	216
211	217	const Foo = struct { a: u32 };
212	218	const Bar = union { a: u32 };
...	...	@@ -225,6 +231,7 @@ test "comptime parameters not converted to anytype in function type" {
225	231	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
226	232	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
227	233	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	234	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
228	235
229	236	const T = fn (fn (type) void, void) void;
230	237	try expectEqualStrings("fn(comptime fn(comptime type) void, void) void", @typeName(T));
...	...	@@ -234,6 +241,7 @@ test "anon name strategy used in sub expression" {
234	241	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
235	242	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
236	243	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	244	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
237	245
238	246	const S = struct {
239	247	fn getTheName() []const u8 {

test/behavior/undefined.zig+3

...	...	@@ -47,6 +47,7 @@ test "assign undefined to struct" {
47	47	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
48	48	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
49	49	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	50	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
50	51
51	52	comptime {
52	53	var foo: Foo = undefined;
...	...	@@ -64,6 +65,7 @@ test "assign undefined to struct with method" {
64	65	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
65	66	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
66	67	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	68	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
67	69
68	70	comptime {
69	71	var foo: Foo = undefined;
...	...	@@ -79,6 +81,7 @@ test "assign undefined to struct with method" {
79	81
80	82	test "type name of undefined" {
81	83	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	84	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
82	85
83	86	const x = undefined;
84	87	try expect(mem.eql(u8, @typeName(@TypeOf(x)), "@TypeOf(undefined)"));

test/behavior/underscore.zig+1

...	...	@@ -8,6 +8,7 @@ test "ignore lval with underscore" {
8	8
9	9	test "ignore lval with underscore (while loop)" {
10	10	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	11	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
11	12
12	13	while (optionalReturnError()) \|_\| {
13	14	while (optionalReturnError()) \|_\| {

test/behavior/union.zig+61

...	...	@@ -14,6 +14,7 @@ test "basic unions with floats" {
14	14	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
15	15	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
16	16	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	17	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
17	18
18	19	var foo = FooWithFloats{ .int = 1 };
19	20	try expect(foo.int == 1);
...	...	@@ -29,6 +30,7 @@ test "init union with runtime value - floats" {
29	30	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
30	31	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
31	32	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	33	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
32	34
33	35	var foo: FooWithFloats = undefined;
34	36
...	...	@@ -40,6 +42,7 @@ test "basic unions" {
40	42	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
41	43	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
42	44	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	45	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
43	46
44	47	var foo = Foo{ .int = 1 };
45	48	try expect(foo.int == 1);
...	...	@@ -58,6 +61,7 @@ test "init union with runtime value" {
58	61	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
59	62	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
60	63	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	64	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
61	65
62	66	var foo: Foo = undefined;
63	67
...	...	@@ -96,6 +100,7 @@ const FooExtern = extern union {
96	100	test "basic extern unions" {
97	101	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
98	102	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	103	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
99	104
100	105	var foo = FooExtern{ .int = 1 };
101	106	try expect(foo.int == 1);
...	...	@@ -167,6 +172,7 @@ test "constant tagged union with payload" {
167	172	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
168	173	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
169	174	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	175	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
170	176
171	177	var empty = TaggedUnionWithPayload{ .Empty = {} };
172	178	var full = TaggedUnionWithPayload{ .Full = 13 };
...	...	@@ -216,6 +222,7 @@ test "union with specified enum tag" {
216	222	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
217	223	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
218	224	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	225	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
219	226
220	227	try doTest();
221	228	comptime try doTest();
...	...	@@ -225,6 +232,7 @@ test "packed union generates correctly aligned type" {
225	232	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
226	233	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
227	234	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	235	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
228	236
229	237	const U = packed union {
230	238	f1: *const fn () error{TestUnexpectedResult}!void,
...	...	@@ -264,6 +272,7 @@ test "comparison between union and enum literal" {
264	272	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
265	273	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
266	274	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	275	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
267	276
268	277	try testComparison();
269	278	comptime try testComparison();
...	...	@@ -279,6 +288,7 @@ test "cast union to tag type of union" {
279	288	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
280	289	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
281	290	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	291	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
282	292
283	293	try testCastUnionToTag();
284	294	comptime try testCastUnionToTag();
...	...	@@ -299,6 +309,7 @@ test "cast tag type of union to union" {
299	309	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
300	310	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
301	311	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	312	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
302	313
303	314	var x: Value2 = Letter2.B;
304	315	try expect(@as(Letter2, x) == Letter2.B);
...	...	@@ -314,6 +325,7 @@ test "implicit cast union to its tag type" {
314	325	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
315	326	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
316	327	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	328	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
317	329
318	330	var x: Value2 = Letter2.B;
319	331	try expect(x == Letter2.B);
...	...	@@ -334,6 +346,7 @@ test "constant packed union" {
334	346	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
335	347	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
336	348	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	349	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
337	350
338	351	try testConstPackedUnion(&[_]PackThis{PackThis{ .StringLiteral = 1 }});
339	352	}
...	...	@@ -353,6 +366,7 @@ test "simple union(enum(u32))" {
353	366	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
354	367	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
355	368	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	369	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
356	370
357	371	var x = MultipleChoice.C;
358	372	try expect(x == MultipleChoice.C);
...	...	@@ -378,6 +392,7 @@ test "tagged union initialization with runtime void" {
378	392	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
379	393	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
380	394	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	395	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
381	396
382	397	try expect(testTaggedUnionInit({}));
383	398	}
...	...	@@ -398,6 +413,7 @@ test "tagged union with no payloads" {
398	413	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
399	414	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
400	415	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	416	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
401	417
402	418	const a = UnionEnumNoPayloads{ .B = {} };
403	419	switch (a) {
...	...	@@ -408,6 +424,7 @@ test "tagged union with no payloads" {
408	424
409	425	test "union with only 1 field casted to its enum type" {
410	426	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	427	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
411	428
412	429	const Literal = union(enum) {
413	430	Number: f64,
...	...	@@ -444,6 +461,7 @@ test "global union with single field is correctly initialized" {
444	461	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
445	462	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
446	463	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	464	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
447	465
448	466	glbl = Foo1{
449	467	.f = @typeInfo(Foo1).Union.fields[0].type{ .x = 123 },
...	...	@@ -462,6 +480,7 @@ test "initialize global array of union" {
462	480	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
463	481	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
464	482	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	483	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
465	484
466	485	glbl_array[1] = FooUnion{ .U1 = 2 };
467	486	glbl_array[0] = FooUnion{ .U0 = 1 };
...	...	@@ -473,6 +492,7 @@ test "update the tag value for zero-sized unions" {
473	492	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
474	493	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
475	494	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	495	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
476	496
477	497	const S = union(enum) {
478	498	U0: void,
...	...	@@ -489,6 +509,7 @@ test "union initializer generates padding only if needed" {
489	509	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
490	510	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
491	511	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	512	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
492	513
493	514	const U = union(enum) {
494	515	A: u24,
...	...	@@ -501,6 +522,7 @@ test "union initializer generates padding only if needed" {
501	522	test "runtime tag name with single field" {
502	523	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
503	524	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	525	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
504	526
505	527	const U = union(enum) {
506	528	A: i32,
...	...	@@ -514,6 +536,7 @@ test "method call on an empty union" {
514	536	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
515	537	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
516	538	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	539	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
517	540
518	541	const S = struct {
519	542	const MyUnion = union(MyUnionTag) {
...	...	@@ -576,6 +599,7 @@ test "tagged union as return value" {
576	599	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
577	600	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
578	601	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	602	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
579	603
580	604	switch (returnAnInt(13)) {
581	605	TaggedFoo.One => \|value\| try expect(value == 13),
...	...	@@ -591,6 +615,7 @@ test "tagged union with all void fields but a meaningful tag" {
591	615	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
592	616	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
593	617	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	618	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
594	619
595	620	const S = struct {
596	621	const B = union(enum) {
...	...	@@ -620,6 +645,7 @@ test "union(enum(u32)) with specified and unspecified tag values" {
620	645	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
621	646	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
622	647	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	648	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
623	649
624	650	comptime try expect(Tag(Tag(MultipleChoice2)) == u32);
625	651	try testEnumWithSpecifiedAndUnspecifiedTagValues(MultipleChoice2{ .C = 123 });
...	...	@@ -657,6 +683,7 @@ test "switch on union with only 1 field" {
657	683	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
658	684	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
659	685	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	686	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
660	687
661	688	var r: PartialInst = undefined;
662	689	r = PartialInst.Compiled;
...	...	@@ -685,6 +712,7 @@ const PartialInstWithPayload = union(enum) {
685	712
686	713	test "union with only 1 field casted to its enum type which has enum value specified" {
687	714	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	715	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
688	716
689	717	const Literal = union(enum) {
690	718	Number: f64,
...	...	@@ -711,6 +739,7 @@ test "@enumToInt works on unions" {
711	739	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
712	740	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
713	741	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	742	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
714	743
715	744	const Bar = union(enum) {
716	745	A: bool,
...	...	@@ -770,6 +799,7 @@ test "return union init with void payload" {
770	799	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
771	800	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
772	801	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	802	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
773	803
774	804	const S = struct {
775	805	fn entry() !void {
...	...	@@ -796,6 +826,7 @@ test "@unionInit stored to a const" {
796	826	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
797	827	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
798	828	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	829	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
799	830
800	831	const S = struct {
801	832	const U = union(enum) {
...	...	@@ -824,6 +855,7 @@ test "@unionInit can modify a union type" {
824	855	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
825	856	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
826	857	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	858	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
827	859
828	860	const UnionInitEnum = union(enum) {
829	861	Boolean: bool,
...	...	@@ -847,6 +879,7 @@ test "@unionInit can modify a pointer value" {
847	879	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
848	880	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
849	881	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	882	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
850	883
851	884	const UnionInitEnum = union(enum) {
852	885	Boolean: bool,
...	...	@@ -867,6 +900,7 @@ test "union no tag with struct member" {
867	900	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
868	901	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
869	902	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	903	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
870	904
871	905	const Struct = struct {};
872	906	const Union = union {
...	...	@@ -902,6 +936,7 @@ test "anonymous union literal syntax" {
902	936	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
903	937	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
904	938	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	939	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
905	940
906	941	const S = struct {
907	942	const Number = union {
...	...	@@ -928,6 +963,7 @@ test "function call result coerces from tagged union to the tag" {
928	963	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
929	964	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
930	965	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	966	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
931	967
932	968	const S = struct {
933	969	const Arch = union(enum) {
...	...	@@ -963,6 +999,7 @@ test "cast from anonymous struct to union" {
963	999	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
964	1000	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
965	1001	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	1002	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
966	1003
967	1004	const S = struct {
968	1005	const U = union(enum) {
...	...	@@ -996,6 +1033,7 @@ test "cast from pointer to anonymous struct to pointer to union" {
996	1033	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
997	1034	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
998	1035	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	1036	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
999	1037
1000	1038	const S = struct {
1001	1039	const U = union(enum) {
...	...	@@ -1027,6 +1065,7 @@ test "switching on non exhaustive union" {
1027	1065	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1028	1066	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1029	1067	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	1068	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1030	1069
1031	1070	const S = struct {
1032	1071	const E = enum(u8) {
...	...	@@ -1054,6 +1093,7 @@ test "containers with single-field enums" {
1054	1093	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1055	1094	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1056	1095	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	1096	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1057	1097
1058	1098	const S = struct {
1059	1099	const A = union(enum) { f1 };
...	...	@@ -1083,6 +1123,7 @@ test "@unionInit on union with tag but no fields" {
1083	1123	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1084	1124	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
1085	1125	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	1126	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1086	1127
1087	1128	const S = struct {
1088	1129	const Type = enum(u8) { no_op = 105 };
...	...	@@ -1132,6 +1173,7 @@ test "global variable struct contains union initialized to non-most-aligned fiel
1132	1173	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1133	1174	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1134	1175	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	1176	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1135	1177
1136	1178	const T = struct {
1137	1179	const U = union(enum) {
...	...	@@ -1159,6 +1201,7 @@ test "union with no result loc initiated with a runtime value" {
1159	1201	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1160	1202	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
1161	1203	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	1204	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1162	1205
1163	1206	const U = union {
1164	1207	a: u32,
...	...	@@ -1176,6 +1219,7 @@ test "union with a large struct field" {
1176	1219	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1177	1220	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
1178	1221	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	1222	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1179	1223
1180	1224	const S = struct {
1181	1225	a: [8]usize,
...	...	@@ -1209,6 +1253,7 @@ test "union tag is set when initiated as a temporary value at runtime" {
1209	1253	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1210	1254	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1211	1255	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	1256	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1212	1257
1213	1258	const U = union(enum) {
1214	1259	a,
...	...	@@ -1227,6 +1272,7 @@ test "extern union most-aligned field is smaller" {
1227	1272	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1228	1273	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1229	1274	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	1275	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1230	1276
1231	1277	const U = extern union {
1232	1278	in6: extern struct {
...	...	@@ -1246,6 +1292,7 @@ test "return an extern union from C calling convention" {
1246	1292	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1247	1293	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1248	1294	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	1295	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1249	1296
1250	1297	const namespace = struct {
1251	1298	const S = extern struct {
...	...	@@ -1276,6 +1323,7 @@ test "noreturn field in union" {
1276	1323	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1277	1324	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1278	1325	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	1326	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1279	1327
1280	1328	const U = union(enum) {
1281	1329	a: u32,
...	...	@@ -1327,6 +1375,7 @@ test "union and enum field order doesn't match" {
1327	1375	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1328	1376	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1329	1377	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	1378	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1330	1379
1331	1380	const MyTag = enum(u32) {
1332	1381	b = 1337,
...	...	@@ -1353,6 +1402,7 @@ test "@unionInit uses tag value instead of field index" {
1353	1402	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1354	1403	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
1355	1404	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	1405	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1356	1406
1357	1407	const E = enum(u8) {
1358	1408	b = 255,
...	...	@@ -1379,6 +1429,7 @@ test "union field ptr - zero sized payload" {
1379	1429	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1380	1430	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1381	1431	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	1432	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1382	1433
1383	1434	const U = union {
1384	1435	foo: void,
...	...	@@ -1393,6 +1444,7 @@ test "union field ptr - zero sized field" {
1393	1444	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1394	1445	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1395	1446	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	1447	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1396	1448
1397	1449	const U = union {
1398	1450	foo: void,
...	...	@@ -1408,6 +1460,7 @@ test "packed union in packed struct" {
1408	1460	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1409	1461	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
1410	1462	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	1463	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1411	1464
1412	1465	const S = packed struct {
1413	1466	nested: packed union {
...	...	@@ -1425,6 +1478,8 @@ test "packed union in packed struct" {
1425	1478	}
1426	1479
1427	1480	test "Namespace-like union" {
	1481	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1482
1428	1483	const DepType = enum {
1429	1484	git,
1430	1485	http,
...	...	@@ -1458,6 +1513,7 @@ test "union int tag type is properly managed" {
1458	1513	test "no dependency loop when function pointer in union returns the union" {
1459	1514	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1460	1515	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	1516	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1461	1517
1462	1518	const U = union(enum) {
1463	1519	const U = @This();
...	...	@@ -1478,6 +1534,7 @@ test "no dependency loop when function pointer in union returns the union" {
1478	1534	test "union reassignment can use previous value" {
1479	1535	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1480	1536	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	1537	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1481	1538
1482	1539	const U = union {
1483	1540	a: u32,
...	...	@@ -1493,6 +1550,7 @@ test "packed union with zero-bit field" {
1493	1550	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1494	1551	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
1495	1552	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	1553	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1496	1554
1497	1555	const S = packed struct {
1498	1556	nested: packed union {
...	...	@@ -1512,6 +1570,7 @@ test "reinterpreting enum value inside packed union" {
1512	1570	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1513	1571	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1514	1572	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
	1573	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1515	1574
1516	1575	const U = packed union {
1517	1576	tag: enum { a, b },
...	...	@@ -1529,6 +1588,7 @@ test "reinterpreting enum value inside packed union" {
1529	1588
1530	1589	test "access the tag of a global tagged union" {
1531	1590	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	1591	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1532	1592
1533	1593	const U = union(enum) {
1534	1594	a,
...	...	@@ -1540,6 +1600,7 @@ test "access the tag of a global tagged union" {
1540	1600
1541	1601	test "coerce enum literal to union in result loc" {
1542	1602	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	1603	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1543	1604
1544	1605	const U = union(enum) {
1545	1606	a,

test/behavior/union_with_members.zig+1

...	...	@@ -21,6 +21,7 @@ test "enum with members" {
21	21	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
22	22	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
23	23	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	24	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
24	25
25	26	const a = ET{ .SINT = -42 };
26	27	const b = ET{ .UINT = 42 };

test/behavior/usingnamespace.zig+1

...	...	@@ -55,6 +55,7 @@ usingnamespace @import("usingnamespace/a.zig");
55	55	test "two files usingnamespace import each other" {
56	56	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
57	57	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	58	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
58	59
59	60	try expect(@This().ok());
60	61	}

test/behavior/var_args.zig+8

...	...	@@ -14,6 +14,8 @@ fn add(args: anytype) i32 {
14	14	}
15	15
16	16	test "add arbitrary args" {
	17	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	18
17	19	try expect(add(.{ @as(i32, 1), @as(i32, 2), @as(i32, 3), @as(i32, 4) }) == 10);
18	20	try expect(add(.{@as(i32, 1234)}) == 1234);
19	21	try expect(add(.{}) == 0);
...	...	@@ -30,6 +32,7 @@ test "send void arg to var args" {
30	32	test "pass args directly" {
31	33	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
32	34	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	35	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
33	36
34	37	try expect(addSomeStuff(.{ @as(i32, 1), @as(i32, 2), @as(i32, 3), @as(i32, 4) }) == 10);
35	38	try expect(addSomeStuff(.{@as(i32, 1234)}) == 1234);
...	...	@@ -43,6 +46,7 @@ fn addSomeStuff(args: anytype) i32 {
43	46	test "runtime parameter before var args" {
44	47	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
45	48	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	49	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
46	50
47	51	try expect((try extraFn(10, .{})) == 0);
48	52	try expect((try extraFn(10, .{false})) == 1);
...	...	@@ -99,6 +103,7 @@ test "simple variadic function" {
99	103	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
100	104	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
101	105	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
	106	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
102	107	if (builtin.cpu.arch == .aarch64 and builtin.os.tag != .macos) {
103	108	// https://github.com/ziglang/zig/issues/14096
104	109	return error.SkipZigTest;
...	...	@@ -148,6 +153,7 @@ test "variadic functions" {
148	153	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
149	154	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
150	155	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
	156	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
151	157	if (builtin.cpu.arch == .aarch64 and builtin.os.tag != .macos) {
152	158	// https://github.com/ziglang/zig/issues/14096
153	159	return error.SkipZigTest;
...	...	@@ -191,6 +197,7 @@ test "copy VaList" {
191	197	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
192	198	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
193	199	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
	200	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
194	201	if (builtin.cpu.arch == .aarch64 and builtin.os.tag != .macos) {
195	202	// https://github.com/ziglang/zig/issues/14096
196	203	return error.SkipZigTest;
...	...	@@ -223,6 +230,7 @@ test "unused VaList arg" {
223	230	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
224	231	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
225	232	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
	233	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
226	234	if (builtin.cpu.arch == .aarch64 and builtin.os.tag != .macos) {
227	235	// https://github.com/ziglang/zig/issues/14096
228	236	return error.SkipZigTest;

test/behavior/vector.zig+43

...	...	@@ -11,6 +11,7 @@ test "implicit cast vector to array - bool" {
11	11	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
12	12	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
13	13	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	14	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
14	15
15	16	const S = struct {
16	17	fn doTheTest() !void {
...	...	@@ -29,6 +30,7 @@ test "vector wrap operators" {
29	30	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
30	31	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
31	32	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	33	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
32	34
33	35	const S = struct {
34	36	fn doTheTest() !void {
...	...	@@ -51,6 +53,7 @@ test "vector bin compares with mem.eql" {
51	53	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
52	54	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
53	55	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	56	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
54	57
55	58	const S = struct {
56	59	fn doTheTest() !void {
...	...	@@ -74,6 +77,7 @@ test "vector int operators" {
74	77	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
75	78	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
76	79	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	80	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
77	81
78	82	const S = struct {
79	83	fn doTheTest() !void {
...	...	@@ -95,6 +99,7 @@ test "vector float operators" {
95	99	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
96	100	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
97	101	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	102	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
98	103
99	104	inline for ([_]type{ f16, f32, f64, f80, f128 }) \|T\| {
100	105	const S = struct {
...	...	@@ -118,6 +123,7 @@ test "vector bit operators" {
118	123	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
119	124	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
120	125	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	126	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
121	127
122	128	const S = struct {
123	129	fn doTheTest() !void {
...	...	@@ -136,6 +142,7 @@ test "implicit cast vector to array" {
136	142	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
137	143	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
138	144	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	145	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
139	146
140	147	const S = struct {
141	148	fn doTheTest() !void {
...	...	@@ -153,6 +160,7 @@ test "array to vector" {
153	160	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
154	161	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
155	162	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	163	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
156	164
157	165	const S = struct {
158	166	fn doTheTest() !void {
...	...	@@ -173,6 +181,7 @@ test "array to vector with element type coercion" {
173	181	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
174	182	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
175	183	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	184	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
176	185
177	186	const S = struct {
178	187	fn doTheTest() !void {
...	...	@@ -192,6 +201,7 @@ test "peer type resolution with coercible element types" {
192	201	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
193	202	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
194	203	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	204	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
195	205
196	206	const S = struct {
197	207	fn doTheTest() !void {
...	...	@@ -211,6 +221,7 @@ test "tuple to vector" {
211	221	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
212	222	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
213	223	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	224	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
214	225
215	226	if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .aarch64) {
216	227	// Regressed with LLVM 14:
...	...	@@ -240,6 +251,7 @@ test "vector casts of sizes not divisible by 8" {
240	251	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
241	252	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
242	253	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	254	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
243	255
244	256	const S = struct {
245	257	fn doTheTest() !void {
...	...	@@ -274,6 +286,7 @@ test "vector @splat" {
274	286	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
275	287	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
276	288	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	289	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
277	290
278	291	if (builtin.zig_backend == .stage2_llvm and
279	292	builtin.os.tag == .macos)
...	...	@@ -320,6 +333,7 @@ test "load vector elements via comptime index" {
320	333	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
321	334	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
322	335	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	336	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
323	337
324	338	const S = struct {
325	339	fn doTheTest() !void {
...	...	@@ -341,6 +355,7 @@ test "store vector elements via comptime index" {
341	355	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
342	356	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
343	357	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	358	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
344	359
345	360	const S = struct {
346	361	fn doTheTest() !void {
...	...	@@ -368,6 +383,7 @@ test "load vector elements via runtime index" {
368	383	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
369	384	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
370	385	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	386	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
371	387
372	388	const S = struct {
373	389	fn doTheTest() !void {
...	...	@@ -389,6 +405,7 @@ test "store vector elements via runtime index" {
389	405	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
390	406	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
391	407	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	408	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
392	409
393	410	const S = struct {
394	411	fn doTheTest() !void {
...	...	@@ -411,6 +428,7 @@ test "initialize vector which is a struct field" {
411	428	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
412	429	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
413	430	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	431	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
414	432
415	433	const Vec4Obj = struct {
416	434	data: @Vector(4, f32),
...	...	@@ -434,6 +452,7 @@ test "vector comparison operators" {
434	452	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
435	453	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
436	454	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	455	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
437	456
438	457	const S = struct {
439	458	fn doTheTest() !void {
...	...	@@ -474,6 +493,7 @@ test "vector division operators" {
474	493	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
475	494	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
476	495	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	496	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
477	497
478	498	const S = struct {
479	499	fn doTheTestDiv(comptime T: type, x: @Vector(4, T), y: @Vector(4, T)) !void {
...	...	@@ -556,6 +576,7 @@ test "vector bitwise not operator" {
556	576	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
557	577	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
558	578	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	579	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
559	580
560	581	const S = struct {
561	582	fn doTheTestNot(comptime T: type, x: @Vector(4, T)) !void {
...	...	@@ -587,6 +608,7 @@ test "vector shift operators" {
587	608	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
588	609	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
589	610	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	611	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
590	612
591	613	const S = struct {
592	614	fn doTheTestShift(x: anytype, y: anytype) !void {
...	...	@@ -680,6 +702,7 @@ test "vector reduce operation" {
680	702	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
681	703	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
682	704	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	705	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
683	706
684	707	const S = struct {
685	708	fn testReduce(comptime op: std.builtin.ReduceOp, x: anytype, expected: anytype) !void {
...	...	@@ -837,6 +860,7 @@ test "mask parameter of @shuffle is comptime scope" {
837	860	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
838	861	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
839	862	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	863	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
840	864
841	865	const __v4hi = @Vector(4, i16);
842	866	var v4_a = __v4hi{ 0, 0, 0, 0 };
...	...	@@ -856,6 +880,7 @@ test "saturating add" {
856	880	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
857	881	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
858	882	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	883	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
859	884
860	885	const S = struct {
861	886	fn doTheTest() !void {
...	...	@@ -887,6 +912,7 @@ test "saturating subtraction" {
887	912	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
888	913	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
889	914	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	915	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
890	916
891	917	const S = struct {
892	918	fn doTheTest() !void {
...	...	@@ -909,6 +935,7 @@ test "saturating multiplication" {
909	935	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
910	936	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
911	937	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	938	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
912	939
913	940	// TODO: once #9660 has been solved, remove this line
914	941	if (builtin.target.cpu.arch == .wasm32) return error.SkipZigTest;
...	...	@@ -935,6 +962,7 @@ test "saturating shift-left" {
935	962	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
936	963	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
937	964	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	965	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
938	966
939	967	const S = struct {
940	968	fn doTheTest() !void {
...	...	@@ -957,6 +985,7 @@ test "multiplication-assignment operator with an array operand" {
957	985	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
958	986	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
959	987	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	988	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
960	989
961	990	const S = struct {
962	991	fn doTheTest() !void {
...	...	@@ -977,6 +1006,7 @@ test "@addWithOverflow" {
977	1006	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
978	1007	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
979	1008	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	1009	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
980	1010
981	1011	const S = struct {
982	1012	fn doTheTest() !void {
...	...	@@ -1020,6 +1050,7 @@ test "@subWithOverflow" {
1020	1050	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1021	1051	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1022	1052	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	1053	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1023	1054
1024	1055	const S = struct {
1025	1056	fn doTheTest() !void {
...	...	@@ -1049,6 +1080,7 @@ test "@mulWithOverflow" {
1049	1080	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1050	1081	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1051	1082	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	1083	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1052	1084
1053	1085	const S = struct {
1054	1086	fn doTheTest() !void {
...	...	@@ -1069,6 +1101,7 @@ test "@shlWithOverflow" {
1069	1101	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1070	1102	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1071	1103	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	1104	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1072	1105
1073	1106	const S = struct {
1074	1107	fn doTheTest() !void {
...	...	@@ -1095,6 +1128,7 @@ test "loading the second vector from a slice of vectors" {
1095	1128	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1096	1129	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1097	1130	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	1131	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1098	1132	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
1099	1133
1100	1134	@setRuntimeSafety(false);
...	...	@@ -1113,6 +1147,7 @@ test "array of vectors is copied" {
1113	1147	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1114	1148	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1115	1149	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	1150	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1116	1151
1117	1152	const Vec3 = @Vector(3, i32);
1118	1153	var points = [_]Vec3{
...	...	@@ -1136,6 +1171,7 @@ test "byte vector initialized in inline function" {
1136	1171	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1137	1172	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1138	1173	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	1174	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1139	1175
1140	1176	if (comptime builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .x86_64 and
1141	1177	builtin.cpu.features.isEnabled(@enumToInt(std.Target.x86.Feature.avx512f)))
...	...	@@ -1182,6 +1218,7 @@ test "zero multiplicand" {
1182	1218	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1183	1219	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1184	1220	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	1221	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1185	1222	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
1186	1223
1187	1224	const zeros = @Vector(2, u32){ 0.0, 0.0 };
...	...	@@ -1206,6 +1243,7 @@ test "@intCast to u0" {
1206	1243	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1207	1244	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1208	1245	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	1246	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1209	1247
1210	1248	var zeros = @Vector(2, u32){ 0, 0 };
1211	1249	const casted = @intCast(@Vector(2, u0), zeros);
...	...	@@ -1229,6 +1267,7 @@ test "array operands to shuffle are coerced to vectors" {
1229	1267	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1230	1268	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1231	1269	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	1270	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1232	1271
1233	1272	const mask = [5]i32{ -1, 0, 1, 2, 3 };
1234	1273
...	...	@@ -1241,6 +1280,7 @@ test "load packed vector element" {
1241	1280	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1242	1281	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1243	1282	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	1283	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1244	1284	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
1245	1285	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
1246	1286
...	...	@@ -1253,6 +1293,7 @@ test "store packed vector element" {
1253	1293	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1254	1294	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1255	1295	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	1296	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1256	1297	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
1257	1298	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
1258	1299
...	...	@@ -1268,6 +1309,7 @@ test "store to vector in slice" {
1268	1309	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
1269	1310	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
1270	1311	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	1312	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1271	1313
1272	1314	var v = [_]@Vector(3, f32){
1273	1315	.{ 1, 1, 1 },
...	...	@@ -1283,6 +1325,7 @@ test "addition of vectors represented as strings" {
1283	1325	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1284	1326	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1285	1327	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
	1328	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1286	1329
1287	1330	const V = @Vector(3, u8);
1288	1331	const foo: V = "foo".*;

test/behavior/void.zig+2

...	...	@@ -20,6 +20,7 @@ test "compare void with void compile time known" {
20	20
21	21	test "iterate over a void slice" {
22	22	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	23	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
23	24
24	25	var j: usize = 0;
25	26	for (times(10), 0..) \|_, i\| {
...	...	@@ -36,6 +37,7 @@ test "void optional" {
36	37	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
37	38	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
38	39	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	40	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
39	41
40	42	var x: ?void = {};
41	43	try expect(x != null);

test/behavior/while.zig+20

...	...	@@ -5,6 +5,7 @@ const assert = std.debug.assert;
5	5
6	6	test "while loop" {
7	7	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	8	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
8	9
9	10	var i: i32 = 0;
10	11	while (i < 4) {
...	...	@@ -38,6 +39,8 @@ fn staticWhileLoop2() i32 {
38	39	}
39	40
40	41	test "while with continue expression" {
	42	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	43
41	44	var sum: i32 = 0;
42	45	{
43	46	var i: i32 = 0;
...	...	@@ -50,6 +53,8 @@ test "while with continue expression" {
50	53	}
51	54
52	55	test "while with else" {
	56	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	57
53	58	var sum: i32 = 0;
54	59	var i: i32 = 0;
55	60	var got_else: i32 = 0;
...	...	@@ -77,6 +82,8 @@ fn getNumberOrNull() ?i32 {
77	82	}
78	83
79	84	test "continue outer while loop" {
	85	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	86
80	87	testContinueOuter();
81	88	comptime testContinueOuter();
82	89	}
...	...	@@ -123,6 +130,7 @@ test "while copies its payload" {
123	130
124	131	test "continue and break" {
125	132	if (builtin.zig_backend == .stage2_aarch64 and builtin.os.tag == .macos) return error.SkipZigTest;
	133	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
126	134
127	135	try runContinueAndBreakTest();
128	136	try expect(continue_and_break_counter == 8);
...	...	@@ -144,6 +152,7 @@ fn runContinueAndBreakTest() !void {
144	152	test "while with optional as condition" {
145	153	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
146	154	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	155	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
147	156
148	157	numbers_left = 10;
149	158	var sum: i32 = 0;
...	...	@@ -156,6 +165,7 @@ test "while with optional as condition" {
156	165	test "while with optional as condition with else" {
157	166	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
158	167	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	168	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
159	169
160	170	numbers_left = 10;
161	171	var sum: i32 = 0;
...	...	@@ -172,6 +182,7 @@ test "while with optional as condition with else" {
172	182
173	183	test "while with error union condition" {
174	184	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	185	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
175	186
176	187	numbers_left = 10;
177	188	var sum: i32 = 0;
...	...	@@ -215,6 +226,7 @@ test "while on optional with else result follow break prong" {
215	226	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
216	227	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
217	228	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	229	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
218	230
219	231	const result = while (returnOptional(10)) \|value\| {
220	232	break value;
...	...	@@ -242,6 +254,8 @@ fn returnTrue() bool {
242	254	}
243	255
244	256	test "return with implicit cast from while loop" {
	257	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	258
245	259	returnWithImplicitCastFromWhileLoopTest() catch unreachable;
246	260	}
247	261	fn returnWithImplicitCastFromWhileLoopTest() anyerror!void {
...	...	@@ -252,6 +266,7 @@ fn returnWithImplicitCastFromWhileLoopTest() anyerror!void {
252	266
253	267	test "while on error union with else result follow else prong" {
254	268	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	269	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
255	270
256	271	const result = while (returnError()) \|value\| {
257	272	break value;
...	...	@@ -261,6 +276,7 @@ test "while on error union with else result follow else prong" {
261	276
262	277	test "while on error union with else result follow break prong" {
263	278	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	279	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
264	280
265	281	const result = while (returnSuccess(10)) \|value\| {
266	282	break value;
...	...	@@ -306,6 +322,7 @@ test "while error 2 break statements and an else" {
306	322	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
307	323	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
308	324	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	325	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
309	326
310	327	const S = struct {
311	328	fn entry(opt_t: anyerror!bool, f: bool) !void {
...	...	@@ -331,6 +348,8 @@ test "continue inline while loop" {
331	348	}
332	349
333	350	test "else continue outer while" {
	351	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	352
334	353	var i: usize = 0;
335	354	while (true) {
336	355	i += 1;
...	...	@@ -343,6 +362,7 @@ test "else continue outer while" {
343	362	test "try terminating an infinite loop" {
344	363	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
345	364	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	365	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
346	366
347	367	// Test coverage for https://github.com/ziglang/zig/issues/13546
348	368	const Foo = struct {

test/behavior/widening.zig+7

...	...	@@ -9,6 +9,7 @@ test "integer widening" {
9	9	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
10	10	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
11	11	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	12	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
12	13
13	14	var a: u8 = 250;
14	15	var b: u16 = a;
...	...	@@ -23,6 +24,8 @@ fn zero() u0 {
23	24	return 0;
24	25	}
25	26	test "integer widening u0 to u8" {
	27	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	28
26	29	const a: u8 = zero();
27	30	try expect(a == 0);
28	31	}
...	...	@@ -30,6 +33,7 @@ test "integer widening u0 to u8" {
30	33	test "implicit unsigned integer to signed integer" {
31	34	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
32	35	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	36	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
33	37
34	38	var a: u8 = 250;
35	39	var b: i16 = a;
...	...	@@ -42,6 +46,7 @@ test "float widening" {
42	46	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
43	47	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
44	48	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	49	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
45	50
46	51	var a: f16 = 12.34;
47	52	var b: f32 = a;
...	...	@@ -62,6 +67,7 @@ test "float widening f16 to f128" {
62	67	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
63	68	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
64	69	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	70	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
65	71
66	72	var x: f16 = 12.34;
67	73	var y: f128 = x;
...	...	@@ -72,6 +78,7 @@ test "cast small unsigned to larger signed" {
72	78	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
73	79	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
74	80	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	81	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
75	82
76	83	try expect(castSmallUnsignedToLargerSigned1(200) == @as(i16, 200));
77	84	try expect(castSmallUnsignedToLargerSigned2(9999) == @as(i64, 9999));