Commit 8400163e0245f68833e29db22ae3bcc1fb8bf9ae | zig

author	Andrew Kelley <andrew@ziglang.org> 2018-09-05 18:42:56-04:00
committer	Andrew Kelley <andrew@ziglang.org> 2018-09-05 18:42:56-04:00
log	8400163e0245f68833e29db22ae3bcc1fb8bf9ae
tree	5eb0d4463b2437534963159147b16af5a120ce44
parent	1f5c7ff4d7360f83f83f422adf167df5d756e3b4
signature	Commit is signed but in an unrecognized format.

stage1: rename more TypeTableEntry types to ZigType

4 files changed, 1920 insertions(+), 1920 deletions(-)

src/all_types.hpp+52-52

...	...	@@ -1004,7 +1004,7 @@ enum PtrLen {
1004	1004	PtrLenSingle,
1005	1005	};
1006	1006
1007		struct TypeTableEntryPointer {
	1007	struct ZigTypePointer {
1008	1008	ZigType *child_type;
1009	1009	PtrLen ptr_len;
1010	1010	bool is_const;
...	...	@@ -1015,16 +1015,16 @@ struct TypeTableEntryPointer {
1015	1015	ZigType *slice_parent;
1016	1016	};
1017	1017
1018		struct TypeTableEntryInt {
	1018	struct ZigTypeInt {
1019	1019	uint32_t bit_count;
1020	1020	bool is_signed;
1021	1021	};
1022	1022
1023		struct TypeTableEntryFloat {
	1023	struct ZigTypeFloat {
1024	1024	size_t bit_count;
1025	1025	};
1026	1026
1027		struct TypeTableEntryArray {
	1027	struct ZigTypeArray {
1028	1028	ZigType *child_type;
1029	1029	uint64_t len;
1030	1030	};
...	...	@@ -1040,7 +1040,7 @@ struct TypeStructField {
1040	1040	size_t unaligned_bit_count;
1041	1041	AstNode *decl_node;
1042	1042	};
1043		struct TypeTableEntryStruct {
	1043	struct ZigTypeStruct {
1044	1044	AstNode *decl_node;
1045	1045	ContainerLayout layout;
1046	1046	uint32_t src_field_count;
...	...	@@ -1068,22 +1068,22 @@ struct TypeTableEntryStruct {
1068	1068	HashMap<Buf , TypeStructField , buf_hash, buf_eql_buf> fields_by_name;
1069	1069	};
1070	1070
1071		struct TypeTableEntryOptional {
	1071	struct ZigTypeOptional {
1072	1072	ZigType *child_type;
1073	1073	};
1074	1074
1075		struct TypeTableEntryErrorUnion {
	1075	struct ZigTypeErrorUnion {
1076	1076	ZigType *err_set_type;
1077	1077	ZigType *payload_type;
1078	1078	};
1079	1079
1080		struct TypeTableEntryErrorSet {
	1080	struct ZigTypeErrorSet {
1081	1081	uint32_t err_count;
1082	1082	ErrorTableEntry **errors;
1083	1083	ZigFn *infer_fn;
1084	1084	};
1085	1085
1086		struct TypeTableEntryEnum {
	1086	struct ZigTypeEnum {
1087	1087	AstNode *decl_node;
1088	1088	ContainerLayout layout;
1089	1089	uint32_t src_field_count;
...	...	@@ -1110,7 +1110,7 @@ struct TypeTableEntryEnum {
1110	1110	uint32_t type_ptr_hash(const ZigType *ptr);
1111	1111	bool type_ptr_eql(const ZigType a, const ZigType b);
1112	1112
1113		struct TypeTableEntryUnion {
	1113	struct ZigTypeUnion {
1114	1114	AstNode *decl_node;
1115	1115	ContainerLayout layout;
1116	1116	uint32_t src_field_count;
...	...	@@ -1154,7 +1154,7 @@ struct FnGenParamInfo {
1154	1154	ZigType *type;
1155	1155	};
1156	1156
1157		struct TypeTableEntryFn {
	1157	struct ZigTypeFn {
1158	1158	FnTypeId fn_type_id;
1159	1159	bool is_generic;
1160	1160	ZigType *gen_return_type;
...	...	@@ -1166,42 +1166,42 @@ struct TypeTableEntryFn {
1166	1166	ZigType *bound_fn_parent;
1167	1167	};
1168	1168
1169		struct TypeTableEntryBoundFn {
	1169	struct ZigTypeBoundFn {
1170	1170	ZigType *fn_type;
1171	1171	};
1172	1172
1173		struct TypeTableEntryPromise {
	1173	struct ZigTypePromise {
1174	1174	// null if `promise` instead of `promise->T`
1175	1175	ZigType *result_type;
1176	1176	};
1177	1177
1178	1178	enum ZigTypeId {
1179		TypeTableEntryIdInvalid,
1180		TypeTableEntryIdMetaType,
1181		TypeTableEntryIdVoid,
1182		TypeTableEntryIdBool,
1183		TypeTableEntryIdUnreachable,
1184		TypeTableEntryIdInt,
1185		TypeTableEntryIdFloat,
1186		TypeTableEntryIdPointer,
1187		TypeTableEntryIdArray,
1188		TypeTableEntryIdStruct,
1189		TypeTableEntryIdComptimeFloat,
1190		TypeTableEntryIdComptimeInt,
1191		TypeTableEntryIdUndefined,
1192		TypeTableEntryIdNull,
1193		TypeTableEntryIdOptional,
1194		TypeTableEntryIdErrorUnion,
1195		TypeTableEntryIdErrorSet,
1196		TypeTableEntryIdEnum,
1197		TypeTableEntryIdUnion,
1198		TypeTableEntryIdFn,
1199		TypeTableEntryIdNamespace,
1200		TypeTableEntryIdBlock,
1201		TypeTableEntryIdBoundFn,
1202		TypeTableEntryIdArgTuple,
1203		TypeTableEntryIdOpaque,
1204		TypeTableEntryIdPromise,
	1179	ZigTypeIdInvalid,
	1180	ZigTypeIdMetaType,
	1181	ZigTypeIdVoid,
	1182	ZigTypeIdBool,
	1183	ZigTypeIdUnreachable,
	1184	ZigTypeIdInt,
	1185	ZigTypeIdFloat,
	1186	ZigTypeIdPointer,
	1187	ZigTypeIdArray,
	1188	ZigTypeIdStruct,
	1189	ZigTypeIdComptimeFloat,
	1190	ZigTypeIdComptimeInt,
	1191	ZigTypeIdUndefined,
	1192	ZigTypeIdNull,
	1193	ZigTypeIdOptional,
	1194	ZigTypeIdErrorUnion,
	1195	ZigTypeIdErrorSet,
	1196	ZigTypeIdEnum,
	1197	ZigTypeIdUnion,
	1198	ZigTypeIdFn,
	1199	ZigTypeIdNamespace,
	1200	ZigTypeIdBlock,
	1201	ZigTypeIdBoundFn,
	1202	ZigTypeIdArgTuple,
	1203	ZigTypeIdOpaque,
	1204	ZigTypeIdPromise,
1205	1205	};
1206	1206
1207	1207	struct ZigType {
...	...	@@ -1216,19 +1216,19 @@ struct ZigType {
1216	1216	bool gen_h_loop_flag;
1217	1217
1218	1218	union {
1219		TypeTableEntryPointer pointer;
1220		TypeTableEntryInt integral;
1221		TypeTableEntryFloat floating;
1222		TypeTableEntryArray array;
1223		TypeTableEntryStruct structure;
1224		TypeTableEntryOptional maybe;
1225		TypeTableEntryErrorUnion error_union;
1226		TypeTableEntryErrorSet error_set;
1227		TypeTableEntryEnum enumeration;
1228		TypeTableEntryUnion unionation;
1229		TypeTableEntryFn fn;
1230		TypeTableEntryBoundFn bound_fn;
1231		TypeTableEntryPromise promise;
	1219	ZigTypePointer pointer;
	1220	ZigTypeInt integral;
	1221	ZigTypeFloat floating;
	1222	ZigTypeArray array;
	1223	ZigTypeStruct structure;
	1224	ZigTypeOptional maybe;
	1225	ZigTypeErrorUnion error_union;
	1226	ZigTypeErrorSet error_set;
	1227	ZigTypeEnum enumeration;
	1228	ZigTypeUnion unionation;
	1229	ZigTypeFn fn;
	1230	ZigTypeBoundFn bound_fn;
	1231	ZigTypePromise promise;
1232	1232	} data;
1233	1233
1234	1234	// use these fields to make sure we don't duplicate type table entries for the same type

src/analyze.cpp+695-695

...	...	@@ -77,11 +77,11 @@ ZigType *new_type_table_entry(ZigTypeId id) {
77	77	}
78	78
79	79	static ScopeDecls *get_container_scope_ptr(ZigType type_entry) {
80		if (type_entry->id == TypeTableEntryIdStruct) {
	80	if (type_entry->id == ZigTypeIdStruct) {
81	81	return &type_entry->data.structure.decls_scope;
82		} else if (type_entry->id == TypeTableEntryIdEnum) {
	82	} else if (type_entry->id == ZigTypeIdEnum) {
83	83	return &type_entry->data.enumeration.decls_scope;
84		} else if (type_entry->id == TypeTableEntryIdUnion) {
	84	} else if (type_entry->id == ZigTypeIdUnion) {
85	85	return &type_entry->data.unionation.decls_scope;
86	86	}
87	87	zig_unreachable();
...	...	@@ -220,36 +220,36 @@ static uint8_t bits_needed_for_unsigned(uint64_t x) {
220	220
221	221	AstNode type_decl_node(ZigType type_entry) {
222	222	switch (type_entry->id) {
223		case TypeTableEntryIdInvalid:
	223	case ZigTypeIdInvalid:
224	224	zig_unreachable();
225		case TypeTableEntryIdStruct:
	225	case ZigTypeIdStruct:
226	226	return type_entry->data.structure.decl_node;
227		case TypeTableEntryIdEnum:
	227	case ZigTypeIdEnum:
228	228	return type_entry->data.enumeration.decl_node;
229		case TypeTableEntryIdUnion:
	229	case ZigTypeIdUnion:
230	230	return type_entry->data.unionation.decl_node;
231		case TypeTableEntryIdOpaque:
232		case TypeTableEntryIdMetaType:
233		case TypeTableEntryIdVoid:
234		case TypeTableEntryIdBool:
235		case TypeTableEntryIdUnreachable:
236		case TypeTableEntryIdInt:
237		case TypeTableEntryIdFloat:
238		case TypeTableEntryIdPointer:
239		case TypeTableEntryIdArray:
240		case TypeTableEntryIdComptimeFloat:
241		case TypeTableEntryIdComptimeInt:
242		case TypeTableEntryIdUndefined:
243		case TypeTableEntryIdNull:
244		case TypeTableEntryIdOptional:
245		case TypeTableEntryIdErrorUnion:
246		case TypeTableEntryIdErrorSet:
247		case TypeTableEntryIdFn:
248		case TypeTableEntryIdNamespace:
249		case TypeTableEntryIdBlock:
250		case TypeTableEntryIdBoundFn:
251		case TypeTableEntryIdArgTuple:
252		case TypeTableEntryIdPromise:
	231	case ZigTypeIdOpaque:
	232	case ZigTypeIdMetaType:
	233	case ZigTypeIdVoid:
	234	case ZigTypeIdBool:
	235	case ZigTypeIdUnreachable:
	236	case ZigTypeIdInt:
	237	case ZigTypeIdFloat:
	238	case ZigTypeIdPointer:
	239	case ZigTypeIdArray:
	240	case ZigTypeIdComptimeFloat:
	241	case ZigTypeIdComptimeInt:
	242	case ZigTypeIdUndefined:
	243	case ZigTypeIdNull:
	244	case ZigTypeIdOptional:
	245	case ZigTypeIdErrorUnion:
	246	case ZigTypeIdErrorSet:
	247	case ZigTypeIdFn:
	248	case ZigTypeIdNamespace:
	249	case ZigTypeIdBlock:
	250	case ZigTypeIdBoundFn:
	251	case ZigTypeIdArgTuple:
	252	case ZigTypeIdPromise:
253	253	return nullptr;
254	254	}
255	255	zig_unreachable();
...	...	@@ -257,37 +257,37 @@ AstNode type_decl_node(ZigType type_entry) {
257	257
258	258	bool type_is_complete(ZigType *type_entry) {
259	259	switch (type_entry->id) {
260		case TypeTableEntryIdInvalid:
	260	case ZigTypeIdInvalid:
261	261	zig_unreachable();
262		case TypeTableEntryIdStruct:
	262	case ZigTypeIdStruct:
263	263	return type_entry->data.structure.complete;
264		case TypeTableEntryIdEnum:
	264	case ZigTypeIdEnum:
265	265	return type_entry->data.enumeration.complete;
266		case TypeTableEntryIdUnion:
	266	case ZigTypeIdUnion:
267	267	return type_entry->data.unionation.complete;
268		case TypeTableEntryIdOpaque:
	268	case ZigTypeIdOpaque:
269	269	return false;
270		case TypeTableEntryIdMetaType:
271		case TypeTableEntryIdVoid:
272		case TypeTableEntryIdBool:
273		case TypeTableEntryIdUnreachable:
274		case TypeTableEntryIdInt:
275		case TypeTableEntryIdFloat:
276		case TypeTableEntryIdPointer:
277		case TypeTableEntryIdArray:
278		case TypeTableEntryIdComptimeFloat:
279		case TypeTableEntryIdComptimeInt:
280		case TypeTableEntryIdUndefined:
281		case TypeTableEntryIdNull:
282		case TypeTableEntryIdOptional:
283		case TypeTableEntryIdErrorUnion:
284		case TypeTableEntryIdErrorSet:
285		case TypeTableEntryIdFn:
286		case TypeTableEntryIdNamespace:
287		case TypeTableEntryIdBlock:
288		case TypeTableEntryIdBoundFn:
289		case TypeTableEntryIdArgTuple:
290		case TypeTableEntryIdPromise:
	270	case ZigTypeIdMetaType:
	271	case ZigTypeIdVoid:
	272	case ZigTypeIdBool:
	273	case ZigTypeIdUnreachable:
	274	case ZigTypeIdInt:
	275	case ZigTypeIdFloat:
	276	case ZigTypeIdPointer:
	277	case ZigTypeIdArray:
	278	case ZigTypeIdComptimeFloat:
	279	case ZigTypeIdComptimeInt:
	280	case ZigTypeIdUndefined:
	281	case ZigTypeIdNull:
	282	case ZigTypeIdOptional:
	283	case ZigTypeIdErrorUnion:
	284	case ZigTypeIdErrorSet:
	285	case ZigTypeIdFn:
	286	case ZigTypeIdNamespace:
	287	case ZigTypeIdBlock:
	288	case ZigTypeIdBoundFn:
	289	case ZigTypeIdArgTuple:
	290	case ZigTypeIdPromise:
291	291	return true;
292	292	}
293	293	zig_unreachable();
...	...	@@ -295,36 +295,36 @@ bool type_is_complete(ZigType *type_entry) {
295	295
296	296	bool type_has_zero_bits_known(ZigType *type_entry) {
297	297	switch (type_entry->id) {
298		case TypeTableEntryIdInvalid:
	298	case ZigTypeIdInvalid:
299	299	zig_unreachable();
300		case TypeTableEntryIdStruct:
	300	case ZigTypeIdStruct:
301	301	return type_entry->data.structure.zero_bits_known;
302		case TypeTableEntryIdEnum:
	302	case ZigTypeIdEnum:
303	303	return type_entry->data.enumeration.zero_bits_known;
304		case TypeTableEntryIdUnion:
	304	case ZigTypeIdUnion:
305	305	return type_entry->data.unionation.zero_bits_known;
306		case TypeTableEntryIdMetaType:
307		case TypeTableEntryIdVoid:
308		case TypeTableEntryIdBool:
309		case TypeTableEntryIdUnreachable:
310		case TypeTableEntryIdInt:
311		case TypeTableEntryIdFloat:
312		case TypeTableEntryIdPointer:
313		case TypeTableEntryIdArray:
314		case TypeTableEntryIdComptimeFloat:
315		case TypeTableEntryIdComptimeInt:
316		case TypeTableEntryIdUndefined:
317		case TypeTableEntryIdNull:
318		case TypeTableEntryIdOptional:
319		case TypeTableEntryIdErrorUnion:
320		case TypeTableEntryIdErrorSet:
321		case TypeTableEntryIdFn:
322		case TypeTableEntryIdNamespace:
323		case TypeTableEntryIdBlock:
324		case TypeTableEntryIdBoundFn:
325		case TypeTableEntryIdArgTuple:
326		case TypeTableEntryIdOpaque:
327		case TypeTableEntryIdPromise:
	306	case ZigTypeIdMetaType:
	307	case ZigTypeIdVoid:
	308	case ZigTypeIdBool:
	309	case ZigTypeIdUnreachable:
	310	case ZigTypeIdInt:
	311	case ZigTypeIdFloat:
	312	case ZigTypeIdPointer:
	313	case ZigTypeIdArray:
	314	case ZigTypeIdComptimeFloat:
	315	case ZigTypeIdComptimeInt:
	316	case ZigTypeIdUndefined:
	317	case ZigTypeIdNull:
	318	case ZigTypeIdOptional:
	319	case ZigTypeIdErrorUnion:
	320	case ZigTypeIdErrorSet:
	321	case ZigTypeIdFn:
	322	case ZigTypeIdNamespace:
	323	case ZigTypeIdBlock:
	324	case ZigTypeIdBoundFn:
	325	case ZigTypeIdArgTuple:
	326	case ZigTypeIdOpaque:
	327	case ZigTypeIdPromise:
328	328	return true;
329	329	}
330	330	zig_unreachable();
...	...	@@ -337,12 +337,12 @@ uint64_t type_size(CodeGen g, ZigType type_entry) {
337	337	if (!type_has_bits(type_entry))
338	338	return 0;
339	339
340		if (type_entry->id == TypeTableEntryIdStruct && type_entry->data.structure.layout == ContainerLayoutPacked) {
	340	if (type_entry->id == ZigTypeIdStruct && type_entry->data.structure.layout == ContainerLayoutPacked) {
341	341	uint64_t size_in_bits = type_size_bits(g, type_entry);
342	342	return (size_in_bits + 7) / 8;
343		} else if (type_entry->id == TypeTableEntryIdArray) {
	343	} else if (type_entry->id == ZigTypeIdArray) {
344	344	ZigType *child_type = type_entry->data.array.child_type;
345		if (child_type->id == TypeTableEntryIdStruct &&
	345	if (child_type->id == ZigTypeIdStruct &&
346	346	child_type->data.structure.layout == ContainerLayoutPacked)
347	347	{
348	348	uint64_t size_in_bits = type_size_bits(g, type_entry);
...	...	@@ -359,15 +359,15 @@ uint64_t type_size_bits(CodeGen g, ZigType type_entry) {
359	359	if (!type_has_bits(type_entry))
360	360	return 0;
361	361
362		if (type_entry->id == TypeTableEntryIdStruct && type_entry->data.structure.layout == ContainerLayoutPacked) {
	362	if (type_entry->id == ZigTypeIdStruct && type_entry->data.structure.layout == ContainerLayoutPacked) {
363	363	uint64_t result = 0;
364	364	for (size_t i = 0; i < type_entry->data.structure.src_field_count; i += 1) {
365	365	result += type_size_bits(g, type_entry->data.structure.fields[i].type_entry);
366	366	}
367	367	return result;
368		} else if (type_entry->id == TypeTableEntryIdArray) {
	368	} else if (type_entry->id == ZigTypeIdArray) {
369	369	ZigType *child_type = type_entry->data.array.child_type;
370		if (child_type->id == TypeTableEntryIdStruct &&
	370	if (child_type->id == ZigTypeIdStruct &&
371	371	child_type->data.structure.layout == ContainerLayoutPacked)
372	372	{
373	373	return type_entry->data.array.len * type_size_bits(g, child_type);
...	...	@@ -395,7 +395,7 @@ Result<bool> type_is_copyable(CodeGen g, ZigType type_entry) {
395	395	}
396	396
397	397	static bool is_slice(ZigType *type) {
398		return type->id == TypeTableEntryIdStruct && type->data.structure.is_slice;
	398	return type->id == ZigTypeIdStruct && type->data.structure.is_slice;
399	399	}
400	400
401	401	ZigType get_smallest_unsigned_int_type(CodeGen g, uint64_t x) {
...	...	@@ -410,7 +410,7 @@ ZigType get_promise_type(CodeGen g, ZigType *result_type) {
410	410	}
411	411
412	412	ZigType *u8_ptr_type = get_pointer_to_type(g, g->builtin_types.entry_u8, false);
413		ZigType *entry = new_type_table_entry(TypeTableEntryIdPromise);
	413	ZigType *entry = new_type_table_entry(ZigTypeIdPromise);
414	414	entry->type_ref = u8_ptr_type->type_ref;
415	415	entry->zero_bits = false;
416	416	entry->data.promise.result_type = result_type;
...	...	@@ -432,13 +432,13 @@ ZigType get_pointer_to_type_extra(CodeGen g, ZigType *child_type, bool is_cons
432	432	bool is_volatile, PtrLen ptr_len, uint32_t byte_alignment, uint32_t bit_offset, uint32_t unaligned_bit_count)
433	433	{
434	434	assert(!type_is_invalid(child_type));
435		assert(ptr_len == PtrLenSingle \|\| child_type->id != TypeTableEntryIdOpaque);
	435	assert(ptr_len == PtrLenSingle \|\| child_type->id != ZigTypeIdOpaque);
436	436
437	437	TypeId type_id = {};
438	438	ZigType **parent_pointer = nullptr;
439	439	uint32_t abi_alignment = get_abi_alignment(g, child_type);
440	440	if (unaligned_bit_count != 0 \|\| is_volatile \|\| byte_alignment != abi_alignment \|\| ptr_len != PtrLenSingle) {
441		type_id.id = TypeTableEntryIdPointer;
	441	type_id.id = ZigTypeIdPointer;
442	442	type_id.data.pointer.child_type = child_type;
443	443	type_id.data.pointer.is_const = is_const;
444	444	type_id.data.pointer.is_volatile = is_volatile;
...	...	@@ -461,7 +461,7 @@ ZigType get_pointer_to_type_extra(CodeGen g, ZigType *child_type, bool is_cons
461	461
462	462	assertNoError(type_ensure_zero_bits_known(g, child_type));
463	463
464		ZigType *entry = new_type_table_entry(TypeTableEntryIdPointer);
	464	ZigType *entry = new_type_table_entry(ZigTypeIdPointer);
465	465	entry->is_copyable = true;
466	466
467	467	const char star_str = ptr_len == PtrLenSingle ? "" : "[*]";
...	...	@@ -478,7 +478,7 @@ ZigType get_pointer_to_type_extra(CodeGen g, ZigType *child_type, bool is_cons
478	478	bit_offset, bit_offset + unaligned_bit_count, const_str, volatile_str, buf_ptr(&child_type->name));
479	479	}
480	480
481		assert(child_type->id != TypeTableEntryIdInvalid);
	481	assert(child_type->id != ZigTypeIdInvalid);
482	482
483	483	entry->zero_bits = !type_has_bits(child_type);
484	484
...	...	@@ -568,7 +568,7 @@ ZigType get_optional_type(CodeGen g, ZigType *child_type) {
568	568	} else {
569	569	assertNoError(ensure_complete_type(g, child_type));
570	570
571		ZigType *entry = new_type_table_entry(TypeTableEntryIdOptional);
	571	ZigType *entry = new_type_table_entry(ZigTypeIdOptional);
572	572	assert(child_type->type_ref \|\| child_type->zero_bits);
573	573	entry->is_copyable = type_is_copyable(g, child_type).unwrap();
574	574
...	...	@@ -646,11 +646,11 @@ ZigType get_optional_type(CodeGen g, ZigType *child_type) {
646	646	}
647	647
648	648	ZigType get_error_union_type(CodeGen g, ZigType err_set_type, ZigType payload_type) {
649		assert(err_set_type->id == TypeTableEntryIdErrorSet);
	649	assert(err_set_type->id == ZigTypeIdErrorSet);
650	650	assert(!type_is_invalid(payload_type));
651	651
652	652	TypeId type_id = {};
653		type_id.id = TypeTableEntryIdErrorUnion;
	653	type_id.id = ZigTypeIdErrorUnion;
654	654	type_id.data.error_union.err_set_type = err_set_type;
655	655	type_id.data.error_union.payload_type = payload_type;
656	656
...	...	@@ -659,7 +659,7 @@ ZigType get_error_union_type(CodeGen g, ZigType err_set_type, ZigType payloa
659	659	return existing_entry->value;
660	660	}
661	661
662		ZigType *entry = new_type_table_entry(TypeTableEntryIdErrorUnion);
	662	ZigType *entry = new_type_table_entry(ZigTypeIdErrorUnion);
663	663	entry->is_copyable = true;
664	664	assert(payload_type->di_type);
665	665	assertNoError(ensure_complete_type(g, payload_type));
...	...	@@ -742,7 +742,7 @@ ZigType get_error_union_type(CodeGen g, ZigType err_set_type, ZigType payloa
742	742
743	743	ZigType get_array_type(CodeGen g, ZigType *child_type, uint64_t array_size) {
744	744	TypeId type_id = {};
745		type_id.id = TypeTableEntryIdArray;
	745	type_id.id = ZigTypeIdArray;
746	746	type_id.data.array.child_type = child_type;
747	747	type_id.data.array.size = array_size;
748	748	auto existing_entry = g->type_table.maybe_get(type_id);
...	...	@@ -753,7 +753,7 @@ ZigType get_array_type(CodeGen g, ZigType *child_type, uint64_t array_size) {
753	753
754	754	assertNoError(ensure_complete_type(g, child_type));
755	755
756		ZigType *entry = new_type_table_entry(TypeTableEntryIdArray);
	756	ZigType *entry = new_type_table_entry(ZigTypeIdArray);
757	757	entry->zero_bits = (array_size == 0) \|\| child_type->zero_bits;
758	758	entry->is_copyable = false;
759	759
...	...	@@ -812,7 +812,7 @@ static void slice_type_common_init(CodeGen g, ZigType pointer_type, ZigType *e
812	812	}
813	813
814	814	ZigType get_slice_type(CodeGen g, ZigType *ptr_type) {
815		assert(ptr_type->id == TypeTableEntryIdPointer);
	815	assert(ptr_type->id == ZigTypeIdPointer);
816	816	assert(ptr_type->data.pointer.ptr_len == PtrLenUnknown);
817	817
818	818	ZigType **parent_pointer = &ptr_type->data.pointer.slice_parent;
...	...	@@ -820,7 +820,7 @@ ZigType get_slice_type(CodeGen g, ZigType *ptr_type) {
820	820	return *parent_pointer;
821	821	}
822	822
823		ZigType *entry = new_type_table_entry(TypeTableEntryIdStruct);
	823	ZigType *entry = new_type_table_entry(ZigTypeIdStruct);
824	824	entry->is_copyable = true;
825	825
826	826	// replace the & with [] to go from a ptr type name to a slice type name
...	...	@@ -853,7 +853,7 @@ ZigType get_slice_type(CodeGen g, ZigType *ptr_type) {
853	853	// and debug info is the same as if the child type were []T.
854	854	if (is_slice(child_type)) {
855	855	ZigType *child_ptr_type = child_type->data.structure.fields[slice_ptr_index].type_entry;
856		assert(child_ptr_type->id == TypeTableEntryIdPointer);
	856	assert(child_ptr_type->id == ZigTypeIdPointer);
857	857	ZigType *grand_child_type = child_ptr_type->data.pointer.child_type;
858	858	if (child_ptr_type->data.pointer.is_const \|\| child_ptr_type->data.pointer.is_volatile \|\|
859	859	child_ptr_type->data.pointer.alignment != get_abi_alignment(g, grand_child_type))
...	...	@@ -972,7 +972,7 @@ ZigType get_slice_type(CodeGen g, ZigType *ptr_type) {
972	972	}
973	973
974	974	ZigType get_opaque_type(CodeGen g, Scope scope, AstNode source_node, const char *name) {
975		ZigType *entry = new_type_table_entry(TypeTableEntryIdOpaque);
	975	ZigType *entry = new_type_table_entry(ZigTypeIdOpaque);
976	976
977	977	buf_init_from_str(&entry->name, name);
978	978
...	...	@@ -993,11 +993,11 @@ ZigType get_opaque_type(CodeGen g, Scope scope, AstNode source_node, const c
993	993
994	994	ZigType get_bound_fn_type(CodeGen g, ZigFn *fn_entry) {
995	995	ZigType *fn_type = fn_entry->type_entry;
996		assert(fn_type->id == TypeTableEntryIdFn);
	996	assert(fn_type->id == ZigTypeIdFn);
997	997	if (fn_type->data.fn.bound_fn_parent)
998	998	return fn_type->data.fn.bound_fn_parent;
999	999
1000		ZigType *bound_fn_type = new_type_table_entry(TypeTableEntryIdBoundFn);
	1000	ZigType *bound_fn_type = new_type_table_entry(ZigTypeIdBoundFn);
1001	1001	bound_fn_type->is_copyable = false;
1002	1002	bound_fn_type->data.bound_fn.fn_type = fn_type;
1003	1003	bound_fn_type->zero_bits = true;
...	...	@@ -1054,7 +1054,7 @@ static bool calling_convention_allows_zig_types(CallingConvention cc) {
1054	1054	ZigType get_ptr_to_stack_trace_type(CodeGen g) {
1055	1055	if (g->stack_trace_type == nullptr) {
1056	1056	ConstExprValue *stack_trace_type_val = get_builtin_value(g, "StackTrace");
1057		assert(stack_trace_type_val->type->id == TypeTableEntryIdMetaType);
	1057	assert(stack_trace_type_val->type->id == ZigTypeIdMetaType);
1058	1058	g->stack_trace_type = stack_trace_type_val->data.x_type;
1059	1059	g->ptr_to_stack_trace_type = get_pointer_to_type(g, g->stack_trace_type, false);
1060	1060	}
...	...	@@ -1070,12 +1070,12 @@ ZigType get_fn_type(CodeGen g, FnTypeId *fn_type_id) {
1070	1070	if (fn_type_id->return_type != nullptr) {
1071	1071	if ((err = ensure_complete_type(g, fn_type_id->return_type)))
1072	1072	return g->builtin_types.entry_invalid;
1073		assert(fn_type_id->return_type->id != TypeTableEntryIdOpaque);
	1073	assert(fn_type_id->return_type->id != ZigTypeIdOpaque);
1074	1074	} else {
1075	1075	zig_panic("TODO implement inferred return types https://github.com/ziglang/zig/issues/447");
1076	1076	}
1077	1077
1078		ZigType *fn_type = new_type_table_entry(TypeTableEntryIdFn);
	1078	ZigType *fn_type = new_type_table_entry(ZigTypeIdFn);
1079	1079	fn_type->is_copyable = true;
1080	1080	fn_type->data.fn.fn_type_id = *fn_type_id;
1081	1081
...	...	@@ -1222,11 +1222,11 @@ ZigType get_fn_type(CodeGen g, FnTypeId *fn_type_id) {
1222	1222	static ZigTypeId container_to_type(ContainerKind kind) {
1223	1223	switch (kind) {
1224	1224	case ContainerKindStruct:
1225		return TypeTableEntryIdStruct;
	1225	return ZigTypeIdStruct;
1226	1226	case ContainerKindEnum:
1227		return TypeTableEntryIdEnum;
	1227	return ZigTypeIdEnum;
1228	1228	case ContainerKindUnion:
1229		return TypeTableEntryIdUnion;
	1229	return ZigTypeIdUnion;
1230	1230	}
1231	1231	zig_unreachable();
1232	1232	}
...	...	@@ -1275,7 +1275,7 @@ static IrInstruction analyze_const_value(CodeGen g, Scope scope, AstNode nod
1275	1275
1276	1276	ZigType analyze_type_expr(CodeGen g, Scope scope, AstNode node) {
1277	1277	IrInstruction *result = analyze_const_value(g, scope, node, g->builtin_types.entry_type, nullptr);
1278		if (result->value.type->id == TypeTableEntryIdInvalid)
	1278	if (result->value.type->id == ZigTypeIdInvalid)
1279	1279	return g->builtin_types.entry_invalid;
1280	1280
1281	1281	assert(result->value.special != ConstValSpecialRuntime);
...	...	@@ -1283,7 +1283,7 @@ ZigType analyze_type_expr(CodeGen g, Scope scope, AstNode node) {
1283	1283	}
1284	1284
1285	1285	ZigType get_generic_fn_type(CodeGen g, FnTypeId *fn_type_id) {
1286		ZigType *fn_type = new_type_table_entry(TypeTableEntryIdFn);
	1286	ZigType *fn_type = new_type_table_entry(ZigTypeIdFn);
1287	1287	fn_type->is_copyable = false;
1288	1288	buf_resize(&fn_type->name, 0);
1289	1289	if (fn_type->data.fn.fn_type_id.cc == CallingConventionAsync) {
...	...	@@ -1384,41 +1384,41 @@ static bool analyze_const_string(CodeGen g, Scope scope, AstNode node, Buf *
1384	1384
1385	1385	static bool type_allowed_in_packed_struct(ZigType *type_entry) {
1386	1386	switch (type_entry->id) {
1387		case TypeTableEntryIdInvalid:
	1387	case ZigTypeIdInvalid:
1388	1388	zig_unreachable();
1389		case TypeTableEntryIdMetaType:
1390		case TypeTableEntryIdUnreachable:
1391		case TypeTableEntryIdComptimeFloat:
1392		case TypeTableEntryIdComptimeInt:
1393		case TypeTableEntryIdUndefined:
1394		case TypeTableEntryIdNull:
1395		case TypeTableEntryIdErrorUnion:
1396		case TypeTableEntryIdErrorSet:
1397		case TypeTableEntryIdNamespace:
1398		case TypeTableEntryIdBlock:
1399		case TypeTableEntryIdBoundFn:
1400		case TypeTableEntryIdArgTuple:
1401		case TypeTableEntryIdOpaque:
1402		case TypeTableEntryIdPromise:
	1389	case ZigTypeIdMetaType:
	1390	case ZigTypeIdUnreachable:
	1391	case ZigTypeIdComptimeFloat:
	1392	case ZigTypeIdComptimeInt:
	1393	case ZigTypeIdUndefined:
	1394	case ZigTypeIdNull:
	1395	case ZigTypeIdErrorUnion:
	1396	case ZigTypeIdErrorSet:
	1397	case ZigTypeIdNamespace:
	1398	case ZigTypeIdBlock:
	1399	case ZigTypeIdBoundFn:
	1400	case ZigTypeIdArgTuple:
	1401	case ZigTypeIdOpaque:
	1402	case ZigTypeIdPromise:
1403	1403	return false;
1404		case TypeTableEntryIdVoid:
1405		case TypeTableEntryIdBool:
1406		case TypeTableEntryIdInt:
1407		case TypeTableEntryIdFloat:
1408		case TypeTableEntryIdPointer:
1409		case TypeTableEntryIdArray:
1410		case TypeTableEntryIdFn:
	1404	case ZigTypeIdVoid:
	1405	case ZigTypeIdBool:
	1406	case ZigTypeIdInt:
	1407	case ZigTypeIdFloat:
	1408	case ZigTypeIdPointer:
	1409	case ZigTypeIdArray:
	1410	case ZigTypeIdFn:
1411	1411	return true;
1412		case TypeTableEntryIdStruct:
	1412	case ZigTypeIdStruct:
1413	1413	return type_entry->data.structure.layout == ContainerLayoutPacked;
1414		case TypeTableEntryIdUnion:
	1414	case ZigTypeIdUnion:
1415	1415	return type_entry->data.unionation.layout == ContainerLayoutPacked;
1416		case TypeTableEntryIdOptional:
	1416	case ZigTypeIdOptional:
1417	1417	{
1418	1418	ZigType *child_type = type_entry->data.maybe.child_type;
1419	1419	return type_is_codegen_pointer(child_type);
1420	1420	}
1421		case TypeTableEntryIdEnum:
	1421	case ZigTypeIdEnum:
1422	1422	return type_entry->data.enumeration.decl_node->data.container_decl.init_arg_expr != nullptr;
1423	1423	}
1424	1424	zig_unreachable();
...	...	@@ -1426,27 +1426,27 @@ static bool type_allowed_in_packed_struct(ZigType *type_entry) {
1426	1426
1427	1427	static bool type_allowed_in_extern(CodeGen g, ZigType type_entry) {
1428	1428	switch (type_entry->id) {
1429		case TypeTableEntryIdInvalid:
	1429	case ZigTypeIdInvalid:
1430	1430	zig_unreachable();
1431		case TypeTableEntryIdMetaType:
1432		case TypeTableEntryIdComptimeFloat:
1433		case TypeTableEntryIdComptimeInt:
1434		case TypeTableEntryIdUndefined:
1435		case TypeTableEntryIdNull:
1436		case TypeTableEntryIdErrorUnion:
1437		case TypeTableEntryIdErrorSet:
1438		case TypeTableEntryIdNamespace:
1439		case TypeTableEntryIdBlock:
1440		case TypeTableEntryIdBoundFn:
1441		case TypeTableEntryIdArgTuple:
1442		case TypeTableEntryIdPromise:
1443		case TypeTableEntryIdVoid:
	1431	case ZigTypeIdMetaType:
	1432	case ZigTypeIdComptimeFloat:
	1433	case ZigTypeIdComptimeInt:
	1434	case ZigTypeIdUndefined:
	1435	case ZigTypeIdNull:
	1436	case ZigTypeIdErrorUnion:
	1437	case ZigTypeIdErrorSet:
	1438	case ZigTypeIdNamespace:
	1439	case ZigTypeIdBlock:
	1440	case ZigTypeIdBoundFn:
	1441	case ZigTypeIdArgTuple:
	1442	case ZigTypeIdPromise:
	1443	case ZigTypeIdVoid:
1444	1444	return false;
1445		case TypeTableEntryIdOpaque:
1446		case TypeTableEntryIdUnreachable:
1447		case TypeTableEntryIdBool:
	1445	case ZigTypeIdOpaque:
	1446	case ZigTypeIdUnreachable:
	1447	case ZigTypeIdBool:
1448	1448	return true;
1449		case TypeTableEntryIdInt:
	1449	case ZigTypeIdInt:
1450	1450	switch (type_entry->data.integral.bit_count) {
1451	1451	case 8:
1452	1452	case 16:
...	...	@@ -1457,36 +1457,36 @@ static bool type_allowed_in_extern(CodeGen g, ZigType type_entry) {
1457	1457	default:
1458	1458	return false;
1459	1459	}
1460		case TypeTableEntryIdFloat:
	1460	case ZigTypeIdFloat:
1461	1461	return true;
1462		case TypeTableEntryIdArray:
	1462	case ZigTypeIdArray:
1463	1463	return type_allowed_in_extern(g, type_entry->data.array.child_type);
1464		case TypeTableEntryIdFn:
	1464	case ZigTypeIdFn:
1465	1465	return type_entry->data.fn.fn_type_id.cc == CallingConventionC;
1466		case TypeTableEntryIdPointer:
	1466	case ZigTypeIdPointer:
1467	1467	if (type_size(g, type_entry) == 0)
1468	1468	return false;
1469	1469	return true;
1470		case TypeTableEntryIdStruct:
	1470	case ZigTypeIdStruct:
1471	1471	return type_entry->data.structure.layout == ContainerLayoutExtern \|\| type_entry->data.structure.layout == ContainerLayoutPacked;
1472		case TypeTableEntryIdOptional:
	1472	case ZigTypeIdOptional:
1473	1473	{
1474	1474	ZigType *child_type = type_entry->data.maybe.child_type;
1475		if (child_type->id != TypeTableEntryIdPointer && child_type->id != TypeTableEntryIdFn) {
	1475	if (child_type->id != ZigTypeIdPointer && child_type->id != ZigTypeIdFn) {
1476	1476	return false;
1477	1477	}
1478	1478	return type_allowed_in_extern(g, child_type);
1479	1479	}
1480		case TypeTableEntryIdEnum:
	1480	case ZigTypeIdEnum:
1481	1481	return type_entry->data.enumeration.layout == ContainerLayoutExtern \|\| type_entry->data.enumeration.layout == ContainerLayoutPacked;
1482		case TypeTableEntryIdUnion:
	1482	case ZigTypeIdUnion:
1483	1483	return type_entry->data.unionation.layout == ContainerLayoutExtern \|\| type_entry->data.unionation.layout == ContainerLayoutPacked;
1484	1484	}
1485	1485	zig_unreachable();
1486	1486	}
1487	1487
1488	1488	ZigType get_auto_err_set_type(CodeGen g, ZigFn *fn_entry) {
1489		ZigType *err_set_type = new_type_table_entry(TypeTableEntryIdErrorSet);
	1489	ZigType *err_set_type = new_type_table_entry(ZigTypeIdErrorSet);
1490	1490	buf_resize(&err_set_type->name, 0);
1491	1491	buf_appendf(&err_set_type->name, "@typeOf(%s).ReturnType.ErrorSet", buf_ptr(&fn_entry->symbol_name));
1492	1492	err_set_type->is_copyable = true;
...	...	@@ -1581,36 +1581,36 @@ static ZigType analyze_fn_type(CodeGen g, AstNode proto_node, Scope child_sc
1581	1581	}
1582	1582
1583	1583	switch (type_entry->id) {
1584		case TypeTableEntryIdInvalid:
	1584	case ZigTypeIdInvalid:
1585	1585	zig_unreachable();
1586		case TypeTableEntryIdUnreachable:
1587		case TypeTableEntryIdUndefined:
1588		case TypeTableEntryIdNull:
1589		case TypeTableEntryIdArgTuple:
1590		case TypeTableEntryIdOpaque:
	1586	case ZigTypeIdUnreachable:
	1587	case ZigTypeIdUndefined:
	1588	case ZigTypeIdNull:
	1589	case ZigTypeIdArgTuple:
	1590	case ZigTypeIdOpaque:
1591	1591	add_node_error(g, param_node->data.param_decl.type,
1592	1592	buf_sprintf("parameter of type '%s' not allowed", buf_ptr(&type_entry->name)));
1593	1593	return g->builtin_types.entry_invalid;
1594		case TypeTableEntryIdComptimeFloat:
1595		case TypeTableEntryIdComptimeInt:
1596		case TypeTableEntryIdNamespace:
1597		case TypeTableEntryIdBlock:
1598		case TypeTableEntryIdBoundFn:
1599		case TypeTableEntryIdMetaType:
1600		case TypeTableEntryIdVoid:
1601		case TypeTableEntryIdBool:
1602		case TypeTableEntryIdInt:
1603		case TypeTableEntryIdFloat:
1604		case TypeTableEntryIdPointer:
1605		case TypeTableEntryIdArray:
1606		case TypeTableEntryIdStruct:
1607		case TypeTableEntryIdOptional:
1608		case TypeTableEntryIdErrorUnion:
1609		case TypeTableEntryIdErrorSet:
1610		case TypeTableEntryIdEnum:
1611		case TypeTableEntryIdUnion:
1612		case TypeTableEntryIdFn:
1613		case TypeTableEntryIdPromise:
	1594	case ZigTypeIdComptimeFloat:
	1595	case ZigTypeIdComptimeInt:
	1596	case ZigTypeIdNamespace:
	1597	case ZigTypeIdBlock:
	1598	case ZigTypeIdBoundFn:
	1599	case ZigTypeIdMetaType:
	1600	case ZigTypeIdVoid:
	1601	case ZigTypeIdBool:
	1602	case ZigTypeIdInt:
	1603	case ZigTypeIdFloat:
	1604	case ZigTypeIdPointer:
	1605	case ZigTypeIdArray:
	1606	case ZigTypeIdStruct:
	1607	case ZigTypeIdOptional:
	1608	case ZigTypeIdErrorUnion:
	1609	case ZigTypeIdErrorSet:
	1610	case ZigTypeIdEnum:
	1611	case ZigTypeIdUnion:
	1612	case ZigTypeIdFn:
	1613	case ZigTypeIdPromise:
1614	1614	if ((err = type_ensure_zero_bits_known(g, type_entry)))
1615	1615	return g->builtin_types.entry_invalid;
1616	1616	if (type_requires_comptime(type_entry)) {
...	...	@@ -1659,7 +1659,7 @@ static ZigType analyze_fn_type(CodeGen g, AstNode proto_node, Scope child_sc
1659	1659	}
1660	1660
1661	1661	if (!calling_convention_allows_zig_types(fn_type_id.cc) &&
1662		fn_type_id.return_type->id != TypeTableEntryIdVoid &&
	1662	fn_type_id.return_type->id != ZigTypeIdVoid &&
1663	1663	!type_allowed_in_extern(g, fn_type_id.return_type))
1664	1664	{
1665	1665	add_node_error(g, fn_proto->return_type,
...	...	@@ -1670,38 +1670,38 @@ static ZigType analyze_fn_type(CodeGen g, AstNode proto_node, Scope child_sc
1670	1670	}
1671	1671
1672	1672	switch (fn_type_id.return_type->id) {
1673		case TypeTableEntryIdInvalid:
	1673	case ZigTypeIdInvalid:
1674	1674	zig_unreachable();
1675	1675
1676		case TypeTableEntryIdUndefined:
1677		case TypeTableEntryIdNull:
1678		case TypeTableEntryIdArgTuple:
1679		case TypeTableEntryIdOpaque:
	1676	case ZigTypeIdUndefined:
	1677	case ZigTypeIdNull:
	1678	case ZigTypeIdArgTuple:
	1679	case ZigTypeIdOpaque:
1680	1680	add_node_error(g, fn_proto->return_type,
1681	1681	buf_sprintf("return type '%s' not allowed", buf_ptr(&fn_type_id.return_type->name)));
1682	1682	return g->builtin_types.entry_invalid;
1683	1683
1684		case TypeTableEntryIdComptimeFloat:
1685		case TypeTableEntryIdComptimeInt:
1686		case TypeTableEntryIdNamespace:
1687		case TypeTableEntryIdBlock:
1688		case TypeTableEntryIdBoundFn:
1689		case TypeTableEntryIdMetaType:
1690		case TypeTableEntryIdUnreachable:
1691		case TypeTableEntryIdVoid:
1692		case TypeTableEntryIdBool:
1693		case TypeTableEntryIdInt:
1694		case TypeTableEntryIdFloat:
1695		case TypeTableEntryIdPointer:
1696		case TypeTableEntryIdArray:
1697		case TypeTableEntryIdStruct:
1698		case TypeTableEntryIdOptional:
1699		case TypeTableEntryIdErrorUnion:
1700		case TypeTableEntryIdErrorSet:
1701		case TypeTableEntryIdEnum:
1702		case TypeTableEntryIdUnion:
1703		case TypeTableEntryIdFn:
1704		case TypeTableEntryIdPromise:
	1684	case ZigTypeIdComptimeFloat:
	1685	case ZigTypeIdComptimeInt:
	1686	case ZigTypeIdNamespace:
	1687	case ZigTypeIdBlock:
	1688	case ZigTypeIdBoundFn:
	1689	case ZigTypeIdMetaType:
	1690	case ZigTypeIdUnreachable:
	1691	case ZigTypeIdVoid:
	1692	case ZigTypeIdBool:
	1693	case ZigTypeIdInt:
	1694	case ZigTypeIdFloat:
	1695	case ZigTypeIdPointer:
	1696	case ZigTypeIdArray:
	1697	case ZigTypeIdStruct:
	1698	case ZigTypeIdOptional:
	1699	case ZigTypeIdErrorUnion:
	1700	case ZigTypeIdErrorSet:
	1701	case ZigTypeIdEnum:
	1702	case ZigTypeIdUnion:
	1703	case ZigTypeIdFn:
	1704	case ZigTypeIdPromise:
1705	1705	if ((err = type_ensure_zero_bits_known(g, fn_type_id.return_type)))
1706	1706	return g->builtin_types.entry_invalid;
1707	1707	if (type_requires_comptime(fn_type_id.return_type)) {
...	...	@@ -1725,13 +1725,13 @@ static ZigType analyze_fn_type(CodeGen g, AstNode proto_node, Scope child_sc
1725	1725
1726	1726	bool type_is_invalid(ZigType *type_entry) {
1727	1727	switch (type_entry->id) {
1728		case TypeTableEntryIdInvalid:
	1728	case ZigTypeIdInvalid:
1729	1729	return true;
1730		case TypeTableEntryIdStruct:
	1730	case ZigTypeIdStruct:
1731	1731	return type_entry->data.structure.is_invalid;
1732		case TypeTableEntryIdEnum:
	1732	case ZigTypeIdEnum:
1733	1733	return type_entry->data.enumeration.is_invalid;
1734		case TypeTableEntryIdUnion:
	1734	case ZigTypeIdUnion:
1735	1735	return type_entry->data.unionation.is_invalid;
1736	1736	default:
1737	1737	return false;
...	...	@@ -1741,7 +1741,7 @@ bool type_is_invalid(ZigType *type_entry) {
1741	1741
1742	1742
1743	1743	static Error resolve_enum_type(CodeGen g, ZigType enum_type) {
1744		assert(enum_type->id == TypeTableEntryIdEnum);
	1744	assert(enum_type->id == ZigTypeIdEnum);
1745	1745
1746	1746	if (enum_type->data.enumeration.is_invalid)
1747	1747	return ErrorSemanticAnalyzeFail;
...	...	@@ -1837,7 +1837,7 @@ static Error resolve_enum_type(CodeGen g, ZigType enum_type) {
1837	1837	ZigType get_struct_type(CodeGen g, const char type_name, const char field_names[],
1838	1838	ZigType *field_types[], size_t field_count)
1839	1839	{
1840		ZigType *struct_type = new_type_table_entry(TypeTableEntryIdStruct);
	1840	ZigType *struct_type = new_type_table_entry(ZigTypeIdStruct);
1841	1841
1842	1842	buf_init_from_str(&struct_type->name, type_name);
1843	1843
...	...	@@ -1914,7 +1914,7 @@ ZigType get_struct_type(CodeGen g, const char type_name, const char field_na
1914	1914	}
1915	1915
1916	1916	static Error resolve_struct_type(CodeGen g, ZigType struct_type) {
1917		assert(struct_type->id == TypeTableEntryIdStruct);
	1917	assert(struct_type->id == ZigTypeIdStruct);
1918	1918
1919	1919	if (struct_type->data.structure.complete)
1920	1920	return ErrorNone;
...	...	@@ -2092,7 +2092,7 @@ static Error resolve_struct_type(CodeGen g, ZigType struct_type) {
2092	2092
2093	2093	// if the field is a function, actually the debug info should be a pointer.
2094	2094	ZigLLVMDIType *field_di_type;
2095		if (field_type->id == TypeTableEntryIdFn) {
	2095	if (field_type->id == ZigTypeIdFn) {
2096	2096	ZigType *field_ptr_type = get_pointer_to_type(g, field_type, true);
2097	2097	uint64_t debug_size_in_bits = 8*LLVMStoreSizeOfType(g->target_data_ref, field_ptr_type->type_ref);
2098	2098	uint64_t debug_align_in_bits = 8*LLVMABISizeOfType(g->target_data_ref, field_ptr_type->type_ref);
...	...	@@ -2148,7 +2148,7 @@ static Error resolve_struct_type(CodeGen g, ZigType struct_type) {
2148	2148	}
2149	2149
2150	2150	static Error resolve_union_type(CodeGen g, ZigType union_type) {
2151		assert(union_type->id == TypeTableEntryIdUnion);
	2151	assert(union_type->id == ZigTypeIdUnion);
2152	2152
2153	2153	if (union_type->data.unionation.complete)
2154	2154	return ErrorNone;
...	...	@@ -2388,7 +2388,7 @@ static Error resolve_union_type(CodeGen g, ZigType union_type) {
2388	2388	}
2389	2389
2390	2390	static Error resolve_enum_zero_bits(CodeGen g, ZigType enum_type) {
2391		assert(enum_type->id == TypeTableEntryIdEnum);
	2391	assert(enum_type->id == ZigTypeIdEnum);
2392	2392
2393	2393	if (enum_type->data.enumeration.zero_bits_known)
2394	2394	return ErrorNone;
...	...	@@ -2440,7 +2440,7 @@ static Error resolve_enum_zero_bits(CodeGen g, ZigType enum_type) {
2440	2440	ZigType *wanted_tag_int_type = analyze_type_expr(g, scope, decl_node->data.container_decl.init_arg_expr);
2441	2441	if (type_is_invalid(wanted_tag_int_type)) {
2442	2442	enum_type->data.enumeration.is_invalid = true;
2443		} else if (wanted_tag_int_type->id != TypeTableEntryIdInt) {
	2443	} else if (wanted_tag_int_type->id != ZigTypeIdInt) {
2444	2444	enum_type->data.enumeration.is_invalid = true;
2445	2445	add_node_error(g, decl_node->data.container_decl.init_arg_expr,
2446	2446	buf_sprintf("expected integer, found '%s'", buf_ptr(&wanted_tag_int_type->name)));
...	...	@@ -2489,12 +2489,12 @@ static Error resolve_enum_zero_bits(CodeGen g, ZigType enum_type) {
2489	2489	// In a second pass we will fill in the unspecified ones.
2490	2490	if (tag_value != nullptr) {
2491	2491	IrInstruction *result_inst = analyze_const_value(g, scope, tag_value, tag_int_type, nullptr);
2492		if (result_inst->value.type->id == TypeTableEntryIdInvalid) {
	2492	if (result_inst->value.type->id == ZigTypeIdInvalid) {
2493	2493	enum_type->data.enumeration.is_invalid = true;
2494	2494	continue;
2495	2495	}
2496	2496	assert(result_inst->value.special != ConstValSpecialRuntime);
2497		assert(result_inst->value.type->id == TypeTableEntryIdInt);
	2497	assert(result_inst->value.type->id == ZigTypeIdInt);
2498	2498	auto entry = occupied_tag_values.put_unique(result_inst->value.data.x_bigint, tag_value);
2499	2499	if (entry == nullptr) {
2500	2500	bigint_init_bigint(&type_enum_field->value, &result_inst->value.data.x_bigint);
...	...	@@ -2551,7 +2551,7 @@ static Error resolve_enum_zero_bits(CodeGen g, ZigType enum_type) {
2551	2551	}
2552	2552
2553	2553	static Error resolve_struct_zero_bits(CodeGen g, ZigType struct_type) {
2554		assert(struct_type->id == TypeTableEntryIdStruct);
	2554	assert(struct_type->id == ZigTypeIdStruct);
2555	2555
2556	2556	Error err;
2557	2557
...	...	@@ -2670,7 +2670,7 @@ static Error resolve_struct_zero_bits(CodeGen g, ZigType struct_type) {
2670	2670	}
2671	2671
2672	2672	static Error resolve_union_zero_bits(CodeGen g, ZigType union_type) {
2673		assert(union_type->id == TypeTableEntryIdUnion);
	2673	assert(union_type->id == ZigTypeIdUnion);
2674	2674
2675	2675	Error err;
2676	2676
...	...	@@ -2751,7 +2751,7 @@ static Error resolve_union_zero_bits(CodeGen g, ZigType union_type) {
2751	2751	union_type->data.unionation.is_invalid = true;
2752	2752	return ErrorSemanticAnalyzeFail;
2753	2753	}
2754		if (tag_int_type->id != TypeTableEntryIdInt) {
	2754	if (tag_int_type->id != ZigTypeIdInt) {
2755	2755	add_node_error(g, enum_type_node,
2756	2756	buf_sprintf("expected integer tag type, found '%s'", buf_ptr(&tag_int_type->name)));
2757	2757	union_type->data.unionation.is_invalid = true;
...	...	@@ -2762,7 +2762,7 @@ static Error resolve_union_zero_bits(CodeGen g, ZigType union_type) {
2762	2762	}
2763	2763	abi_alignment_so_far = get_abi_alignment(g, tag_int_type);
2764	2764
2765		tag_type = new_type_table_entry(TypeTableEntryIdEnum);
	2765	tag_type = new_type_table_entry(ZigTypeIdEnum);
2766	2766	buf_resize(&tag_type->name, 0);
2767	2767	buf_appendf(&tag_type->name, "@TagType(%s)", buf_ptr(&union_type->name));
2768	2768	tag_type->is_copyable = true;
...	...	@@ -2784,7 +2784,7 @@ static Error resolve_union_zero_bits(CodeGen g, ZigType union_type) {
2784	2784	union_type->data.unionation.is_invalid = true;
2785	2785	return ErrorSemanticAnalyzeFail;
2786	2786	}
2787		if (enum_type->id != TypeTableEntryIdEnum) {
	2787	if (enum_type->id != ZigTypeIdEnum) {
2788	2788	union_type->data.unionation.is_invalid = true;
2789	2789	add_node_error(g, enum_type_node,
2790	2790	buf_sprintf("expected enum tag type, found '%s'", buf_ptr(&enum_type->name)));
...	...	@@ -2862,12 +2862,12 @@ static Error resolve_union_zero_bits(CodeGen g, ZigType union_type) {
2862	2862	if (tag_value != nullptr) {
2863	2863	ZigType *tag_int_type = tag_type->data.enumeration.tag_int_type;
2864	2864	IrInstruction *result_inst = analyze_const_value(g, scope, tag_value, tag_int_type, nullptr);
2865		if (result_inst->value.type->id == TypeTableEntryIdInvalid) {
	2865	if (result_inst->value.type->id == ZigTypeIdInvalid) {
2866	2866	union_type->data.unionation.is_invalid = true;
2867	2867	continue;
2868	2868	}
2869	2869	assert(result_inst->value.special != ConstValSpecialRuntime);
2870		assert(result_inst->value.type->id == TypeTableEntryIdInt);
	2870	assert(result_inst->value.type->id == ZigTypeIdInt);
2871	2871	auto entry = occupied_tag_values.put_unique(result_inst->value.data.x_bigint, tag_value);
2872	2872	if (entry == nullptr) {
2873	2873	bigint_init_bigint(&union_field->enum_field->value, &result_inst->value.data.x_bigint);
...	...	@@ -3192,7 +3192,7 @@ static void resolve_decl_fn(CodeGen g, TldFn tld_fn) {
3192	3192	}
3193	3193	}
3194	3194
3195		if (fn_table_entry->type_entry->id == TypeTableEntryIdInvalid) {
	3195	if (fn_table_entry->type_entry->id == ZigTypeIdInvalid) {
3196	3196	tld_fn->base.resolution = TldResolutionInvalid;
3197	3197	return;
3198	3198	}
...	...	@@ -3448,13 +3448,13 @@ static void resolve_decl_container(CodeGen g, TldContainer tld_container) {
3448	3448	assert(type_entry);
3449	3449
3450	3450	switch (type_entry->id) {
3451		case TypeTableEntryIdStruct:
	3451	case ZigTypeIdStruct:
3452	3452	resolve_struct_type(g, tld_container->type_entry);
3453	3453	return;
3454		case TypeTableEntryIdEnum:
	3454	case ZigTypeIdEnum:
3455	3455	resolve_enum_type(g, tld_container->type_entry);
3456	3456	return;
3457		case TypeTableEntryIdUnion:
	3457	case ZigTypeIdUnion:
3458	3458	resolve_union_type(g, tld_container->type_entry);
3459	3459	return;
3460	3460	default:
...	...	@@ -3464,36 +3464,36 @@ static void resolve_decl_container(CodeGen g, TldContainer tld_container) {
3464	3464
3465	3465	ZigType validate_var_type(CodeGen g, AstNode source_node, ZigType type_entry) {
3466	3466	switch (type_entry->id) {
3467		case TypeTableEntryIdInvalid:
	3467	case ZigTypeIdInvalid:
3468	3468	return g->builtin_types.entry_invalid;
3469		case TypeTableEntryIdUnreachable:
3470		case TypeTableEntryIdUndefined:
3471		case TypeTableEntryIdNull:
3472		case TypeTableEntryIdBlock:
3473		case TypeTableEntryIdArgTuple:
3474		case TypeTableEntryIdOpaque:
	3469	case ZigTypeIdUnreachable:
	3470	case ZigTypeIdUndefined:
	3471	case ZigTypeIdNull:
	3472	case ZigTypeIdBlock:
	3473	case ZigTypeIdArgTuple:
	3474	case ZigTypeIdOpaque:
3475	3475	add_node_error(g, source_node, buf_sprintf("variable of type '%s' not allowed",
3476	3476	buf_ptr(&type_entry->name)));
3477	3477	return g->builtin_types.entry_invalid;
3478		case TypeTableEntryIdComptimeFloat:
3479		case TypeTableEntryIdComptimeInt:
3480		case TypeTableEntryIdNamespace:
3481		case TypeTableEntryIdMetaType:
3482		case TypeTableEntryIdVoid:
3483		case TypeTableEntryIdBool:
3484		case TypeTableEntryIdInt:
3485		case TypeTableEntryIdFloat:
3486		case TypeTableEntryIdPointer:
3487		case TypeTableEntryIdArray:
3488		case TypeTableEntryIdStruct:
3489		case TypeTableEntryIdOptional:
3490		case TypeTableEntryIdErrorUnion:
3491		case TypeTableEntryIdErrorSet:
3492		case TypeTableEntryIdEnum:
3493		case TypeTableEntryIdUnion:
3494		case TypeTableEntryIdFn:
3495		case TypeTableEntryIdBoundFn:
3496		case TypeTableEntryIdPromise:
	3478	case ZigTypeIdComptimeFloat:
	3479	case ZigTypeIdComptimeInt:
	3480	case ZigTypeIdNamespace:
	3481	case ZigTypeIdMetaType:
	3482	case ZigTypeIdVoid:
	3483	case ZigTypeIdBool:
	3484	case ZigTypeIdInt:
	3485	case ZigTypeIdFloat:
	3486	case ZigTypeIdPointer:
	3487	case ZigTypeIdArray:
	3488	case ZigTypeIdStruct:
	3489	case ZigTypeIdOptional:
	3490	case ZigTypeIdErrorUnion:
	3491	case ZigTypeIdErrorSet:
	3492	case ZigTypeIdEnum:
	3493	case ZigTypeIdUnion:
	3494	case ZigTypeIdFn:
	3495	case ZigTypeIdBoundFn:
	3496	case ZigTypeIdPromise:
3497	3497	return type_entry;
3498	3498	}
3499	3499	zig_unreachable();
...	...	@@ -3598,30 +3598,30 @@ static void resolve_decl_var(CodeGen g, TldVar tld_var) {
3598	3598
3599	3599	// TODO more validation for types that can't be used for export/extern variables
3600	3600	ZigType *implicit_type = nullptr;
3601		if (explicit_type && explicit_type->id == TypeTableEntryIdInvalid) {
	3601	if (explicit_type && explicit_type->id == ZigTypeIdInvalid) {
3602	3602	implicit_type = explicit_type;
3603	3603	} else if (var_decl->expr) {
3604	3604	init_value = analyze_const_value(g, tld_var->base.parent_scope, var_decl->expr, explicit_type, var_decl->symbol);
3605	3605	assert(init_value);
3606	3606	implicit_type = init_value->value.type;
3607	3607
3608		if (implicit_type->id == TypeTableEntryIdUnreachable) {
	3608	if (implicit_type->id == ZigTypeIdUnreachable) {
3609	3609	add_node_error(g, source_node, buf_sprintf("variable initialization is unreachable"));
3610	3610	implicit_type = g->builtin_types.entry_invalid;
3611	3611	} else if ((!is_const \|\| linkage == VarLinkageExternal) &&
3612		(implicit_type->id == TypeTableEntryIdComptimeFloat \|\|
3613		implicit_type->id == TypeTableEntryIdComptimeInt))
	3612	(implicit_type->id == ZigTypeIdComptimeFloat \|\|
	3613	implicit_type->id == ZigTypeIdComptimeInt))
3614	3614	{
3615	3615	add_node_error(g, source_node, buf_sprintf("unable to infer variable type"));
3616	3616	implicit_type = g->builtin_types.entry_invalid;
3617		} else if (implicit_type->id == TypeTableEntryIdNull) {
	3617	} else if (implicit_type->id == ZigTypeIdNull) {
3618	3618	add_node_error(g, source_node, buf_sprintf("unable to infer variable type"));
3619	3619	implicit_type = g->builtin_types.entry_invalid;
3620		} else if (implicit_type->id == TypeTableEntryIdMetaType && !is_const) {
	3620	} else if (implicit_type->id == ZigTypeIdMetaType && !is_const) {
3621	3621	add_node_error(g, source_node, buf_sprintf("variable of type 'type' must be constant"));
3622	3622	implicit_type = g->builtin_types.entry_invalid;
3623	3623	}
3624		assert(implicit_type->id == TypeTableEntryIdInvalid \|\| init_value->value.special != ConstValSpecialRuntime);
	3624	assert(implicit_type->id == ZigTypeIdInvalid \|\| init_value->value.special != ConstValSpecialRuntime);
3625	3625	} else if (linkage != VarLinkageExternal) {
3626	3626	add_node_error(g, source_node, buf_sprintf("variables must be initialized"));
3627	3627	implicit_type = g->builtin_types.entry_invalid;
...	...	@@ -3790,7 +3790,7 @@ ZigFn scope_get_fn_if_root(Scope scope) {
3790	3790	}
3791	3791
3792	3792	TypeEnumField find_enum_type_field(ZigType enum_type, Buf *name) {
3793		assert(enum_type->id == TypeTableEntryIdEnum);
	3793	assert(enum_type->id == ZigTypeIdEnum);
3794	3794	if (enum_type->data.enumeration.src_field_count == 0)
3795	3795	return nullptr;
3796	3796	auto entry = enum_type->data.enumeration.fields_by_name.maybe_get(name);
...	...	@@ -3800,7 +3800,7 @@ TypeEnumField find_enum_type_field(ZigType enum_type, Buf *name) {
3800	3800	}
3801	3801
3802	3802	TypeStructField find_struct_type_field(ZigType type_entry, Buf *name) {
3803		assert(type_entry->id == TypeTableEntryIdStruct);
	3803	assert(type_entry->id == ZigTypeIdStruct);
3804	3804	assert(type_entry->data.structure.complete);
3805	3805	if (type_entry->data.structure.src_field_count == 0)
3806	3806	return nullptr;
...	...	@@ -3811,7 +3811,7 @@ TypeStructField find_struct_type_field(ZigType type_entry, Buf *name) {
3811	3811	}
3812	3812
3813	3813	TypeUnionField find_union_type_field(ZigType type_entry, Buf *name) {
3814		assert(type_entry->id == TypeTableEntryIdUnion);
	3814	assert(type_entry->id == ZigTypeIdUnion);
3815	3815	assert(type_entry->data.unionation.zero_bits_known);
3816	3816	if (type_entry->data.unionation.src_field_count == 0)
3817	3817	return nullptr;
...	...	@@ -3822,7 +3822,7 @@ TypeUnionField find_union_type_field(ZigType type_entry, Buf *name) {
3822	3822	}
3823	3823
3824	3824	TypeUnionField find_union_field_by_tag(ZigType type_entry, const BigInt *tag) {
3825		assert(type_entry->id == TypeTableEntryIdUnion);
	3825	assert(type_entry->id == ZigTypeIdUnion);
3826	3826	assert(type_entry->data.unionation.zero_bits_known);
3827	3827	for (uint32_t i = 0; i < type_entry->data.unionation.src_field_count; i += 1) {
3828	3828	TypeUnionField *field = &type_entry->data.unionation.fields[i];
...	...	@@ -3847,47 +3847,47 @@ TypeEnumField find_enum_field_by_tag(ZigType enum_type, const BigInt *tag) {
3847	3847
3848	3848	static bool is_container(ZigType *type_entry) {
3849	3849	switch (type_entry->id) {
3850		case TypeTableEntryIdInvalid:
	3850	case ZigTypeIdInvalid:
3851	3851	zig_unreachable();
3852		case TypeTableEntryIdStruct:
3853		case TypeTableEntryIdEnum:
3854		case TypeTableEntryIdUnion:
	3852	case ZigTypeIdStruct:
	3853	case ZigTypeIdEnum:
	3854	case ZigTypeIdUnion:
3855	3855	return true;
3856		case TypeTableEntryIdPointer:
3857		case TypeTableEntryIdMetaType:
3858		case TypeTableEntryIdVoid:
3859		case TypeTableEntryIdBool:
3860		case TypeTableEntryIdUnreachable:
3861		case TypeTableEntryIdInt:
3862		case TypeTableEntryIdFloat:
3863		case TypeTableEntryIdArray:
3864		case TypeTableEntryIdComptimeFloat:
3865		case TypeTableEntryIdComptimeInt:
3866		case TypeTableEntryIdUndefined:
3867		case TypeTableEntryIdNull:
3868		case TypeTableEntryIdOptional:
3869		case TypeTableEntryIdErrorUnion:
3870		case TypeTableEntryIdErrorSet:
3871		case TypeTableEntryIdFn:
3872		case TypeTableEntryIdNamespace:
3873		case TypeTableEntryIdBlock:
3874		case TypeTableEntryIdBoundFn:
3875		case TypeTableEntryIdArgTuple:
3876		case TypeTableEntryIdOpaque:
3877		case TypeTableEntryIdPromise:
	3856	case ZigTypeIdPointer:
	3857	case ZigTypeIdMetaType:
	3858	case ZigTypeIdVoid:
	3859	case ZigTypeIdBool:
	3860	case ZigTypeIdUnreachable:
	3861	case ZigTypeIdInt:
	3862	case ZigTypeIdFloat:
	3863	case ZigTypeIdArray:
	3864	case ZigTypeIdComptimeFloat:
	3865	case ZigTypeIdComptimeInt:
	3866	case ZigTypeIdUndefined:
	3867	case ZigTypeIdNull:
	3868	case ZigTypeIdOptional:
	3869	case ZigTypeIdErrorUnion:
	3870	case ZigTypeIdErrorSet:
	3871	case ZigTypeIdFn:
	3872	case ZigTypeIdNamespace:
	3873	case ZigTypeIdBlock:
	3874	case ZigTypeIdBoundFn:
	3875	case ZigTypeIdArgTuple:
	3876	case ZigTypeIdOpaque:
	3877	case ZigTypeIdPromise:
3878	3878	return false;
3879	3879	}
3880	3880	zig_unreachable();
3881	3881	}
3882	3882
3883	3883	bool is_ref(ZigType *type_entry) {
3884		return type_entry->id == TypeTableEntryIdPointer && type_entry->data.pointer.ptr_len == PtrLenSingle;
	3884	return type_entry->id == ZigTypeIdPointer && type_entry->data.pointer.ptr_len == PtrLenSingle;
3885	3885	}
3886	3886
3887	3887	bool is_array_ref(ZigType *type_entry) {
3888	3888	ZigType *array = is_ref(type_entry) ?
3889	3889	type_entry->data.pointer.child_type : type_entry;
3890		return array->id == TypeTableEntryIdArray;
	3890	return array->id == ZigTypeIdArray;
3891	3891	}
3892	3892
3893	3893	bool is_container_ref(ZigType *type_entry) {
...	...	@@ -3903,50 +3903,50 @@ ZigType container_ref_type(ZigType type_entry) {
3903	3903
3904	3904	void resolve_container_type(CodeGen g, ZigType type_entry) {
3905	3905	switch (type_entry->id) {
3906		case TypeTableEntryIdStruct:
	3906	case ZigTypeIdStruct:
3907	3907	resolve_struct_type(g, type_entry);
3908	3908	break;
3909		case TypeTableEntryIdEnum:
	3909	case ZigTypeIdEnum:
3910	3910	resolve_enum_type(g, type_entry);
3911	3911	break;
3912		case TypeTableEntryIdUnion:
	3912	case ZigTypeIdUnion:
3913	3913	resolve_union_type(g, type_entry);
3914	3914	break;
3915		case TypeTableEntryIdPointer:
3916		case TypeTableEntryIdMetaType:
3917		case TypeTableEntryIdVoid:
3918		case TypeTableEntryIdBool:
3919		case TypeTableEntryIdUnreachable:
3920		case TypeTableEntryIdInt:
3921		case TypeTableEntryIdFloat:
3922		case TypeTableEntryIdArray:
3923		case TypeTableEntryIdComptimeFloat:
3924		case TypeTableEntryIdComptimeInt:
3925		case TypeTableEntryIdUndefined:
3926		case TypeTableEntryIdNull:
3927		case TypeTableEntryIdOptional:
3928		case TypeTableEntryIdErrorUnion:
3929		case TypeTableEntryIdErrorSet:
3930		case TypeTableEntryIdFn:
3931		case TypeTableEntryIdNamespace:
3932		case TypeTableEntryIdBlock:
3933		case TypeTableEntryIdBoundFn:
3934		case TypeTableEntryIdInvalid:
3935		case TypeTableEntryIdArgTuple:
3936		case TypeTableEntryIdOpaque:
3937		case TypeTableEntryIdPromise:
	3915	case ZigTypeIdPointer:
	3916	case ZigTypeIdMetaType:
	3917	case ZigTypeIdVoid:
	3918	case ZigTypeIdBool:
	3919	case ZigTypeIdUnreachable:
	3920	case ZigTypeIdInt:
	3921	case ZigTypeIdFloat:
	3922	case ZigTypeIdArray:
	3923	case ZigTypeIdComptimeFloat:
	3924	case ZigTypeIdComptimeInt:
	3925	case ZigTypeIdUndefined:
	3926	case ZigTypeIdNull:
	3927	case ZigTypeIdOptional:
	3928	case ZigTypeIdErrorUnion:
	3929	case ZigTypeIdErrorSet:
	3930	case ZigTypeIdFn:
	3931	case ZigTypeIdNamespace:
	3932	case ZigTypeIdBlock:
	3933	case ZigTypeIdBoundFn:
	3934	case ZigTypeIdInvalid:
	3935	case ZigTypeIdArgTuple:
	3936	case ZigTypeIdOpaque:
	3937	case ZigTypeIdPromise:
3938	3938	zig_unreachable();
3939	3939	}
3940	3940	}
3941	3941
3942	3942	ZigType get_codegen_ptr_type(ZigType type) {
3943		if (type->id == TypeTableEntryIdPointer) return type;
3944		if (type->id == TypeTableEntryIdFn) return type;
3945		if (type->id == TypeTableEntryIdPromise) return type;
3946		if (type->id == TypeTableEntryIdOptional) {
3947		if (type->data.maybe.child_type->id == TypeTableEntryIdPointer) return type->data.maybe.child_type;
3948		if (type->data.maybe.child_type->id == TypeTableEntryIdFn) return type->data.maybe.child_type;
3949		if (type->data.maybe.child_type->id == TypeTableEntryIdPromise) return type->data.maybe.child_type;
	3943	if (type->id == ZigTypeIdPointer) return type;
	3944	if (type->id == ZigTypeIdFn) return type;
	3945	if (type->id == ZigTypeIdPromise) return type;
	3946	if (type->id == ZigTypeIdOptional) {
	3947	if (type->data.maybe.child_type->id == ZigTypeIdPointer) return type->data.maybe.child_type;
	3948	if (type->data.maybe.child_type->id == ZigTypeIdFn) return type->data.maybe.child_type;
	3949	if (type->data.maybe.child_type->id == ZigTypeIdPromise) return type->data.maybe.child_type;
3950	3950	}
3951	3951	return nullptr;
3952	3952	}
...	...	@@ -3957,11 +3957,11 @@ bool type_is_codegen_pointer(ZigType *type) {
3957	3957
3958	3958	uint32_t get_ptr_align(ZigType *type) {
3959	3959	ZigType *ptr_type = get_codegen_ptr_type(type);
3960		if (ptr_type->id == TypeTableEntryIdPointer) {
	3960	if (ptr_type->id == ZigTypeIdPointer) {
3961	3961	return ptr_type->data.pointer.alignment;
3962		} else if (ptr_type->id == TypeTableEntryIdFn) {
	3962	} else if (ptr_type->id == ZigTypeIdFn) {
3963	3963	return (ptr_type->data.fn.fn_type_id.alignment == 0) ? 1 : ptr_type->data.fn.fn_type_id.alignment;
3964		} else if (ptr_type->id == TypeTableEntryIdPromise) {
	3964	} else if (ptr_type->id == ZigTypeIdPromise) {
3965	3965	return 1;
3966	3966	} else {
3967	3967	zig_unreachable();
...	...	@@ -3970,11 +3970,11 @@ uint32_t get_ptr_align(ZigType *type) {
3970	3970
3971	3971	bool get_ptr_const(ZigType *type) {
3972	3972	ZigType *ptr_type = get_codegen_ptr_type(type);
3973		if (ptr_type->id == TypeTableEntryIdPointer) {
	3973	if (ptr_type->id == ZigTypeIdPointer) {
3974	3974	return ptr_type->data.pointer.is_const;
3975		} else if (ptr_type->id == TypeTableEntryIdFn) {
	3975	} else if (ptr_type->id == ZigTypeIdFn) {
3976	3976	return true;
3977		} else if (ptr_type->id == TypeTableEntryIdPromise) {
	3977	} else if (ptr_type->id == ZigTypeIdPromise) {
3978	3978	return true;
3979	3979	} else {
3980	3980	zig_unreachable();
...	...	@@ -4067,13 +4067,13 @@ void analyze_fn_ir(CodeGen g, ZigFn fn_table_entry, AstNode *return_type_node)
4067	4067	return;
4068	4068	}
4069	4069
4070		if (fn_type_id->return_type->id == TypeTableEntryIdErrorUnion) {
	4070	if (fn_type_id->return_type->id == ZigTypeIdErrorUnion) {
4071	4071	ZigType *return_err_set_type = fn_type_id->return_type->data.error_union.err_set_type;
4072	4072	if (return_err_set_type->data.error_set.infer_fn != nullptr) {
4073	4073	ZigType *inferred_err_set_type;
4074		if (fn_table_entry->src_implicit_return_type->id == TypeTableEntryIdErrorSet) {
	4074	if (fn_table_entry->src_implicit_return_type->id == ZigTypeIdErrorSet) {
4075	4075	inferred_err_set_type = fn_table_entry->src_implicit_return_type;
4076		} else if (fn_table_entry->src_implicit_return_type->id == TypeTableEntryIdErrorUnion) {
	4076	} else if (fn_table_entry->src_implicit_return_type->id == ZigTypeIdErrorUnion) {
4077	4077	inferred_err_set_type = fn_table_entry->src_implicit_return_type->data.error_union.err_set_type;
4078	4078	} else {
4079	4079	add_node_error(g, return_type_node,
...	...	@@ -4154,7 +4154,7 @@ static void add_symbols_from_import(CodeGen g, AstNode src_use_node, AstNode *
4154	4154	}
4155	4155
4156	4156	IrInstruction *use_target_value = src_use_node->data.use.value;
4157		if (use_target_value->value.type->id == TypeTableEntryIdInvalid) {
	4157	if (use_target_value->value.type->id == ZigTypeIdInvalid) {
4158	4158	dst_use_node->owner->any_imports_failed = true;
4159	4159	return;
4160	4160	}
...	...	@@ -4230,7 +4230,7 @@ void preview_use_decl(CodeGen g, AstNode node) {
4230	4230	IrInstruction *result = analyze_const_value(g, &node->owner->decls_scope->base,
4231	4231	node->data.use.expr, g->builtin_types.entry_namespace, nullptr);
4232	4232
4233		if (result->value.type->id == TypeTableEntryIdInvalid)
	4233	if (result->value.type->id == ZigTypeIdInvalid)
4234	4234	node->owner->any_imports_failed = true;
4235	4235
4236	4236	node->data.use.value = result;
...	...	@@ -4357,7 +4357,7 @@ void semantic_analyze(CodeGen *g) {
4357	4357
4358	4358	ZigType get_int_type(CodeGen g, bool is_signed, uint32_t size_in_bits) {
4359	4359	TypeId type_id = {};
4360		type_id.id = TypeTableEntryIdInt;
	4360	type_id.id = ZigTypeIdInt;
4361	4361	type_id.data.integer.is_signed = is_signed;
4362	4362	type_id.data.integer.bit_count = size_in_bits;
4363	4363
...	...	@@ -4382,38 +4382,38 @@ ZigType get_c_int_type(CodeGen g, CIntType c_int_type) {
4382	4382
4383	4383	bool handle_is_ptr(ZigType *type_entry) {
4384	4384	switch (type_entry->id) {
4385		case TypeTableEntryIdInvalid:
4386		case TypeTableEntryIdMetaType:
4387		case TypeTableEntryIdComptimeFloat:
4388		case TypeTableEntryIdComptimeInt:
4389		case TypeTableEntryIdUndefined:
4390		case TypeTableEntryIdNull:
4391		case TypeTableEntryIdNamespace:
4392		case TypeTableEntryIdBlock:
4393		case TypeTableEntryIdBoundFn:
4394		case TypeTableEntryIdArgTuple:
4395		case TypeTableEntryIdOpaque:
	4385	case ZigTypeIdInvalid:
	4386	case ZigTypeIdMetaType:
	4387	case ZigTypeIdComptimeFloat:
	4388	case ZigTypeIdComptimeInt:
	4389	case ZigTypeIdUndefined:
	4390	case ZigTypeIdNull:
	4391	case ZigTypeIdNamespace:
	4392	case ZigTypeIdBlock:
	4393	case ZigTypeIdBoundFn:
	4394	case ZigTypeIdArgTuple:
	4395	case ZigTypeIdOpaque:
4396	4396	zig_unreachable();
4397		case TypeTableEntryIdUnreachable:
4398		case TypeTableEntryIdVoid:
4399		case TypeTableEntryIdBool:
4400		case TypeTableEntryIdInt:
4401		case TypeTableEntryIdFloat:
4402		case TypeTableEntryIdPointer:
4403		case TypeTableEntryIdErrorSet:
4404		case TypeTableEntryIdFn:
4405		case TypeTableEntryIdEnum:
4406		case TypeTableEntryIdPromise:
	4397	case ZigTypeIdUnreachable:
	4398	case ZigTypeIdVoid:
	4399	case ZigTypeIdBool:
	4400	case ZigTypeIdInt:
	4401	case ZigTypeIdFloat:
	4402	case ZigTypeIdPointer:
	4403	case ZigTypeIdErrorSet:
	4404	case ZigTypeIdFn:
	4405	case ZigTypeIdEnum:
	4406	case ZigTypeIdPromise:
4407	4407	return false;
4408		case TypeTableEntryIdArray:
4409		case TypeTableEntryIdStruct:
	4408	case ZigTypeIdArray:
	4409	case ZigTypeIdStruct:
4410	4410	return type_has_bits(type_entry);
4411		case TypeTableEntryIdErrorUnion:
	4411	case ZigTypeIdErrorUnion:
4412	4412	return type_has_bits(type_entry->data.error_union.payload_type);
4413		case TypeTableEntryIdOptional:
	4413	case ZigTypeIdOptional:
4414	4414	return type_has_bits(type_entry->data.maybe.child_type) &&
4415	4415	!type_is_codegen_pointer(type_entry->data.maybe.child_type);
4416		case TypeTableEntryIdUnion:
	4416	case ZigTypeIdUnion:
4417	4417	assert(type_entry->data.unionation.complete);
4418	4418	if (type_entry->data.unionation.gen_field_count == 0)
4419	4419	return false;
...	...	@@ -4697,16 +4697,16 @@ static uint32_t hash_const_val_ptr(ConstExprValue *const_val) {
4697	4697	static uint32_t hash_const_val(ConstExprValue *const_val) {
4698	4698	assert(const_val->special == ConstValSpecialStatic);
4699	4699	switch (const_val->type->id) {
4700		case TypeTableEntryIdOpaque:
	4700	case ZigTypeIdOpaque:
4701	4701	zig_unreachable();
4702		case TypeTableEntryIdBool:
	4702	case ZigTypeIdBool:
4703	4703	return const_val->data.x_bool ? (uint32_t)127863866 : (uint32_t)215080464;
4704		case TypeTableEntryIdMetaType:
	4704	case ZigTypeIdMetaType:
4705	4705	return hash_ptr(const_val->data.x_type);
4706		case TypeTableEntryIdVoid:
	4706	case ZigTypeIdVoid:
4707	4707	return (uint32_t)4149439618;
4708		case TypeTableEntryIdInt:
4709		case TypeTableEntryIdComptimeInt:
	4708	case ZigTypeIdInt:
	4709	case ZigTypeIdComptimeInt:
4710	4710	{
4711	4711	uint32_t result = 1331471175;
4712	4712	for (size_t i = 0; i < const_val->data.x_bigint.digit_count; i += 1) {
...	...	@@ -4715,7 +4715,7 @@ static uint32_t hash_const_val(ConstExprValue *const_val) {
4715	4715	}
4716	4716	return result;
4717	4717	}
4718		case TypeTableEntryIdEnum:
	4718	case ZigTypeIdEnum:
4719	4719	{
4720	4720	uint32_t result = 31643936;
4721	4721	for (size_t i = 0; i < const_val->data.x_enum_tag.digit_count; i += 1) {
...	...	@@ -4724,7 +4724,7 @@ static uint32_t hash_const_val(ConstExprValue *const_val) {
4724	4724	}
4725	4725	return result;
4726	4726	}
4727		case TypeTableEntryIdFloat:
	4727	case ZigTypeIdFloat:
4728	4728	switch (const_val->type->data.floating.bit_count) {
4729	4729	case 16:
4730	4730	{
...	...	@@ -4754,39 +4754,39 @@ static uint32_t hash_const_val(ConstExprValue *const_val) {
4754	4754	default:
4755	4755	zig_unreachable();
4756	4756	}
4757		case TypeTableEntryIdComptimeFloat:
	4757	case ZigTypeIdComptimeFloat:
4758	4758	{
4759	4759	float128_t f128 = bigfloat_to_f128(&const_val->data.x_bigfloat);
4760	4760	uint32_t ints[4];
4761	4761	memcpy(&ints[0], &f128, 16);
4762	4762	return ints[0] ^ ints[1] ^ ints[2] ^ ints[3] ^ 0xed8b3dfb;
4763	4763	}
4764		case TypeTableEntryIdArgTuple:
	4764	case ZigTypeIdArgTuple:
4765	4765	return (uint32_t)const_val->data.x_arg_tuple.start_index * (uint32_t)281907309 +
4766	4766	(uint32_t)const_val->data.x_arg_tuple.end_index * (uint32_t)2290442768;
4767		case TypeTableEntryIdFn:
	4767	case ZigTypeIdFn:
4768	4768	assert(const_val->data.x_ptr.mut == ConstPtrMutComptimeConst);
4769	4769	assert(const_val->data.x_ptr.special == ConstPtrSpecialFunction);
4770	4770	return 3677364617 ^ hash_ptr(const_val->data.x_ptr.data.fn.fn_entry);
4771		case TypeTableEntryIdPointer:
	4771	case ZigTypeIdPointer:
4772	4772	return hash_const_val_ptr(const_val);
4773		case TypeTableEntryIdPromise:
	4773	case ZigTypeIdPromise:
4774	4774	// TODO better hashing algorithm
4775	4775	return 223048345;
4776		case TypeTableEntryIdUndefined:
	4776	case ZigTypeIdUndefined:
4777	4777	return 162837799;
4778		case TypeTableEntryIdNull:
	4778	case ZigTypeIdNull:
4779	4779	return 844854567;
4780		case TypeTableEntryIdArray:
	4780	case ZigTypeIdArray:
4781	4781	// TODO better hashing algorithm
4782	4782	return 1166190605;
4783		case TypeTableEntryIdStruct:
	4783	case ZigTypeIdStruct:
4784	4784	// TODO better hashing algorithm
4785	4785	return 1532530855;
4786		case TypeTableEntryIdUnion:
	4786	case ZigTypeIdUnion:
4787	4787	// TODO better hashing algorithm
4788	4788	return 2709806591;
4789		case TypeTableEntryIdOptional:
	4789	case ZigTypeIdOptional:
4790	4790	if (get_codegen_ptr_type(const_val->type) != nullptr) {
4791	4791	return hash_const_val(const_val) * 1992916303;
4792	4792	} else {
...	...	@@ -4796,19 +4796,19 @@ static uint32_t hash_const_val(ConstExprValue *const_val) {
4796	4796	return 4016830364;
4797	4797	}
4798	4798	}
4799		case TypeTableEntryIdErrorUnion:
	4799	case ZigTypeIdErrorUnion:
4800	4800	// TODO better hashing algorithm
4801	4801	return 3415065496;
4802		case TypeTableEntryIdErrorSet:
	4802	case ZigTypeIdErrorSet:
4803	4803	assert(const_val->data.x_err_set != nullptr);
4804	4804	return const_val->data.x_err_set->value ^ 2630160122;
4805		case TypeTableEntryIdNamespace:
	4805	case ZigTypeIdNamespace:
4806	4806	return hash_ptr(const_val->data.x_import);
4807		case TypeTableEntryIdBlock:
	4807	case ZigTypeIdBlock:
4808	4808	return hash_ptr(const_val->data.x_block);
4809		case TypeTableEntryIdBoundFn:
4810		case TypeTableEntryIdInvalid:
4811		case TypeTableEntryIdUnreachable:
	4809	case ZigTypeIdBoundFn:
	4810	case ZigTypeIdInvalid:
	4811	case ZigTypeIdUnreachable:
4812	4812	zig_unreachable();
4813	4813	}
4814	4814	zig_unreachable();
...	...	@@ -4851,32 +4851,32 @@ bool generic_fn_type_id_eql(GenericFnTypeId a, GenericFnTypeId b) {
4851	4851	static bool can_mutate_comptime_var_state(ConstExprValue *value) {
4852	4852	assert(value != nullptr);
4853	4853	switch (value->type->id) {
4854		case TypeTableEntryIdInvalid:
	4854	case ZigTypeIdInvalid:
4855	4855	zig_unreachable();
4856		case TypeTableEntryIdMetaType:
4857		case TypeTableEntryIdVoid:
4858		case TypeTableEntryIdBool:
4859		case TypeTableEntryIdUnreachable:
4860		case TypeTableEntryIdInt:
4861		case TypeTableEntryIdFloat:
4862		case TypeTableEntryIdComptimeFloat:
4863		case TypeTableEntryIdComptimeInt:
4864		case TypeTableEntryIdUndefined:
4865		case TypeTableEntryIdNull:
4866		case TypeTableEntryIdNamespace:
4867		case TypeTableEntryIdBoundFn:
4868		case TypeTableEntryIdFn:
4869		case TypeTableEntryIdBlock:
4870		case TypeTableEntryIdOpaque:
4871		case TypeTableEntryIdPromise:
4872		case TypeTableEntryIdErrorSet:
4873		case TypeTableEntryIdEnum:
	4856	case ZigTypeIdMetaType:
	4857	case ZigTypeIdVoid:
	4858	case ZigTypeIdBool:
	4859	case ZigTypeIdUnreachable:
	4860	case ZigTypeIdInt:
	4861	case ZigTypeIdFloat:
	4862	case ZigTypeIdComptimeFloat:
	4863	case ZigTypeIdComptimeInt:
	4864	case ZigTypeIdUndefined:
	4865	case ZigTypeIdNull:
	4866	case ZigTypeIdNamespace:
	4867	case ZigTypeIdBoundFn:
	4868	case ZigTypeIdFn:
	4869	case ZigTypeIdBlock:
	4870	case ZigTypeIdOpaque:
	4871	case ZigTypeIdPromise:
	4872	case ZigTypeIdErrorSet:
	4873	case ZigTypeIdEnum:
4874	4874	return false;
4875	4875
4876		case TypeTableEntryIdPointer:
	4876	case ZigTypeIdPointer:
4877	4877	return value->data.x_ptr.mut == ConstPtrMutComptimeVar;
4878	4878
4879		case TypeTableEntryIdArray:
	4879	case ZigTypeIdArray:
4880	4880	if (value->type->data.array.len == 0)
4881	4881	return false;
4882	4882	if (value->data.x_array.special == ConstArraySpecialUndef)
...	...	@@ -4887,30 +4887,30 @@ static bool can_mutate_comptime_var_state(ConstExprValue *value) {
4887	4887	}
4888	4888	return false;
4889	4889
4890		case TypeTableEntryIdStruct:
	4890	case ZigTypeIdStruct:
4891	4891	for (uint32_t i = 0; i < value->type->data.structure.src_field_count; i += 1) {
4892	4892	if (can_mutate_comptime_var_state(&value->data.x_struct.fields[i]))
4893	4893	return true;
4894	4894	}
4895	4895	return false;
4896	4896
4897		case TypeTableEntryIdOptional:
	4897	case ZigTypeIdOptional:
4898	4898	if (get_codegen_ptr_type(value->type) != nullptr)
4899	4899	return value->data.x_ptr.mut == ConstPtrMutComptimeVar;
4900	4900	if (value->data.x_optional == nullptr)
4901	4901	return false;
4902	4902	return can_mutate_comptime_var_state(value->data.x_optional);
4903	4903
4904		case TypeTableEntryIdErrorUnion:
	4904	case ZigTypeIdErrorUnion:
4905	4905	if (value->data.x_err_union.err != nullptr)
4906	4906	return false;
4907	4907	assert(value->data.x_err_union.payload != nullptr);
4908	4908	return can_mutate_comptime_var_state(value->data.x_err_union.payload);
4909	4909
4910		case TypeTableEntryIdUnion:
	4910	case ZigTypeIdUnion:
4911	4911	return can_mutate_comptime_var_state(value->data.x_union.payload);
4912	4912
4913		case TypeTableEntryIdArgTuple:
	4913	case ZigTypeIdArgTuple:
4914	4914	zig_panic("TODO var args at comptime is currently not supported");
4915	4915	}
4916	4916	zig_unreachable();
...	...	@@ -4918,41 +4918,41 @@ static bool can_mutate_comptime_var_state(ConstExprValue *value) {
4918	4918
4919	4919	static bool return_type_is_cacheable(ZigType *return_type) {
4920	4920	switch (return_type->id) {
4921		case TypeTableEntryIdInvalid:
	4921	case ZigTypeIdInvalid:
4922	4922	zig_unreachable();
4923		case TypeTableEntryIdMetaType:
4924		case TypeTableEntryIdVoid:
4925		case TypeTableEntryIdBool:
4926		case TypeTableEntryIdUnreachable:
4927		case TypeTableEntryIdInt:
4928		case TypeTableEntryIdFloat:
4929		case TypeTableEntryIdComptimeFloat:
4930		case TypeTableEntryIdComptimeInt:
4931		case TypeTableEntryIdUndefined:
4932		case TypeTableEntryIdNull:
4933		case TypeTableEntryIdNamespace:
4934		case TypeTableEntryIdBoundFn:
4935		case TypeTableEntryIdFn:
4936		case TypeTableEntryIdBlock:
4937		case TypeTableEntryIdOpaque:
4938		case TypeTableEntryIdPromise:
4939		case TypeTableEntryIdErrorSet:
4940		case TypeTableEntryIdEnum:
4941		case TypeTableEntryIdPointer:
	4923	case ZigTypeIdMetaType:
	4924	case ZigTypeIdVoid:
	4925	case ZigTypeIdBool:
	4926	case ZigTypeIdUnreachable:
	4927	case ZigTypeIdInt:
	4928	case ZigTypeIdFloat:
	4929	case ZigTypeIdComptimeFloat:
	4930	case ZigTypeIdComptimeInt:
	4931	case ZigTypeIdUndefined:
	4932	case ZigTypeIdNull:
	4933	case ZigTypeIdNamespace:
	4934	case ZigTypeIdBoundFn:
	4935	case ZigTypeIdFn:
	4936	case ZigTypeIdBlock:
	4937	case ZigTypeIdOpaque:
	4938	case ZigTypeIdPromise:
	4939	case ZigTypeIdErrorSet:
	4940	case ZigTypeIdEnum:
	4941	case ZigTypeIdPointer:
4942	4942	return true;
4943	4943
4944		case TypeTableEntryIdArray:
4945		case TypeTableEntryIdStruct:
4946		case TypeTableEntryIdUnion:
	4944	case ZigTypeIdArray:
	4945	case ZigTypeIdStruct:
	4946	case ZigTypeIdUnion:
4947	4947	return false;
4948	4948
4949		case TypeTableEntryIdOptional:
	4949	case ZigTypeIdOptional:
4950	4950	return return_type_is_cacheable(return_type->data.maybe.child_type);
4951	4951
4952		case TypeTableEntryIdErrorUnion:
	4952	case ZigTypeIdErrorUnion:
4953	4953	return return_type_is_cacheable(return_type->data.error_union.payload_type);
4954	4954
4955		case TypeTableEntryIdArgTuple:
	4955	case ZigTypeIdArgTuple:
4956	4956	zig_panic("TODO var args at comptime is currently not supported");
4957	4957	}
4958	4958	zig_unreachable();
...	...	@@ -5029,54 +5029,54 @@ bool fn_eval_eql(Scope a, Scope b) {
5029	5029
5030	5030	bool type_has_bits(ZigType *type_entry) {
5031	5031	assert(type_entry);
5032		assert(type_entry->id != TypeTableEntryIdInvalid);
	5032	assert(type_entry->id != ZigTypeIdInvalid);
5033	5033	assert(type_has_zero_bits_known(type_entry));
5034	5034	return !type_entry->zero_bits;
5035	5035	}
5036	5036
5037	5037	bool type_requires_comptime(ZigType *type_entry) {
5038	5038	switch (type_entry->id) {
5039		case TypeTableEntryIdInvalid:
5040		case TypeTableEntryIdOpaque:
	5039	case ZigTypeIdInvalid:
	5040	case ZigTypeIdOpaque:
5041	5041	zig_unreachable();
5042		case TypeTableEntryIdComptimeFloat:
5043		case TypeTableEntryIdComptimeInt:
5044		case TypeTableEntryIdUndefined:
5045		case TypeTableEntryIdNull:
5046		case TypeTableEntryIdMetaType:
5047		case TypeTableEntryIdNamespace:
5048		case TypeTableEntryIdBlock:
5049		case TypeTableEntryIdBoundFn:
5050		case TypeTableEntryIdArgTuple:
	5042	case ZigTypeIdComptimeFloat:
	5043	case ZigTypeIdComptimeInt:
	5044	case ZigTypeIdUndefined:
	5045	case ZigTypeIdNull:
	5046	case ZigTypeIdMetaType:
	5047	case ZigTypeIdNamespace:
	5048	case ZigTypeIdBlock:
	5049	case ZigTypeIdBoundFn:
	5050	case ZigTypeIdArgTuple:
5051	5051	return true;
5052		case TypeTableEntryIdArray:
	5052	case ZigTypeIdArray:
5053	5053	return type_requires_comptime(type_entry->data.array.child_type);
5054		case TypeTableEntryIdStruct:
	5054	case ZigTypeIdStruct:
5055	5055	assert(type_has_zero_bits_known(type_entry));
5056	5056	return type_entry->data.structure.requires_comptime;
5057		case TypeTableEntryIdUnion:
	5057	case ZigTypeIdUnion:
5058	5058	assert(type_has_zero_bits_known(type_entry));
5059	5059	return type_entry->data.unionation.requires_comptime;
5060		case TypeTableEntryIdOptional:
	5060	case ZigTypeIdOptional:
5061	5061	return type_requires_comptime(type_entry->data.maybe.child_type);
5062		case TypeTableEntryIdErrorUnion:
	5062	case ZigTypeIdErrorUnion:
5063	5063	return type_requires_comptime(type_entry->data.error_union.payload_type);
5064		case TypeTableEntryIdPointer:
5065		if (type_entry->data.pointer.child_type->id == TypeTableEntryIdOpaque) {
	5064	case ZigTypeIdPointer:
	5065	if (type_entry->data.pointer.child_type->id == ZigTypeIdOpaque) {
5066	5066	return false;
5067	5067	} else {
5068	5068	return type_requires_comptime(type_entry->data.pointer.child_type);
5069	5069	}
5070		case TypeTableEntryIdFn:
	5070	case ZigTypeIdFn:
5071	5071	return type_entry->data.fn.is_generic;
5072		case TypeTableEntryIdEnum:
5073		case TypeTableEntryIdErrorSet:
5074		case TypeTableEntryIdBool:
5075		case TypeTableEntryIdInt:
5076		case TypeTableEntryIdFloat:
5077		case TypeTableEntryIdVoid:
5078		case TypeTableEntryIdUnreachable:
5079		case TypeTableEntryIdPromise:
	5072	case ZigTypeIdEnum:
	5073	case ZigTypeIdErrorSet:
	5074	case ZigTypeIdBool:
	5075	case ZigTypeIdInt:
	5076	case ZigTypeIdFloat:
	5077	case ZigTypeIdVoid:
	5078	case ZigTypeIdUnreachable:
	5079	case ZigTypeIdPromise:
5080	5080	return false;
5081	5081	}
5082	5082	zig_unreachable();
...	...	@@ -5192,9 +5192,9 @@ ConstExprValue create_const_signed(ZigType type, int64_t x) {
5192	5192	void init_const_float(ConstExprValue const_val, ZigType type, double value) {
5193	5193	const_val->special = ConstValSpecialStatic;
5194	5194	const_val->type = type;
5195		if (type->id == TypeTableEntryIdComptimeFloat) {
	5195	if (type->id == ZigTypeIdComptimeFloat) {
5196	5196	bigfloat_init_64(&const_val->data.x_bigfloat, value);
5197		} else if (type->id == TypeTableEntryIdFloat) {
	5197	} else if (type->id == ZigTypeIdFloat) {
5198	5198	switch (type->data.floating.bit_count) {
5199	5199	case 16:
5200	5200	const_val->data.x_f16 = zig_double_to_f16(value);
...	...	@@ -5273,7 +5273,7 @@ ConstExprValue create_const_type(CodeGen g, ZigType *type_value) {
5273	5273	void init_const_slice(CodeGen g, ConstExprValue const_val, ConstExprValue *array_val,
5274	5274	size_t start, size_t len, bool is_const)
5275	5275	{
5276		assert(array_val->type->id == TypeTableEntryIdArray);
	5276	assert(array_val->type->id == ZigTypeIdArray);
5277	5277
5278	5278	ZigType *ptr_type = get_pointer_to_type_extra(g, array_val->type->data.array.child_type,
5279	5279	is_const, false, PtrLenUnknown, get_abi_alignment(g, array_val->type->data.array.child_type),
...	...	@@ -5297,7 +5297,7 @@ ConstExprValue create_const_slice(CodeGen g, ConstExprValue *array_val, size_t
5297	5297	void init_const_ptr_array(CodeGen g, ConstExprValue const_val, ConstExprValue *array_val,
5298	5298	size_t elem_index, bool is_const, PtrLen ptr_len)
5299	5299	{
5300		assert(array_val->type->id == TypeTableEntryIdArray);
	5300	assert(array_val->type->id == ZigTypeIdArray);
5301	5301	ZigType *child_type = array_val->type->data.array.child_type;
5302	5302
5303	5303	const_val->special = ConstValSpecialStatic;
...	...	@@ -5363,10 +5363,10 @@ ConstExprValue create_const_arg_tuple(CodeGen g, size_t arg_index_start, size_
5363	5363	void init_const_undefined(CodeGen g, ConstExprValue const_val) {
5364	5364	Error err;
5365	5365	ZigType *wanted_type = const_val->type;
5366		if (wanted_type->id == TypeTableEntryIdArray) {
	5366	if (wanted_type->id == ZigTypeIdArray) {
5367	5367	const_val->special = ConstValSpecialStatic;
5368	5368	const_val->data.x_array.special = ConstArraySpecialUndef;
5369		} else if (wanted_type->id == TypeTableEntryIdStruct) {
	5369	} else if (wanted_type->id == ZigTypeIdStruct) {
5370	5370	if ((err = ensure_complete_type(g, wanted_type))) {
5371	5371	return;
5372	5372	}
...	...	@@ -5403,13 +5403,13 @@ ConstExprValue *create_const_vals(size_t count) {
5403	5403	Error ensure_complete_type(CodeGen g, ZigType type_entry) {
5404	5404	if (type_is_invalid(type_entry))
5405	5405	return ErrorSemanticAnalyzeFail;
5406		if (type_entry->id == TypeTableEntryIdStruct) {
	5406	if (type_entry->id == ZigTypeIdStruct) {
5407	5407	if (!type_entry->data.structure.complete)
5408	5408	return resolve_struct_type(g, type_entry);
5409		} else if (type_entry->id == TypeTableEntryIdEnum) {
	5409	} else if (type_entry->id == ZigTypeIdEnum) {
5410	5410	if (!type_entry->data.enumeration.complete)
5411	5411	return resolve_enum_type(g, type_entry);
5412		} else if (type_entry->id == TypeTableEntryIdUnion) {
	5412	} else if (type_entry->id == ZigTypeIdUnion) {
5413	5413	if (!type_entry->data.unionation.complete)
5414	5414	return resolve_union_type(g, type_entry);
5415	5415	}
...	...	@@ -5419,11 +5419,11 @@ Error ensure_complete_type(CodeGen g, ZigType type_entry) {
5419	5419	Error type_ensure_zero_bits_known(CodeGen g, ZigType type_entry) {
5420	5420	if (type_is_invalid(type_entry))
5421	5421	return ErrorSemanticAnalyzeFail;
5422		if (type_entry->id == TypeTableEntryIdStruct) {
	5422	if (type_entry->id == ZigTypeIdStruct) {
5423	5423	return resolve_struct_zero_bits(g, type_entry);
5424		} else if (type_entry->id == TypeTableEntryIdEnum) {
	5424	} else if (type_entry->id == ZigTypeIdEnum) {
5425	5425	return resolve_enum_zero_bits(g, type_entry);
5426		} else if (type_entry->id == TypeTableEntryIdUnion) {
	5426	} else if (type_entry->id == ZigTypeIdUnion) {
5427	5427	return resolve_union_zero_bits(g, type_entry);
5428	5428	}
5429	5429	return ErrorNone;
...	...	@@ -5488,11 +5488,11 @@ bool const_values_equal(ConstExprValue a, ConstExprValue b) {
5488	5488	assert(a->special == ConstValSpecialStatic);
5489	5489	assert(b->special == ConstValSpecialStatic);
5490	5490	switch (a->type->id) {
5491		case TypeTableEntryIdOpaque:
	5491	case ZigTypeIdOpaque:
5492	5492	zig_unreachable();
5493		case TypeTableEntryIdEnum:
	5493	case ZigTypeIdEnum:
5494	5494	return bigint_cmp(&a->data.x_enum_tag, &b->data.x_enum_tag) == CmpEQ;
5495		case TypeTableEntryIdUnion: {
	5495	case ZigTypeIdUnion: {
5496	5496	ConstUnionValue *union1 = &a->data.x_union;
5497	5497	ConstUnionValue *union2 = &b->data.x_union;
5498	5498
...	...	@@ -5507,15 +5507,15 @@ bool const_values_equal(ConstExprValue a, ConstExprValue b) {
5507	5507	}
5508	5508	return false;
5509	5509	}
5510		case TypeTableEntryIdMetaType:
	5510	case ZigTypeIdMetaType:
5511	5511	return a->data.x_type == b->data.x_type;
5512		case TypeTableEntryIdVoid:
	5512	case ZigTypeIdVoid:
5513	5513	return true;
5514		case TypeTableEntryIdErrorSet:
	5514	case ZigTypeIdErrorSet:
5515	5515	return a->data.x_err_set->value == b->data.x_err_set->value;
5516		case TypeTableEntryIdBool:
	5516	case ZigTypeIdBool:
5517	5517	return a->data.x_bool == b->data.x_bool;
5518		case TypeTableEntryIdFloat:
	5518	case ZigTypeIdFloat:
5519	5519	assert(a->type->data.floating.bit_count == b->type->data.floating.bit_count);
5520	5520	switch (a->type->data.floating.bit_count) {
5521	5521	case 16:
...	...	@@ -5529,15 +5529,15 @@ bool const_values_equal(ConstExprValue a, ConstExprValue b) {
5529	5529	default:
5530	5530	zig_unreachable();
5531	5531	}
5532		case TypeTableEntryIdComptimeFloat:
	5532	case ZigTypeIdComptimeFloat:
5533	5533	return bigfloat_cmp(&a->data.x_bigfloat, &b->data.x_bigfloat) == CmpEQ;
5534		case TypeTableEntryIdInt:
5535		case TypeTableEntryIdComptimeInt:
	5534	case ZigTypeIdInt:
	5535	case ZigTypeIdComptimeInt:
5536	5536	return bigint_cmp(&a->data.x_bigint, &b->data.x_bigint) == CmpEQ;
5537		case TypeTableEntryIdPointer:
5538		case TypeTableEntryIdFn:
	5537	case ZigTypeIdPointer:
	5538	case ZigTypeIdFn:
5539	5539	return const_values_equal_ptr(a, b);
5540		case TypeTableEntryIdArray: {
	5540	case ZigTypeIdArray: {
5541	5541	assert(a->type->data.array.len == b->type->data.array.len);
5542	5542	assert(a->data.x_array.special != ConstArraySpecialUndef);
5543	5543	assert(b->data.x_array.special != ConstArraySpecialUndef);
...	...	@@ -5553,7 +5553,7 @@ bool const_values_equal(ConstExprValue a, ConstExprValue b) {
5553	5553
5554	5554	return true;
5555	5555	}
5556		case TypeTableEntryIdStruct:
	5556	case ZigTypeIdStruct:
5557	5557	for (size_t i = 0; i < a->type->data.structure.src_field_count; i += 1) {
5558	5558	ConstExprValue *field_a = &a->data.x_struct.fields[i];
5559	5559	ConstExprValue *field_b = &b->data.x_struct.fields[i];
...	...	@@ -5561,11 +5561,11 @@ bool const_values_equal(ConstExprValue a, ConstExprValue b) {
5561	5561	return false;
5562	5562	}
5563	5563	return true;
5564		case TypeTableEntryIdUndefined:
	5564	case ZigTypeIdUndefined:
5565	5565	zig_panic("TODO");
5566		case TypeTableEntryIdNull:
	5566	case ZigTypeIdNull:
5567	5567	zig_panic("TODO");
5568		case TypeTableEntryIdOptional:
	5568	case ZigTypeIdOptional:
5569	5569	if (get_codegen_ptr_type(a->type) != nullptr)
5570	5570	return const_values_equal_ptr(a, b);
5571	5571	if (a->data.x_optional == nullptr \|\| b->data.x_optional == nullptr) {
...	...	@@ -5573,26 +5573,26 @@ bool const_values_equal(ConstExprValue a, ConstExprValue b) {
5573	5573	} else {
5574	5574	return const_values_equal(a->data.x_optional, b->data.x_optional);
5575	5575	}
5576		case TypeTableEntryIdErrorUnion:
	5576	case ZigTypeIdErrorUnion:
5577	5577	zig_panic("TODO");
5578		case TypeTableEntryIdNamespace:
	5578	case ZigTypeIdNamespace:
5579	5579	return a->data.x_import == b->data.x_import;
5580		case TypeTableEntryIdBlock:
	5580	case ZigTypeIdBlock:
5581	5581	return a->data.x_block == b->data.x_block;
5582		case TypeTableEntryIdArgTuple:
	5582	case ZigTypeIdArgTuple:
5583	5583	return a->data.x_arg_tuple.start_index == b->data.x_arg_tuple.start_index &&
5584	5584	a->data.x_arg_tuple.end_index == b->data.x_arg_tuple.end_index;
5585		case TypeTableEntryIdBoundFn:
5586		case TypeTableEntryIdInvalid:
5587		case TypeTableEntryIdUnreachable:
5588		case TypeTableEntryIdPromise:
	5585	case ZigTypeIdBoundFn:
	5586	case ZigTypeIdInvalid:
	5587	case ZigTypeIdUnreachable:
	5588	case ZigTypeIdPromise:
5589	5589	zig_unreachable();
5590	5590	}
5591	5591	zig_unreachable();
5592	5592	}
5593	5593
5594	5594	void eval_min_max_value_int(CodeGen g, ZigType int_type, BigInt *bigint, bool is_max) {
5595		assert(int_type->id == TypeTableEntryIdInt);
	5595	assert(int_type->id == ZigTypeIdInt);
5596	5596	if (int_type->data.integral.bit_count == 0) {
5597	5597	bigint_init_unsigned(bigint, 0);
5598	5598	return;
...	...	@@ -5629,13 +5629,13 @@ void eval_min_max_value_int(CodeGen g, ZigType int_type, BigInt *bigint, bool
5629	5629	}
5630	5630
5631	5631	void eval_min_max_value(CodeGen g, ZigType type_entry, ConstExprValue *const_val, bool is_max) {
5632		if (type_entry->id == TypeTableEntryIdInt) {
	5632	if (type_entry->id == ZigTypeIdInt) {
5633	5633	const_val->special = ConstValSpecialStatic;
5634	5634	eval_min_max_value_int(g, type_entry, &const_val->data.x_bigint, is_max);
5635		} else if (type_entry->id == TypeTableEntryIdBool) {
	5635	} else if (type_entry->id == ZigTypeIdBool) {
5636	5636	const_val->special = ConstValSpecialStatic;
5637	5637	const_val->data.x_bool = is_max;
5638		} else if (type_entry->id == TypeTableEntryIdVoid) {
	5638	} else if (type_entry->id == ZigTypeIdVoid) {
5639	5639	// nothing to do
5640	5640	} else {
5641	5641	zig_unreachable();
...	...	@@ -5692,18 +5692,18 @@ void render_const_value(CodeGen g, Buf buf, ConstExprValue *const_val) {
5692	5692
5693	5693	ZigType *type_entry = const_val->type;
5694	5694	switch (type_entry->id) {
5695		case TypeTableEntryIdOpaque:
	5695	case ZigTypeIdOpaque:
5696	5696	zig_unreachable();
5697		case TypeTableEntryIdInvalid:
	5697	case ZigTypeIdInvalid:
5698	5698	buf_appendf(buf, "(invalid)");
5699	5699	return;
5700		case TypeTableEntryIdVoid:
	5700	case ZigTypeIdVoid:
5701	5701	buf_appendf(buf, "{}");
5702	5702	return;
5703		case TypeTableEntryIdComptimeFloat:
	5703	case ZigTypeIdComptimeFloat:
5704	5704	bigfloat_append_buf(buf, &const_val->data.x_bigfloat);
5705	5705	return;
5706		case TypeTableEntryIdFloat:
	5706	case ZigTypeIdFloat:
5707	5707	switch (type_entry->data.floating.bit_count) {
5708	5708	case 16:
5709	5709	buf_appendf(buf, "%f", zig_f16_to_double(const_val->data.x_f16));
...	...	@@ -5731,23 +5731,23 @@ void render_const_value(CodeGen g, Buf buf, ConstExprValue *const_val) {
5731	5731	default:
5732	5732	zig_unreachable();
5733	5733	}
5734		case TypeTableEntryIdComptimeInt:
5735		case TypeTableEntryIdInt:
	5734	case ZigTypeIdComptimeInt:
	5735	case ZigTypeIdInt:
5736	5736	bigint_append_buf(buf, &const_val->data.x_bigint, 10);
5737	5737	return;
5738		case TypeTableEntryIdMetaType:
	5738	case ZigTypeIdMetaType:
5739	5739	buf_appendf(buf, "%s", buf_ptr(&const_val->data.x_type->name));
5740	5740	return;
5741		case TypeTableEntryIdUnreachable:
	5741	case ZigTypeIdUnreachable:
5742	5742	buf_appendf(buf, "unreachable");
5743	5743	return;
5744		case TypeTableEntryIdBool:
	5744	case ZigTypeIdBool:
5745	5745	{
5746	5746	const char *value = const_val->data.x_bool ? "true" : "false";
5747	5747	buf_appendf(buf, "%s", value);
5748	5748	return;
5749	5749	}
5750		case TypeTableEntryIdFn:
	5750	case ZigTypeIdFn:
5751	5751	{
5752	5752	assert(const_val->data.x_ptr.mut == ConstPtrMutComptimeConst);
5753	5753	assert(const_val->data.x_ptr.special == ConstPtrSpecialFunction);
...	...	@@ -5755,15 +5755,15 @@ void render_const_value(CodeGen g, Buf buf, ConstExprValue *const_val) {
5755	5755	buf_appendf(buf, "%s", buf_ptr(&fn_entry->symbol_name));
5756	5756	return;
5757	5757	}
5758		case TypeTableEntryIdPointer:
	5758	case ZigTypeIdPointer:
5759	5759	return render_const_val_ptr(g, buf, const_val, type_entry);
5760		case TypeTableEntryIdBlock:
	5760	case ZigTypeIdBlock:
5761	5761	{
5762	5762	AstNode *node = const_val->data.x_block->source_node;
5763	5763	buf_appendf(buf, "(scope:%" ZIG_PRI_usize ":%" ZIG_PRI_usize ")", node->line + 1, node->column + 1);
5764	5764	return;
5765	5765	}
5766		case TypeTableEntryIdArray:
	5766	case ZigTypeIdArray:
5767	5767	{
5768	5768	ZigType *child_type = type_entry->data.array.child_type;
5769	5769	uint64_t len = type_entry->data.array.len;
...	...	@@ -5774,7 +5774,7 @@ void render_const_value(CodeGen g, Buf buf, ConstExprValue *const_val) {
5774	5774	}
5775	5775
5776	5776	// if it's []u8, assume UTF-8 and output a string
5777		if (child_type->id == TypeTableEntryIdInt &&
	5777	if (child_type->id == ZigTypeIdInt &&
5778	5778	child_type->data.integral.bit_count == 8 &&
5779	5779	!child_type->data.integral.is_signed)
5780	5780	{
...	...	@@ -5804,17 +5804,17 @@ void render_const_value(CodeGen g, Buf buf, ConstExprValue *const_val) {
5804	5804	buf_appendf(buf, "}");
5805	5805	return;
5806	5806	}
5807		case TypeTableEntryIdNull:
	5807	case ZigTypeIdNull:
5808	5808	{
5809	5809	buf_appendf(buf, "null");
5810	5810	return;
5811	5811	}
5812		case TypeTableEntryIdUndefined:
	5812	case ZigTypeIdUndefined:
5813	5813	{
5814	5814	buf_appendf(buf, "undefined");
5815	5815	return;
5816	5816	}
5817		case TypeTableEntryIdOptional:
	5817	case ZigTypeIdOptional:
5818	5818	{
5819	5819	if (get_codegen_ptr_type(const_val->type) != nullptr)
5820	5820	return render_const_val_ptr(g, buf, const_val, type_entry->data.maybe.child_type);
...	...	@@ -5825,7 +5825,7 @@ void render_const_value(CodeGen g, Buf buf, ConstExprValue *const_val) {
5825	5825	}
5826	5826	return;
5827	5827	}
5828		case TypeTableEntryIdNamespace:
	5828	case ZigTypeIdNamespace:
5829	5829	{
5830	5830	ImportTableEntry *import = const_val->data.x_import;
5831	5831	if (import->c_import_node) {
...	...	@@ -5835,51 +5835,51 @@ void render_const_value(CodeGen g, Buf buf, ConstExprValue *const_val) {
5835	5835	}
5836	5836	return;
5837	5837	}
5838		case TypeTableEntryIdBoundFn:
	5838	case ZigTypeIdBoundFn:
5839	5839	{
5840	5840	ZigFn *fn_entry = const_val->data.x_bound_fn.fn;
5841	5841	buf_appendf(buf, "(bound fn %s)", buf_ptr(&fn_entry->symbol_name));
5842	5842	return;
5843	5843	}
5844		case TypeTableEntryIdStruct:
	5844	case ZigTypeIdStruct:
5845	5845	{
5846	5846	buf_appendf(buf, "(struct %s constant)", buf_ptr(&type_entry->name));
5847	5847	return;
5848	5848	}
5849		case TypeTableEntryIdEnum:
	5849	case ZigTypeIdEnum:
5850	5850	{
5851	5851	TypeEnumField *field = find_enum_field_by_tag(type_entry, &const_val->data.x_enum_tag);
5852	5852	buf_appendf(buf, "%s.%s", buf_ptr(&type_entry->name), buf_ptr(field->name));
5853	5853	return;
5854	5854	}
5855		case TypeTableEntryIdErrorUnion:
	5855	case ZigTypeIdErrorUnion:
5856	5856	{
5857	5857	buf_appendf(buf, "(error union %s constant)", buf_ptr(&type_entry->name));
5858	5858	return;
5859	5859	}
5860		case TypeTableEntryIdUnion:
	5860	case ZigTypeIdUnion:
5861	5861	{
5862	5862	buf_appendf(buf, "(union %s constant)", buf_ptr(&type_entry->name));
5863	5863	return;
5864	5864	}
5865		case TypeTableEntryIdErrorSet:
	5865	case ZigTypeIdErrorSet:
5866	5866	{
5867	5867	buf_appendf(buf, "%s.%s", buf_ptr(&type_entry->name), buf_ptr(&const_val->data.x_err_set->name));
5868	5868	return;
5869	5869	}
5870		case TypeTableEntryIdArgTuple:
	5870	case ZigTypeIdArgTuple:
5871	5871	{
5872	5872	buf_appendf(buf, "(args value)");
5873	5873	return;
5874	5874	}
5875		case TypeTableEntryIdPromise:
	5875	case ZigTypeIdPromise:
5876	5876	zig_unreachable();
5877	5877	}
5878	5878	zig_unreachable();
5879	5879	}
5880	5880
5881	5881	ZigType make_int_type(CodeGen g, bool is_signed, uint32_t size_in_bits) {
5882		ZigType *entry = new_type_table_entry(TypeTableEntryIdInt);
	5882	ZigType *entry = new_type_table_entry(ZigTypeIdInt);
5883	5883	entry->is_copyable = true;
5884	5884	entry->type_ref = (size_in_bits == 0) ? LLVMVoidType() : LLVMIntType(size_in_bits);
5885	5885	entry->zero_bits = (size_in_bits == 0);
...	...	@@ -5913,32 +5913,32 @@ ZigType make_int_type(CodeGen g, bool is_signed, uint32_t size_in_bits) {
5913	5913
5914	5914	uint32_t type_id_hash(TypeId x) {
5915	5915	switch (x.id) {
5916		case TypeTableEntryIdInvalid:
5917		case TypeTableEntryIdOpaque:
5918		case TypeTableEntryIdMetaType:
5919		case TypeTableEntryIdVoid:
5920		case TypeTableEntryIdBool:
5921		case TypeTableEntryIdUnreachable:
5922		case TypeTableEntryIdFloat:
5923		case TypeTableEntryIdStruct:
5924		case TypeTableEntryIdComptimeFloat:
5925		case TypeTableEntryIdComptimeInt:
5926		case TypeTableEntryIdUndefined:
5927		case TypeTableEntryIdNull:
5928		case TypeTableEntryIdOptional:
5929		case TypeTableEntryIdErrorSet:
5930		case TypeTableEntryIdEnum:
5931		case TypeTableEntryIdUnion:
5932		case TypeTableEntryIdFn:
5933		case TypeTableEntryIdNamespace:
5934		case TypeTableEntryIdBlock:
5935		case TypeTableEntryIdBoundFn:
5936		case TypeTableEntryIdArgTuple:
5937		case TypeTableEntryIdPromise:
	5916	case ZigTypeIdInvalid:
	5917	case ZigTypeIdOpaque:
	5918	case ZigTypeIdMetaType:
	5919	case ZigTypeIdVoid:
	5920	case ZigTypeIdBool:
	5921	case ZigTypeIdUnreachable:
	5922	case ZigTypeIdFloat:
	5923	case ZigTypeIdStruct:
	5924	case ZigTypeIdComptimeFloat:
	5925	case ZigTypeIdComptimeInt:
	5926	case ZigTypeIdUndefined:
	5927	case ZigTypeIdNull:
	5928	case ZigTypeIdOptional:
	5929	case ZigTypeIdErrorSet:
	5930	case ZigTypeIdEnum:
	5931	case ZigTypeIdUnion:
	5932	case ZigTypeIdFn:
	5933	case ZigTypeIdNamespace:
	5934	case ZigTypeIdBlock:
	5935	case ZigTypeIdBoundFn:
	5936	case ZigTypeIdArgTuple:
	5937	case ZigTypeIdPromise:
5938	5938	zig_unreachable();
5939		case TypeTableEntryIdErrorUnion:
	5939	case ZigTypeIdErrorUnion:
5940	5940	return hash_ptr(x.data.error_union.err_set_type) ^ hash_ptr(x.data.error_union.payload_type);
5941		case TypeTableEntryIdPointer:
	5941	case ZigTypeIdPointer:
5942	5942	return hash_ptr(x.data.pointer.child_type) +
5943	5943	((x.data.pointer.ptr_len == PtrLenSingle) ? (uint32_t)1120226602 : (uint32_t)3200913342) +
5944	5944	(x.data.pointer.is_const ? (uint32_t)2749109194 : (uint32_t)4047371087) +
...	...	@@ -5946,10 +5946,10 @@ uint32_t type_id_hash(TypeId x) {
5946	5946	(((uint32_t)x.data.pointer.alignment) ^ (uint32_t)0x777fbe0e) +
5947	5947	(((uint32_t)x.data.pointer.bit_offset) ^ (uint32_t)2639019452) +
5948	5948	(((uint32_t)x.data.pointer.unaligned_bit_count) ^ (uint32_t)529908881);
5949		case TypeTableEntryIdArray:
	5949	case ZigTypeIdArray:
5950	5950	return hash_ptr(x.data.array.child_type) +
5951	5951	((uint32_t)x.data.array.size ^ (uint32_t)2122979968);
5952		case TypeTableEntryIdInt:
	5952	case ZigTypeIdInt:
5953	5953	return (x.data.integer.is_signed ? (uint32_t)2652528194 : (uint32_t)163929201) +
5954	5954	(((uint32_t)x.data.integer.bit_count) ^ (uint32_t)2998081557);
5955	5955	}
...	...	@@ -5960,34 +5960,34 @@ bool type_id_eql(TypeId a, TypeId b) {
5960	5960	if (a.id != b.id)
5961	5961	return false;
5962	5962	switch (a.id) {
5963		case TypeTableEntryIdInvalid:
5964		case TypeTableEntryIdMetaType:
5965		case TypeTableEntryIdVoid:
5966		case TypeTableEntryIdBool:
5967		case TypeTableEntryIdUnreachable:
5968		case TypeTableEntryIdFloat:
5969		case TypeTableEntryIdStruct:
5970		case TypeTableEntryIdComptimeFloat:
5971		case TypeTableEntryIdComptimeInt:
5972		case TypeTableEntryIdUndefined:
5973		case TypeTableEntryIdNull:
5974		case TypeTableEntryIdOptional:
5975		case TypeTableEntryIdPromise:
5976		case TypeTableEntryIdErrorSet:
5977		case TypeTableEntryIdEnum:
5978		case TypeTableEntryIdUnion:
5979		case TypeTableEntryIdFn:
5980		case TypeTableEntryIdNamespace:
5981		case TypeTableEntryIdBlock:
5982		case TypeTableEntryIdBoundFn:
5983		case TypeTableEntryIdArgTuple:
5984		case TypeTableEntryIdOpaque:
	5963	case ZigTypeIdInvalid:
	5964	case ZigTypeIdMetaType:
	5965	case ZigTypeIdVoid:
	5966	case ZigTypeIdBool:
	5967	case ZigTypeIdUnreachable:
	5968	case ZigTypeIdFloat:
	5969	case ZigTypeIdStruct:
	5970	case ZigTypeIdComptimeFloat:
	5971	case ZigTypeIdComptimeInt:
	5972	case ZigTypeIdUndefined:
	5973	case ZigTypeIdNull:
	5974	case ZigTypeIdOptional:
	5975	case ZigTypeIdPromise:
	5976	case ZigTypeIdErrorSet:
	5977	case ZigTypeIdEnum:
	5978	case ZigTypeIdUnion:
	5979	case ZigTypeIdFn:
	5980	case ZigTypeIdNamespace:
	5981	case ZigTypeIdBlock:
	5982	case ZigTypeIdBoundFn:
	5983	case ZigTypeIdArgTuple:
	5984	case ZigTypeIdOpaque:
5985	5985	zig_unreachable();
5986		case TypeTableEntryIdErrorUnion:
	5986	case ZigTypeIdErrorUnion:
5987	5987	return a.data.error_union.err_set_type == b.data.error_union.err_set_type &&
5988	5988	a.data.error_union.payload_type == b.data.error_union.payload_type;
5989	5989
5990		case TypeTableEntryIdPointer:
	5990	case ZigTypeIdPointer:
5991	5991	return a.data.pointer.child_type == b.data.pointer.child_type &&
5992	5992	a.data.pointer.ptr_len == b.data.pointer.ptr_len &&
5993	5993	a.data.pointer.is_const == b.data.pointer.is_const &&
...	...	@@ -5995,10 +5995,10 @@ bool type_id_eql(TypeId a, TypeId b) {
5995	5995	a.data.pointer.alignment == b.data.pointer.alignment &&
5996	5996	a.data.pointer.bit_offset == b.data.pointer.bit_offset &&
5997	5997	a.data.pointer.unaligned_bit_count == b.data.pointer.unaligned_bit_count;
5998		case TypeTableEntryIdArray:
	5998	case ZigTypeIdArray:
5999	5999	return a.data.array.child_type == b.data.array.child_type &&
6000	6000	a.data.array.size == b.data.array.size;
6001		case TypeTableEntryIdInt:
	6001	case ZigTypeIdInt:
6002	6002	return a.data.integer.is_signed == b.data.integer.is_signed &&
6003	6003	a.data.integer.bit_count == b.data.integer.bit_count;
6004	6004	}
...	...	@@ -6050,7 +6050,7 @@ bool zig_llvm_fn_key_eql(ZigLLVMFnKey a, ZigLLVMFnKey b) {
6050	6050	}
6051	6051
6052	6052	void expand_undef_array(CodeGen g, ConstExprValue const_val) {
6053		assert(const_val->type->id == TypeTableEntryIdArray);
	6053	assert(const_val->type->id == ZigTypeIdArray);
6054	6054	if (const_val->data.x_array.special == ConstArraySpecialUndef) {
6055	6055	const_val->data.x_array.special = ConstArraySpecialNone;
6056	6056	size_t elem_count = const_val->type->data.array.len;
...	...	@@ -6072,43 +6072,43 @@ void expand_undef_array(CodeGen g, ConstExprValue const_val) {
6072	6072	ConstParent get_const_val_parent(CodeGen g, ConstExprValue *value) {
6073	6073	assert(value->type);
6074	6074	ZigType *type_entry = value->type;
6075		if (type_entry->id == TypeTableEntryIdArray) {
	6075	if (type_entry->id == ZigTypeIdArray) {
6076	6076	expand_undef_array(g, value);
6077	6077	return &value->data.x_array.s_none.parent;
6078		} else if (type_entry->id == TypeTableEntryIdStruct) {
	6078	} else if (type_entry->id == ZigTypeIdStruct) {
6079	6079	return &value->data.x_struct.parent;
6080		} else if (type_entry->id == TypeTableEntryIdUnion) {
	6080	} else if (type_entry->id == ZigTypeIdUnion) {
6081	6081	return &value->data.x_union.parent;
6082	6082	}
6083	6083	return nullptr;
6084	6084	}
6085	6085
6086	6086	static const ZigTypeId all_type_ids[] = {
6087		TypeTableEntryIdMetaType,
6088		TypeTableEntryIdVoid,
6089		TypeTableEntryIdBool,
6090		TypeTableEntryIdUnreachable,
6091		TypeTableEntryIdInt,
6092		TypeTableEntryIdFloat,
6093		TypeTableEntryIdPointer,
6094		TypeTableEntryIdArray,
6095		TypeTableEntryIdStruct,
6096		TypeTableEntryIdComptimeFloat,
6097		TypeTableEntryIdComptimeInt,
6098		TypeTableEntryIdUndefined,
6099		TypeTableEntryIdNull,
6100		TypeTableEntryIdOptional,
6101		TypeTableEntryIdErrorUnion,
6102		TypeTableEntryIdErrorSet,
6103		TypeTableEntryIdEnum,
6104		TypeTableEntryIdUnion,
6105		TypeTableEntryIdFn,
6106		TypeTableEntryIdNamespace,
6107		TypeTableEntryIdBlock,
6108		TypeTableEntryIdBoundFn,
6109		TypeTableEntryIdArgTuple,
6110		TypeTableEntryIdOpaque,
6111		TypeTableEntryIdPromise,
	6087	ZigTypeIdMetaType,
	6088	ZigTypeIdVoid,
	6089	ZigTypeIdBool,
	6090	ZigTypeIdUnreachable,
	6091	ZigTypeIdInt,
	6092	ZigTypeIdFloat,
	6093	ZigTypeIdPointer,
	6094	ZigTypeIdArray,
	6095	ZigTypeIdStruct,
	6096	ZigTypeIdComptimeFloat,
	6097	ZigTypeIdComptimeInt,
	6098	ZigTypeIdUndefined,
	6099	ZigTypeIdNull,
	6100	ZigTypeIdOptional,
	6101	ZigTypeIdErrorUnion,
	6102	ZigTypeIdErrorSet,
	6103	ZigTypeIdEnum,
	6104	ZigTypeIdUnion,
	6105	ZigTypeIdFn,
	6106	ZigTypeIdNamespace,
	6107	ZigTypeIdBlock,
	6108	ZigTypeIdBoundFn,
	6109	ZigTypeIdArgTuple,
	6110	ZigTypeIdOpaque,
	6111	ZigTypeIdPromise,
6112	6112	};
6113	6113
6114	6114	ZigTypeId type_id_at_index(size_t index) {
...	...	@@ -6122,59 +6122,59 @@ size_t type_id_len() {
6122	6122
6123	6123	size_t type_id_index(ZigType *entry) {
6124	6124	switch (entry->id) {
6125		case TypeTableEntryIdInvalid:
	6125	case ZigTypeIdInvalid:
6126	6126	zig_unreachable();
6127		case TypeTableEntryIdMetaType:
	6127	case ZigTypeIdMetaType:
6128	6128	return 0;
6129		case TypeTableEntryIdVoid:
	6129	case ZigTypeIdVoid:
6130	6130	return 1;
6131		case TypeTableEntryIdBool:
	6131	case ZigTypeIdBool:
6132	6132	return 2;
6133		case TypeTableEntryIdUnreachable:
	6133	case ZigTypeIdUnreachable:
6134	6134	return 3;
6135		case TypeTableEntryIdInt:
	6135	case ZigTypeIdInt:
6136	6136	return 4;
6137		case TypeTableEntryIdFloat:
	6137	case ZigTypeIdFloat:
6138	6138	return 5;
6139		case TypeTableEntryIdPointer:
	6139	case ZigTypeIdPointer:
6140	6140	return 6;
6141		case TypeTableEntryIdArray:
	6141	case ZigTypeIdArray:
6142	6142	return 7;
6143		case TypeTableEntryIdStruct:
	6143	case ZigTypeIdStruct:
6144	6144	if (entry->data.structure.is_slice)
6145	6145	return 6;
6146	6146	return 8;
6147		case TypeTableEntryIdComptimeFloat:
	6147	case ZigTypeIdComptimeFloat:
6148	6148	return 9;
6149		case TypeTableEntryIdComptimeInt:
	6149	case ZigTypeIdComptimeInt:
6150	6150	return 10;
6151		case TypeTableEntryIdUndefined:
	6151	case ZigTypeIdUndefined:
6152	6152	return 11;
6153		case TypeTableEntryIdNull:
	6153	case ZigTypeIdNull:
6154	6154	return 12;
6155		case TypeTableEntryIdOptional:
	6155	case ZigTypeIdOptional:
6156	6156	return 13;
6157		case TypeTableEntryIdErrorUnion:
	6157	case ZigTypeIdErrorUnion:
6158	6158	return 14;
6159		case TypeTableEntryIdErrorSet:
	6159	case ZigTypeIdErrorSet:
6160	6160	return 15;
6161		case TypeTableEntryIdEnum:
	6161	case ZigTypeIdEnum:
6162	6162	return 16;
6163		case TypeTableEntryIdUnion:
	6163	case ZigTypeIdUnion:
6164	6164	return 17;
6165		case TypeTableEntryIdFn:
	6165	case ZigTypeIdFn:
6166	6166	return 18;
6167		case TypeTableEntryIdNamespace:
	6167	case ZigTypeIdNamespace:
6168	6168	return 19;
6169		case TypeTableEntryIdBlock:
	6169	case ZigTypeIdBlock:
6170	6170	return 20;
6171		case TypeTableEntryIdBoundFn:
	6171	case ZigTypeIdBoundFn:
6172	6172	return 21;
6173		case TypeTableEntryIdArgTuple:
	6173	case ZigTypeIdArgTuple:
6174	6174	return 22;
6175		case TypeTableEntryIdOpaque:
	6175	case ZigTypeIdOpaque:
6176	6176	return 23;
6177		case TypeTableEntryIdPromise:
	6177	case ZigTypeIdPromise:
6178	6178	return 24;
6179	6179	}
6180	6180	zig_unreachable();
...	...	@@ -6182,57 +6182,57 @@ size_t type_id_index(ZigType *entry) {
6182	6182
6183	6183	const char *type_id_name(ZigTypeId id) {
6184	6184	switch (id) {
6185		case TypeTableEntryIdInvalid:
	6185	case ZigTypeIdInvalid:
6186	6186	zig_unreachable();
6187		case TypeTableEntryIdMetaType:
	6187	case ZigTypeIdMetaType:
6188	6188	return "Type";
6189		case TypeTableEntryIdVoid:
	6189	case ZigTypeIdVoid:
6190	6190	return "Void";
6191		case TypeTableEntryIdBool:
	6191	case ZigTypeIdBool:
6192	6192	return "Bool";
6193		case TypeTableEntryIdUnreachable:
	6193	case ZigTypeIdUnreachable:
6194	6194	return "NoReturn";
6195		case TypeTableEntryIdInt:
	6195	case ZigTypeIdInt:
6196	6196	return "Int";
6197		case TypeTableEntryIdFloat:
	6197	case ZigTypeIdFloat:
6198	6198	return "Float";
6199		case TypeTableEntryIdPointer:
	6199	case ZigTypeIdPointer:
6200	6200	return "Pointer";
6201		case TypeTableEntryIdArray:
	6201	case ZigTypeIdArray:
6202	6202	return "Array";
6203		case TypeTableEntryIdStruct:
	6203	case ZigTypeIdStruct:
6204	6204	return "Struct";
6205		case TypeTableEntryIdComptimeFloat:
	6205	case ZigTypeIdComptimeFloat:
6206	6206	return "ComptimeFloat";
6207		case TypeTableEntryIdComptimeInt:
	6207	case ZigTypeIdComptimeInt:
6208	6208	return "ComptimeInt";
6209		case TypeTableEntryIdUndefined:
	6209	case ZigTypeIdUndefined:
6210	6210	return "Undefined";
6211		case TypeTableEntryIdNull:
	6211	case ZigTypeIdNull:
6212	6212	return "Null";
6213		case TypeTableEntryIdOptional:
	6213	case ZigTypeIdOptional:
6214	6214	return "Optional";
6215		case TypeTableEntryIdErrorUnion:
	6215	case ZigTypeIdErrorUnion:
6216	6216	return "ErrorUnion";
6217		case TypeTableEntryIdErrorSet:
	6217	case ZigTypeIdErrorSet:
6218	6218	return "ErrorSet";
6219		case TypeTableEntryIdEnum:
	6219	case ZigTypeIdEnum:
6220	6220	return "Enum";
6221		case TypeTableEntryIdUnion:
	6221	case ZigTypeIdUnion:
6222	6222	return "Union";
6223		case TypeTableEntryIdFn:
	6223	case ZigTypeIdFn:
6224	6224	return "Fn";
6225		case TypeTableEntryIdNamespace:
	6225	case ZigTypeIdNamespace:
6226	6226	return "Namespace";
6227		case TypeTableEntryIdBlock:
	6227	case ZigTypeIdBlock:
6228	6228	return "Block";
6229		case TypeTableEntryIdBoundFn:
	6229	case ZigTypeIdBoundFn:
6230	6230	return "BoundFn";
6231		case TypeTableEntryIdArgTuple:
	6231	case ZigTypeIdArgTuple:
6232	6232	return "ArgTuple";
6233		case TypeTableEntryIdOpaque:
	6233	case ZigTypeIdOpaque:
6234	6234	return "Opaque";
6235		case TypeTableEntryIdPromise:
	6235	case ZigTypeIdPromise:
6236	6236	return "Promise";
6237	6237	}
6238	6238	zig_unreachable();
...	...	@@ -6272,18 +6272,18 @@ uint32_t get_abi_alignment(CodeGen g, ZigType type_entry) {
6272	6272
6273	6273	// We need to make this function work without requiring ensure_complete_type
6274	6274	// so that we can have structs with fields that are pointers to their own type.
6275		if (type_entry->id == TypeTableEntryIdStruct) {
	6275	if (type_entry->id == ZigTypeIdStruct) {
6276	6276	assert(type_entry->data.structure.abi_alignment != 0);
6277	6277	return type_entry->data.structure.abi_alignment;
6278		} else if (type_entry->id == TypeTableEntryIdUnion) {
	6278	} else if (type_entry->id == ZigTypeIdUnion) {
6279	6279	assert(type_entry->data.unionation.abi_alignment != 0);
6280	6280	return type_entry->data.unionation.abi_alignment;
6281		} else if (type_entry->id == TypeTableEntryIdOpaque) {
	6281	} else if (type_entry->id == ZigTypeIdOpaque) {
6282	6282	return 1;
6283	6283	} else {
6284	6284	uint32_t llvm_alignment = LLVMABIAlignmentOfType(g->target_data_ref, type_entry->type_ref);
6285	6285	// promises have at least alignment 8 so that we can have 3 extra bits when doing atomicrmw
6286		if (type_entry->id == TypeTableEntryIdPromise && llvm_alignment < 8) {
	6286	if (type_entry->id == ZigTypeIdPromise && llvm_alignment < 8) {
6287	6287	return 8;
6288	6288	}
6289	6289	return llvm_alignment;
...	...	@@ -6317,7 +6317,7 @@ ConstExprValue get_builtin_value(CodeGen codegen, const char *name) {
6317	6317	}
6318	6318
6319	6319	bool type_is_global_error_set(ZigType *err_set_type) {
6320		assert(err_set_type->id == TypeTableEntryIdErrorSet);
	6320	assert(err_set_type->id == ZigTypeIdErrorSet);
6321	6321	assert(err_set_type->data.error_set.infer_fn == nullptr);
6322	6322	return err_set_type->data.error_set.err_count == UINT32_MAX;
6323	6323	}
...	...	@@ -6327,7 +6327,7 @@ uint32_t get_coro_frame_align_bytes(CodeGen *g) {
6327	6327	}
6328	6328
6329	6329	bool type_can_fail(ZigType *type_entry) {
6330		return type_entry->id == TypeTableEntryIdErrorUnion \|\| type_entry->id == TypeTableEntryIdErrorSet;
	6330	return type_entry->id == ZigTypeIdErrorUnion \|\| type_entry->id == ZigTypeIdErrorSet;
6331	6331	}
6332	6332
6333	6333	bool fn_type_can_fail(FnTypeId *fn_type_id) {

src/codegen.cpp+277-277

...	...	@@ -533,7 +533,7 @@ static LLVMValueRef fn_llvm_value(CodeGen g, ZigFn fn_table_entry) {
533	533	}
534	534
535	535	ZigType *return_type = fn_type->data.fn.fn_type_id.return_type;
536		if (return_type->id == TypeTableEntryIdUnreachable) {
	536	if (return_type->id == ZigTypeIdUnreachable) {
537	537	addLLVMFnAttr(fn_table_entry->llvm_value, "noreturn");
538	538	}
539	539
...	...	@@ -600,10 +600,10 @@ static LLVMValueRef fn_llvm_value(CodeGen g, ZigFn fn_table_entry) {
600	600	if (param_info->is_noalias) {
601	601	addLLVMArgAttr(fn_table_entry->llvm_value, (unsigned)gen_index, "noalias");
602	602	}
603		if ((param_type->id == TypeTableEntryIdPointer && param_type->data.pointer.is_const) \|\| is_byval) {
	603	if ((param_type->id == ZigTypeIdPointer && param_type->data.pointer.is_const) \|\| is_byval) {
604	604	addLLVMArgAttr(fn_table_entry->llvm_value, (unsigned)gen_index, "readonly");
605	605	}
606		if (param_type->id == TypeTableEntryIdPointer) {
	606	if (param_type->id == ZigTypeIdPointer) {
607	607	addLLVMArgAttr(fn_table_entry->llvm_value, (unsigned)gen_index, "nonnull");
608	608	}
609	609	}
...	...	@@ -693,7 +693,7 @@ static LLVMValueRef get_arithmetic_overflow_fn(CodeGen g, ZigType type_entry,
693	693	{
694	694	char fn_name[64];
695	695
696		assert(type_entry->id == TypeTableEntryIdInt);
	696	assert(type_entry->id == ZigTypeIdInt);
697	697	const char *signed_str = type_entry->data.integral.is_signed ? signed_name : unsigned_name;
698	698	sprintf(fn_name, "llvm.%s.with.overflow.i%" PRIu32, signed_str, type_entry->data.integral.bit_count);
699	699
...	...	@@ -713,7 +713,7 @@ static LLVMValueRef get_arithmetic_overflow_fn(CodeGen g, ZigType type_entry,
713	713	}
714	714
715	715	static LLVMValueRef get_int_overflow_fn(CodeGen g, ZigType type_entry, AddSubMul add_sub_mul) {
716		assert(type_entry->id == TypeTableEntryIdInt);
	716	assert(type_entry->id == ZigTypeIdInt);
717	717
718	718	ZigLLVMFnKey key = {};
719	719	key.id = ZigLLVMFnIdOverflowArithmetic;
...	...	@@ -743,7 +743,7 @@ static LLVMValueRef get_int_overflow_fn(CodeGen g, ZigType type_entry, AddSubM
743	743	}
744	744
745	745	static LLVMValueRef get_float_fn(CodeGen g, ZigType type_entry, ZigLLVMFnId fn_id) {
746		assert(type_entry->id == TypeTableEntryIdFloat);
	746	assert(type_entry->id == ZigTypeIdFloat);
747	747
748	748	ZigLLVMFnKey key = {};
749	749	key.id = fn_id;
...	...	@@ -788,7 +788,7 @@ static LLVMValueRef gen_store_untyped(CodeGen *g, LLVMValueRef value, LLVMValueR
788	788	}
789	789
790	790	static LLVMValueRef gen_store(CodeGen g, LLVMValueRef value, LLVMValueRef ptr, ZigType ptr_type) {
791		assert(ptr_type->id == TypeTableEntryIdPointer);
	791	assert(ptr_type->id == ZigTypeIdPointer);
792	792	return gen_store_untyped(g, value, ptr, ptr_type->data.pointer.alignment, ptr_type->data.pointer.is_volatile);
793	793	}
794	794
...	...	@@ -806,7 +806,7 @@ static LLVMValueRef gen_load_untyped(CodeGen *g, LLVMValueRef ptr, uint32_t alig
806	806	}
807	807
808	808	static LLVMValueRef gen_load(CodeGen g, LLVMValueRef ptr, ZigType ptr_type, const char *name) {
809		assert(ptr_type->id == TypeTableEntryIdPointer);
	809	assert(ptr_type->id == ZigTypeIdPointer);
810	810	return gen_load_untyped(g, ptr, ptr_type->data.pointer.alignment, ptr_type->data.pointer.is_volatile, name);
811	811	}
812	812
...	...	@@ -815,7 +815,7 @@ static LLVMValueRef get_handle_value(CodeGen g, LLVMValueRef ptr, ZigType type
815	815	if (handle_is_ptr(type)) {
816	816	return ptr;
817	817	} else {
818		assert(ptr_type->id == TypeTableEntryIdPointer);
	818	assert(ptr_type->id == ZigTypeIdPointer);
819	819	return gen_load(g, ptr, ptr_type, "");
820	820	}
821	821	} else {
...	...	@@ -1656,17 +1656,17 @@ static LLVMValueRef gen_widen_or_shorten(CodeGen *g, bool want_runtime_safety, Z
1656	1656
1657	1657	uint64_t actual_bits;
1658	1658	uint64_t wanted_bits;
1659		if (actual_type->id == TypeTableEntryIdFloat) {
	1659	if (actual_type->id == ZigTypeIdFloat) {
1660	1660	actual_bits = actual_type->data.floating.bit_count;
1661	1661	wanted_bits = wanted_type->data.floating.bit_count;
1662		} else if (actual_type->id == TypeTableEntryIdInt) {
	1662	} else if (actual_type->id == ZigTypeIdInt) {
1663	1663	actual_bits = actual_type->data.integral.bit_count;
1664	1664	wanted_bits = wanted_type->data.integral.bit_count;
1665	1665	} else {
1666	1666	zig_unreachable();
1667	1667	}
1668	1668
1669		if (actual_bits >= wanted_bits && actual_type->id == TypeTableEntryIdInt &&
	1669	if (actual_bits >= wanted_bits && actual_type->id == ZigTypeIdInt &&
1670	1670	!wanted_type->data.integral.is_signed && actual_type->data.integral.is_signed &&
1671	1671	want_runtime_safety)
1672	1672	{
...	...	@@ -1686,9 +1686,9 @@ static LLVMValueRef gen_widen_or_shorten(CodeGen *g, bool want_runtime_safety, Z
1686	1686	if (actual_bits == wanted_bits) {
1687	1687	return expr_val;
1688	1688	} else if (actual_bits < wanted_bits) {
1689		if (actual_type->id == TypeTableEntryIdFloat) {
	1689	if (actual_type->id == ZigTypeIdFloat) {
1690	1690	return LLVMBuildFPExt(g->builder, expr_val, wanted_type->type_ref, "");
1691		} else if (actual_type->id == TypeTableEntryIdInt) {
	1691	} else if (actual_type->id == ZigTypeIdInt) {
1692	1692	if (actual_type->data.integral.is_signed) {
1693	1693	return LLVMBuildSExt(g->builder, expr_val, wanted_type->type_ref, "");
1694	1694	} else {
...	...	@@ -1698,9 +1698,9 @@ static LLVMValueRef gen_widen_or_shorten(CodeGen *g, bool want_runtime_safety, Z
1698	1698	zig_unreachable();
1699	1699	}
1700	1700	} else if (actual_bits > wanted_bits) {
1701		if (actual_type->id == TypeTableEntryIdFloat) {
	1701	if (actual_type->id == ZigTypeIdFloat) {
1702	1702	return LLVMBuildFPTrunc(g->builder, expr_val, wanted_type->type_ref, "");
1703		} else if (actual_type->id == TypeTableEntryIdInt) {
	1703	} else if (actual_type->id == ZigTypeIdInt) {
1704	1704	LLVMValueRef trunc_val = LLVMBuildTrunc(g->builder, expr_val, wanted_type->type_ref, "");
1705	1705	if (!want_runtime_safety) {
1706	1706	return trunc_val;
...	...	@@ -1792,7 +1792,7 @@ static LLVMRealPredicate cmp_op_to_real_predicate(IrBinOp cmp_op) {
1792	1792	static LLVMValueRef gen_assign_raw(CodeGen g, LLVMValueRef ptr, ZigType ptr_type,
1793	1793	LLVMValueRef value)
1794	1794	{
1795		assert(ptr_type->id == TypeTableEntryIdPointer);
	1795	assert(ptr_type->id == ZigTypeIdPointer);
1796	1796	ZigType *child_type = ptr_type->data.pointer.child_type;
1797	1797
1798	1798	if (!type_has_bits(child_type))
...	...	@@ -1878,7 +1878,7 @@ static LLVMValueRef ir_llvm_value(CodeGen g, IrInstruction instruction) {
1878	1878	render_const_val_global(g, &instruction->value, "");
1879	1879	ZigType *ptr_type = get_pointer_to_type(g, instruction->value.type, true);
1880	1880	instruction->llvm_value = LLVMBuildBitCast(g->builder, instruction->value.global_refs->llvm_global, ptr_type->type_ref, "");
1881		} else if (instruction->value.type->id == TypeTableEntryIdPointer) {
	1881	} else if (instruction->value.type->id == ZigTypeIdPointer) {
1882	1882	instruction->llvm_value = LLVMBuildBitCast(g->builder, instruction->value.global_refs->llvm_value, instruction->value.type->type_ref, "");
1883	1883	} else {
1884	1884	instruction->llvm_value = instruction->value.global_refs->llvm_value;
...	...	@@ -1929,7 +1929,7 @@ static LLVMValueRef gen_overflow_shl_op(CodeGen g, ZigType type_entry,
1929	1929	// if the values don't match, we have an overflow
1930	1930	// for signed left shifting we do the same except arithmetic shift right
1931	1931
1932		assert(type_entry->id == TypeTableEntryIdInt);
	1932	assert(type_entry->id == ZigTypeIdInt);
1933	1933
1934	1934	LLVMValueRef result = LLVMBuildShl(g->builder, val1, val2, "");
1935	1935	LLVMValueRef orig_val;
...	...	@@ -1954,7 +1954,7 @@ static LLVMValueRef gen_overflow_shl_op(CodeGen g, ZigType type_entry,
1954	1954	static LLVMValueRef gen_overflow_shr_op(CodeGen g, ZigType type_entry,
1955	1955	LLVMValueRef val1, LLVMValueRef val2)
1956	1956	{
1957		assert(type_entry->id == TypeTableEntryIdInt);
	1957	assert(type_entry->id == ZigTypeIdInt);
1958	1958
1959	1959	LLVMValueRef result;
1960	1960	if (type_entry->data.integral.is_signed) {
...	...	@@ -1977,7 +1977,7 @@ static LLVMValueRef gen_overflow_shr_op(CodeGen g, ZigType type_entry,
1977	1977	}
1978	1978
1979	1979	static LLVMValueRef gen_floor(CodeGen g, LLVMValueRef val, ZigType type_entry) {
1980		if (type_entry->id == TypeTableEntryIdInt)
	1980	if (type_entry->id == ZigTypeIdInt)
1981	1981	return val;
1982	1982
1983	1983	LLVMValueRef floor_fn = get_float_fn(g, type_entry, ZigLLVMFnIdFloor);
...	...	@@ -1985,7 +1985,7 @@ static LLVMValueRef gen_floor(CodeGen g, LLVMValueRef val, ZigType type_entry)
1985	1985	}
1986	1986
1987	1987	static LLVMValueRef gen_ceil(CodeGen g, LLVMValueRef val, ZigType type_entry) {
1988		if (type_entry->id == TypeTableEntryIdInt)
	1988	if (type_entry->id == ZigTypeIdInt)
1989	1989	return val;
1990	1990
1991	1991	LLVMValueRef ceil_fn = get_float_fn(g, type_entry, ZigLLVMFnIdCeil);
...	...	@@ -2023,11 +2023,11 @@ static LLVMValueRef gen_div(CodeGen *g, bool want_runtime_safety, bool want_fast
2023	2023	ZigLLVMSetFastMath(g->builder, want_fast_math);
2024	2024
2025	2025	LLVMValueRef zero = LLVMConstNull(type_entry->type_ref);
2026		if (want_runtime_safety && (want_fast_math \|\| type_entry->id != TypeTableEntryIdFloat)) {
	2026	if (want_runtime_safety && (want_fast_math \|\| type_entry->id != ZigTypeIdFloat)) {
2027	2027	LLVMValueRef is_zero_bit;
2028		if (type_entry->id == TypeTableEntryIdInt) {
	2028	if (type_entry->id == ZigTypeIdInt) {
2029	2029	is_zero_bit = LLVMBuildICmp(g->builder, LLVMIntEQ, val2, zero, "");
2030		} else if (type_entry->id == TypeTableEntryIdFloat) {
	2030	} else if (type_entry->id == ZigTypeIdFloat) {
2031	2031	is_zero_bit = LLVMBuildFCmp(g->builder, LLVMRealOEQ, val2, zero, "");
2032	2032	} else {
2033	2033	zig_unreachable();
...	...	@@ -2041,7 +2041,7 @@ static LLVMValueRef gen_div(CodeGen *g, bool want_runtime_safety, bool want_fast
2041	2041
2042	2042	LLVMPositionBuilderAtEnd(g->builder, div_zero_ok_block);
2043	2043
2044		if (type_entry->id == TypeTableEntryIdInt && type_entry->data.integral.is_signed) {
	2044	if (type_entry->id == ZigTypeIdInt && type_entry->data.integral.is_signed) {
2045	2045	LLVMValueRef neg_1_value = LLVMConstInt(type_entry->type_ref, -1, true);
2046	2046	BigInt int_min_bi = {0};
2047	2047	eval_min_max_value_int(g, type_entry, &int_min_bi, false);
...	...	@@ -2060,7 +2060,7 @@ static LLVMValueRef gen_div(CodeGen *g, bool want_runtime_safety, bool want_fast
2060	2060	}
2061	2061	}
2062	2062
2063		if (type_entry->id == TypeTableEntryIdFloat) {
	2063	if (type_entry->id == ZigTypeIdFloat) {
2064	2064	LLVMValueRef result = LLVMBuildFDiv(g->builder, val1, val2, "");
2065	2065	switch (div_kind) {
2066	2066	case DivKindFloat:
...	...	@@ -2111,7 +2111,7 @@ static LLVMValueRef gen_div(CodeGen *g, bool want_runtime_safety, bool want_fast
2111	2111	zig_unreachable();
2112	2112	}
2113	2113
2114		assert(type_entry->id == TypeTableEntryIdInt);
	2114	assert(type_entry->id == ZigTypeIdInt);
2115	2115
2116	2116	switch (div_kind) {
2117	2117	case DivKindFloat:
...	...	@@ -2184,10 +2184,10 @@ static LLVMValueRef gen_rem(CodeGen *g, bool want_runtime_safety, bool want_fast
2184	2184	LLVMValueRef zero = LLVMConstNull(type_entry->type_ref);
2185	2185	if (want_runtime_safety) {
2186	2186	LLVMValueRef is_zero_bit;
2187		if (type_entry->id == TypeTableEntryIdInt) {
	2187	if (type_entry->id == ZigTypeIdInt) {
2188	2188	LLVMIntPredicate pred = type_entry->data.integral.is_signed ? LLVMIntSLE : LLVMIntEQ;
2189	2189	is_zero_bit = LLVMBuildICmp(g->builder, pred, val2, zero, "");
2190		} else if (type_entry->id == TypeTableEntryIdFloat) {
	2190	} else if (type_entry->id == ZigTypeIdFloat) {
2191	2191	is_zero_bit = LLVMBuildFCmp(g->builder, LLVMRealOEQ, val2, zero, "");
2192	2192	} else {
2193	2193	zig_unreachable();
...	...	@@ -2202,7 +2202,7 @@ static LLVMValueRef gen_rem(CodeGen *g, bool want_runtime_safety, bool want_fast
2202	2202	LLVMPositionBuilderAtEnd(g->builder, rem_zero_ok_block);
2203	2203	}
2204	2204
2205		if (type_entry->id == TypeTableEntryIdFloat) {
	2205	if (type_entry->id == ZigTypeIdFloat) {
2206	2206	if (rem_kind == RemKindRem) {
2207	2207	return LLVMBuildFRem(g->builder, val1, val2, "");
2208	2208	} else {
...	...	@@ -2213,7 +2213,7 @@ static LLVMValueRef gen_rem(CodeGen *g, bool want_runtime_safety, bool want_fast
2213	2213	return LLVMBuildSelect(g->builder, ltz, c, a, "");
2214	2214	}
2215	2215	} else {
2216		assert(type_entry->id == TypeTableEntryIdInt);
	2216	assert(type_entry->id == ZigTypeIdInt);
2217	2217	if (type_entry->data.integral.is_signed) {
2218	2218	if (rem_kind == RemKindRem) {
2219	2219	return LLVMBuildSRem(g->builder, val1, val2, "");
...	...	@@ -2241,8 +2241,8 @@ static LLVMValueRef ir_render_bin_op(CodeGen g, IrExecutable executable,
2241	2241	assert(op1->value.type == op2->value.type \|\| op_id == IrBinOpBitShiftLeftLossy \|\|
2242	2242	op_id == IrBinOpBitShiftLeftExact \|\| op_id == IrBinOpBitShiftRightLossy \|\|
2243	2243	op_id == IrBinOpBitShiftRightExact \|\|
2244		(op1->value.type->id == TypeTableEntryIdErrorSet && op2->value.type->id == TypeTableEntryIdErrorSet) \|\|
2245		(op1->value.type->id == TypeTableEntryIdPointer &&
	2244	(op1->value.type->id == ZigTypeIdErrorSet && op2->value.type->id == ZigTypeIdErrorSet) \|\|
	2245	(op1->value.type->id == ZigTypeIdPointer &&
2246	2246	(op_id == IrBinOpAdd \|\| op_id == IrBinOpSub) &&
2247	2247	op1->value.type->data.pointer.ptr_len == PtrLenUnknown)
2248	2248	);
...	...	@@ -2272,16 +2272,16 @@ static LLVMValueRef ir_render_bin_op(CodeGen g, IrExecutable executable,
2272	2272	case IrBinOpCmpGreaterThan:
2273	2273	case IrBinOpCmpLessOrEq:
2274	2274	case IrBinOpCmpGreaterOrEq:
2275		if (type_entry->id == TypeTableEntryIdFloat) {
	2275	if (type_entry->id == ZigTypeIdFloat) {
2276	2276	ZigLLVMSetFastMath(g->builder, ir_want_fast_math(g, &bin_op_instruction->base));
2277	2277	LLVMRealPredicate pred = cmp_op_to_real_predicate(op_id);
2278	2278	return LLVMBuildFCmp(g->builder, pred, op1_value, op2_value, "");
2279		} else if (type_entry->id == TypeTableEntryIdInt) {
	2279	} else if (type_entry->id == ZigTypeIdInt) {
2280	2280	LLVMIntPredicate pred = cmp_op_to_int_predicate(op_id, type_entry->data.integral.is_signed);
2281	2281	return LLVMBuildICmp(g->builder, pred, op1_value, op2_value, "");
2282		} else if (type_entry->id == TypeTableEntryIdEnum \|\|
2283		type_entry->id == TypeTableEntryIdErrorSet \|\|
2284		type_entry->id == TypeTableEntryIdBool \|\|
	2282	} else if (type_entry->id == ZigTypeIdEnum \|\|
	2283	type_entry->id == ZigTypeIdErrorSet \|\|
	2284	type_entry->id == ZigTypeIdBool \|\|
2285	2285	get_codegen_ptr_type(type_entry) != nullptr)
2286	2286	{
2287	2287	LLVMIntPredicate pred = cmp_op_to_int_predicate(op_id, false);
...	...	@@ -2291,14 +2291,14 @@ static LLVMValueRef ir_render_bin_op(CodeGen g, IrExecutable executable,
2291	2291	}
2292	2292	case IrBinOpAdd:
2293	2293	case IrBinOpAddWrap:
2294		if (type_entry->id == TypeTableEntryIdPointer) {
	2294	if (type_entry->id == ZigTypeIdPointer) {
2295	2295	assert(type_entry->data.pointer.ptr_len == PtrLenUnknown);
2296	2296	// TODO runtime safety
2297	2297	return LLVMBuildInBoundsGEP(g->builder, op1_value, &op2_value, 1, "");
2298		} else if (type_entry->id == TypeTableEntryIdFloat) {
	2298	} else if (type_entry->id == ZigTypeIdFloat) {
2299	2299	ZigLLVMSetFastMath(g->builder, ir_want_fast_math(g, &bin_op_instruction->base));
2300	2300	return LLVMBuildFAdd(g->builder, op1_value, op2_value, "");
2301		} else if (type_entry->id == TypeTableEntryIdInt) {
	2301	} else if (type_entry->id == ZigTypeIdInt) {
2302	2302	bool is_wrapping = (op_id == IrBinOpAddWrap);
2303	2303	if (is_wrapping) {
2304	2304	return LLVMBuildAdd(g->builder, op1_value, op2_value, "");
...	...	@@ -2321,7 +2321,7 @@ static LLVMValueRef ir_render_bin_op(CodeGen g, IrExecutable executable,
2321	2321	case IrBinOpBitShiftLeftLossy:
2322	2322	case IrBinOpBitShiftLeftExact:
2323	2323	{
2324		assert(type_entry->id == TypeTableEntryIdInt);
	2324	assert(type_entry->id == ZigTypeIdInt);
2325	2325	LLVMValueRef op2_casted = gen_widen_or_shorten(g, false, op2->value.type,
2326	2326	type_entry, op2_value);
2327	2327	bool is_sloppy = (op_id == IrBinOpBitShiftLeftLossy);
...	...	@@ -2338,7 +2338,7 @@ static LLVMValueRef ir_render_bin_op(CodeGen g, IrExecutable executable,
2338	2338	case IrBinOpBitShiftRightLossy:
2339	2339	case IrBinOpBitShiftRightExact:
2340	2340	{
2341		assert(type_entry->id == TypeTableEntryIdInt);
	2341	assert(type_entry->id == ZigTypeIdInt);
2342	2342	LLVMValueRef op2_casted = gen_widen_or_shorten(g, false, op2->value.type,
2343	2343	type_entry, op2_value);
2344	2344	bool is_sloppy = (op_id == IrBinOpBitShiftRightLossy);
...	...	@@ -2358,15 +2358,15 @@ static LLVMValueRef ir_render_bin_op(CodeGen g, IrExecutable executable,
2358	2358	}
2359	2359	case IrBinOpSub:
2360	2360	case IrBinOpSubWrap:
2361		if (type_entry->id == TypeTableEntryIdPointer) {
	2361	if (type_entry->id == ZigTypeIdPointer) {
2362	2362	assert(type_entry->data.pointer.ptr_len == PtrLenUnknown);
2363	2363	// TODO runtime safety
2364	2364	LLVMValueRef subscript_value = LLVMBuildNeg(g->builder, op2_value, "");
2365	2365	return LLVMBuildInBoundsGEP(g->builder, op1_value, &subscript_value, 1, "");
2366		} else if (type_entry->id == TypeTableEntryIdFloat) {
	2366	} else if (type_entry->id == ZigTypeIdFloat) {
2367	2367	ZigLLVMSetFastMath(g->builder, ir_want_fast_math(g, &bin_op_instruction->base));
2368	2368	return LLVMBuildFSub(g->builder, op1_value, op2_value, "");
2369		} else if (type_entry->id == TypeTableEntryIdInt) {
	2369	} else if (type_entry->id == ZigTypeIdInt) {
2370	2370	bool is_wrapping = (op_id == IrBinOpSubWrap);
2371	2371	if (is_wrapping) {
2372	2372	return LLVMBuildSub(g->builder, op1_value, op2_value, "");
...	...	@@ -2382,10 +2382,10 @@ static LLVMValueRef ir_render_bin_op(CodeGen g, IrExecutable executable,
2382	2382	}
2383	2383	case IrBinOpMult:
2384	2384	case IrBinOpMultWrap:
2385		if (type_entry->id == TypeTableEntryIdFloat) {
	2385	if (type_entry->id == ZigTypeIdFloat) {
2386	2386	ZigLLVMSetFastMath(g->builder, ir_want_fast_math(g, &bin_op_instruction->base));
2387	2387	return LLVMBuildFMul(g->builder, op1_value, op2_value, "");
2388		} else if (type_entry->id == TypeTableEntryIdInt) {
	2388	} else if (type_entry->id == ZigTypeIdInt) {
2389	2389	bool is_wrapping = (op_id == IrBinOpMultWrap);
2390	2390	if (is_wrapping) {
2391	2391	return LLVMBuildMul(g->builder, op1_value, op2_value, "");
...	...	@@ -2422,7 +2422,7 @@ static LLVMValueRef ir_render_bin_op(CodeGen g, IrExecutable executable,
2422	2422	}
2423	2423
2424	2424	static void add_error_range_check(CodeGen g, ZigType err_set_type, ZigType *int_type, LLVMValueRef target_val) {
2425		assert(err_set_type->id == TypeTableEntryIdErrorSet);
	2425	assert(err_set_type->id == ZigTypeIdErrorSet);
2426	2426
2427	2427	if (type_is_global_error_set(err_set_type)) {
2428	2428	LLVMValueRef zero = LLVMConstNull(int_type->type_ref);
...	...	@@ -2486,9 +2486,9 @@ static LLVMValueRef ir_render_cast(CodeGen g, IrExecutable executable,
2486	2486	case CastOpResizeSlice:
2487	2487	{
2488	2488	assert(cast_instruction->tmp_ptr);
2489		assert(wanted_type->id == TypeTableEntryIdStruct);
	2489	assert(wanted_type->id == ZigTypeIdStruct);
2490	2490	assert(wanted_type->data.structure.is_slice);
2491		assert(actual_type->id == TypeTableEntryIdStruct);
	2491	assert(actual_type->id == ZigTypeIdStruct);
2492	2492	assert(actual_type->data.structure.is_slice);
2493	2493
2494	2494	ZigType *actual_pointer_type = actual_type->data.structure.fields[0].type_entry;
...	...	@@ -2549,9 +2549,9 @@ static LLVMValueRef ir_render_cast(CodeGen g, IrExecutable executable,
2549	2549	case CastOpBytesToSlice:
2550	2550	{
2551	2551	assert(cast_instruction->tmp_ptr);
2552		assert(wanted_type->id == TypeTableEntryIdStruct);
	2552	assert(wanted_type->id == ZigTypeIdStruct);
2553	2553	assert(wanted_type->data.structure.is_slice);
2554		assert(actual_type->id == TypeTableEntryIdArray);
	2554	assert(actual_type->id == ZigTypeIdArray);
2555	2555
2556	2556	ZigType *wanted_pointer_type = wanted_type->data.structure.fields[slice_ptr_index].type_entry;
2557	2557	ZigType *wanted_child_type = wanted_pointer_type->data.pointer.child_type;
...	...	@@ -2573,14 +2573,14 @@ static LLVMValueRef ir_render_cast(CodeGen g, IrExecutable executable,
2573	2573	return cast_instruction->tmp_ptr;
2574	2574	}
2575	2575	case CastOpIntToFloat:
2576		assert(actual_type->id == TypeTableEntryIdInt);
	2576	assert(actual_type->id == ZigTypeIdInt);
2577	2577	if (actual_type->data.integral.is_signed) {
2578	2578	return LLVMBuildSIToFP(g->builder, expr_val, wanted_type->type_ref, "");
2579	2579	} else {
2580	2580	return LLVMBuildUIToFP(g->builder, expr_val, wanted_type->type_ref, "");
2581	2581	}
2582	2582	case CastOpFloatToInt: {
2583		assert(wanted_type->id == TypeTableEntryIdInt);
	2583	assert(wanted_type->id == ZigTypeIdInt);
2584	2584	ZigLLVMSetFastMath(g->builder, ir_want_fast_math(g, &cast_instruction->base));
2585	2585
2586	2586	bool want_safety = ir_want_runtime_safety(g, &cast_instruction->base);
...	...	@@ -2615,8 +2615,8 @@ static LLVMValueRef ir_render_cast(CodeGen g, IrExecutable executable,
2615	2615	return result;
2616	2616	}
2617	2617	case CastOpBoolToInt:
2618		assert(wanted_type->id == TypeTableEntryIdInt);
2619		assert(actual_type->id == TypeTableEntryIdBool);
	2618	assert(wanted_type->id == ZigTypeIdInt);
	2619	assert(actual_type->id == ZigTypeIdBool);
2620	2620	return LLVMBuildZExt(g->builder, expr_val, wanted_type->type_ref, "");
2621	2621	case CastOpErrSet:
2622	2622	if (ir_want_runtime_safety(g, &cast_instruction->base)) {
...	...	@@ -2627,9 +2627,9 @@ static LLVMValueRef ir_render_cast(CodeGen g, IrExecutable executable,
2627	2627	return LLVMBuildBitCast(g->builder, expr_val, wanted_type->type_ref, "");
2628	2628	case CastOpPtrOfArrayToSlice: {
2629	2629	assert(cast_instruction->tmp_ptr);
2630		assert(actual_type->id == TypeTableEntryIdPointer);
	2630	assert(actual_type->id == ZigTypeIdPointer);
2631	2631	ZigType *array_type = actual_type->data.pointer.child_type;
2632		assert(array_type->id == TypeTableEntryIdArray);
	2632	assert(array_type->id == ZigTypeIdArray);
2633	2633
2634	2634	LLVMValueRef ptr_field_ptr = LLVMBuildStructGEP(g->builder, cast_instruction->tmp_ptr,
2635	2635	slice_ptr_index, "");
...	...	@@ -2678,7 +2678,7 @@ static LLVMValueRef ir_render_widen_or_shorten(CodeGen g, IrExecutable executa
2678	2678	// TODO instead of this logic, use the Noop instruction to change the type from
2679	2679	// enum_tag to the underlying int type
2680	2680	ZigType *int_type;
2681		if (actual_type->id == TypeTableEntryIdEnum) {
	2681	if (actual_type->id == ZigTypeIdEnum) {
2682	2682	int_type = actual_type->data.enumeration.tag_int_type;
2683	2683	} else {
2684	2684	int_type = actual_type;
...	...	@@ -2702,7 +2702,7 @@ static LLVMValueRef ir_render_ptr_to_int(CodeGen g, IrExecutable executable, I
2702	2702
2703	2703	static LLVMValueRef ir_render_int_to_enum(CodeGen g, IrExecutable executable, IrInstructionIntToEnum *instruction) {
2704	2704	ZigType *wanted_type = instruction->base.value.type;
2705		assert(wanted_type->id == TypeTableEntryIdEnum);
	2705	assert(wanted_type->id == ZigTypeIdEnum);
2706	2706	ZigType *tag_int_type = wanted_type->data.enumeration.tag_int_type;
2707	2707
2708	2708	LLVMValueRef target_val = ir_llvm_value(g, instruction->target);
...	...	@@ -2729,10 +2729,10 @@ static LLVMValueRef ir_render_int_to_enum(CodeGen g, IrExecutable executable,
2729	2729
2730	2730	static LLVMValueRef ir_render_int_to_err(CodeGen g, IrExecutable executable, IrInstructionIntToErr *instruction) {
2731	2731	ZigType *wanted_type = instruction->base.value.type;
2732		assert(wanted_type->id == TypeTableEntryIdErrorSet);
	2732	assert(wanted_type->id == ZigTypeIdErrorSet);
2733	2733
2734	2734	ZigType *actual_type = instruction->target->value.type;
2735		assert(actual_type->id == TypeTableEntryIdInt);
	2735	assert(actual_type->id == ZigTypeIdInt);
2736	2736	assert(!actual_type->data.integral.is_signed);
2737	2737
2738	2738	LLVMValueRef target_val = ir_llvm_value(g, instruction->target);
...	...	@@ -2746,16 +2746,16 @@ static LLVMValueRef ir_render_int_to_err(CodeGen g, IrExecutable executable, I
2746	2746
2747	2747	static LLVMValueRef ir_render_err_to_int(CodeGen g, IrExecutable executable, IrInstructionErrToInt *instruction) {
2748	2748	ZigType *wanted_type = instruction->base.value.type;
2749		assert(wanted_type->id == TypeTableEntryIdInt);
	2749	assert(wanted_type->id == ZigTypeIdInt);
2750	2750	assert(!wanted_type->data.integral.is_signed);
2751	2751
2752	2752	ZigType *actual_type = instruction->target->value.type;
2753	2753	LLVMValueRef target_val = ir_llvm_value(g, instruction->target);
2754	2754
2755		if (actual_type->id == TypeTableEntryIdErrorSet) {
	2755	if (actual_type->id == ZigTypeIdErrorSet) {
2756	2756	return gen_widen_or_shorten(g, ir_want_runtime_safety(g, &instruction->base),
2757	2757	g->err_tag_type, wanted_type, target_val);
2758		} else if (actual_type->id == TypeTableEntryIdErrorUnion) {
	2758	} else if (actual_type->id == ZigTypeIdErrorUnion) {
2759	2759	// this should have been a compile time constant
2760	2760	assert(type_has_bits(actual_type->data.error_union.err_set_type));
2761	2761
...	...	@@ -2809,10 +2809,10 @@ static LLVMValueRef ir_render_un_op(CodeGen g, IrExecutable executable, IrInst
2809	2809	case IrUnOpNegation:
2810	2810	case IrUnOpNegationWrap:
2811	2811	{
2812		if (expr_type->id == TypeTableEntryIdFloat) {
	2812	if (expr_type->id == ZigTypeIdFloat) {
2813	2813	ZigLLVMSetFastMath(g->builder, ir_want_fast_math(g, &un_op_instruction->base));
2814	2814	return LLVMBuildFNeg(g->builder, expr, "");
2815		} else if (expr_type->id == TypeTableEntryIdInt) {
	2815	} else if (expr_type->id == ZigTypeIdInt) {
2816	2816	if (op_id == IrUnOpNegationWrap) {
2817	2817	return LLVMBuildNeg(g->builder, expr, "");
2818	2818	} else if (ir_want_runtime_safety(g, &un_op_instruction->base)) {
...	...	@@ -2921,7 +2921,7 @@ static LLVMValueRef ir_render_load_ptr(CodeGen g, IrExecutable executable, IrI
2921	2921
2922	2922	LLVMValueRef ptr = ir_llvm_value(g, instruction->ptr);
2923	2923	ZigType *ptr_type = instruction->ptr->value.type;
2924		assert(ptr_type->id == TypeTableEntryIdPointer);
	2924	assert(ptr_type->id == ZigTypeIdPointer);
2925	2925
2926	2926	uint32_t unaligned_bit_count = ptr_type->data.pointer.unaligned_bit_count;
2927	2927	if (unaligned_bit_count == 0)
...	...	@@ -2946,7 +2946,7 @@ static LLVMValueRef ir_render_store_ptr(CodeGen g, IrExecutable executable, Ir
2946	2946	LLVMValueRef ptr = ir_llvm_value(g, instruction->ptr);
2947	2947	LLVMValueRef value = ir_llvm_value(g, instruction->value);
2948	2948
2949		assert(instruction->ptr->value.type->id == TypeTableEntryIdPointer);
	2949	assert(instruction->ptr->value.type->id == ZigTypeIdPointer);
2950	2950	ZigType *ptr_type = instruction->ptr->value.type;
2951	2951
2952	2952	gen_assign_raw(g, ptr, ptr_type, value);
...	...	@@ -2967,7 +2967,7 @@ static LLVMValueRef ir_render_var_ptr(CodeGen g, IrExecutable executable, IrIn
2967	2967	static LLVMValueRef ir_render_elem_ptr(CodeGen g, IrExecutable executable, IrInstructionElemPtr *instruction) {
2968	2968	LLVMValueRef array_ptr_ptr = ir_llvm_value(g, instruction->array_ptr);
2969	2969	ZigType *array_ptr_type = instruction->array_ptr->value.type;
2970		assert(array_ptr_type->id == TypeTableEntryIdPointer);
	2970	assert(array_ptr_type->id == ZigTypeIdPointer);
2971	2971	ZigType *array_type = array_ptr_type->data.pointer.child_type;
2972	2972	LLVMValueRef array_ptr = get_handle_value(g, array_ptr_ptr, array_type, array_ptr_type);
2973	2973	LLVMValueRef subscript_value = ir_llvm_value(g, instruction->elem_index);
...	...	@@ -2978,11 +2978,11 @@ static LLVMValueRef ir_render_elem_ptr(CodeGen g, IrExecutable executable, IrI
2978	2978
2979	2979	bool safety_check_on = ir_want_runtime_safety(g, &instruction->base) && instruction->safety_check_on;
2980	2980
2981		if (array_type->id == TypeTableEntryIdArray \|\|
2982		(array_type->id == TypeTableEntryIdPointer && array_type->data.pointer.ptr_len == PtrLenSingle))
	2981	if (array_type->id == ZigTypeIdArray \|\|
	2982	(array_type->id == ZigTypeIdPointer && array_type->data.pointer.ptr_len == PtrLenSingle))
2983	2983	{
2984		if (array_type->id == TypeTableEntryIdPointer) {
2985		assert(array_type->data.pointer.child_type->id == TypeTableEntryIdArray);
	2984	if (array_type->id == ZigTypeIdPointer) {
	2985	assert(array_type->data.pointer.child_type->id == ZigTypeIdArray);
2986	2986	array_type = array_type->data.pointer.child_type;
2987	2987	}
2988	2988	if (safety_check_on) {
...	...	@@ -2994,7 +2994,7 @@ static LLVMValueRef ir_render_elem_ptr(CodeGen g, IrExecutable executable, IrI
2994	2994	return array_ptr_ptr;
2995	2995	}
2996	2996	ZigType *child_type = array_type->data.array.child_type;
2997		if (child_type->id == TypeTableEntryIdStruct &&
	2997	if (child_type->id == ZigTypeIdStruct &&
2998	2998	child_type->data.structure.layout == ContainerLayoutPacked)
2999	2999	{
3000	3000	size_t unaligned_bit_count = instruction->base.value.type->data.pointer.unaligned_bit_count;
...	...	@@ -3017,13 +3017,13 @@ static LLVMValueRef ir_render_elem_ptr(CodeGen g, IrExecutable executable, IrI
3017	3017	subscript_value
3018	3018	};
3019	3019	return LLVMBuildInBoundsGEP(g->builder, array_ptr, indices, 2, "");
3020		} else if (array_type->id == TypeTableEntryIdPointer) {
	3020	} else if (array_type->id == ZigTypeIdPointer) {
3021	3021	assert(LLVMGetTypeKind(LLVMTypeOf(array_ptr)) == LLVMPointerTypeKind);
3022	3022	LLVMValueRef indices[] = {
3023	3023	subscript_value
3024	3024	};
3025	3025	return LLVMBuildInBoundsGEP(g->builder, array_ptr, indices, 1, "");
3026		} else if (array_type->id == TypeTableEntryIdStruct) {
	3026	} else if (array_type->id == ZigTypeIdStruct) {
3027	3027	assert(array_type->data.structure.is_slice);
3028	3028	if (!type_has_bits(instruction->base.value.type)) {
3029	3029	if (safety_check_on) {
...	...	@@ -3056,8 +3056,8 @@ static LLVMValueRef ir_render_elem_ptr(CodeGen g, IrExecutable executable, IrI
3056	3056
3057	3057	static bool get_prefix_arg_err_ret_stack(CodeGen g, FnTypeId fn_type_id) {
3058	3058	return g->have_err_ret_tracing &&
3059		(fn_type_id->return_type->id == TypeTableEntryIdErrorUnion \|\|
3060		fn_type_id->return_type->id == TypeTableEntryIdErrorSet \|\|
	3059	(fn_type_id->return_type->id == ZigTypeIdErrorUnion \|\|
	3060	fn_type_id->return_type->id == ZigTypeIdErrorSet \|\|
3061	3061	fn_type_id->cc == CallingConventionAsync);
3062	3062	}
3063	3063
...	...	@@ -3201,7 +3201,7 @@ static LLVMValueRef ir_render_call(CodeGen g, IrExecutable executable, IrInstr
3201	3201	return instruction->tmp_ptr;
3202	3202	}
3203	3203
3204		if (src_return_type->id == TypeTableEntryIdUnreachable) {
	3204	if (src_return_type->id == ZigTypeIdUnreachable) {
3205	3205	return LLVMBuildUnreachable(g->builder);
3206	3206	} else if (!ret_has_bits) {
3207	3207	return nullptr;
...	...	@@ -3221,14 +3221,14 @@ static LLVMValueRef ir_render_struct_field_ptr(CodeGen g, IrExecutable executa
3221	3221	IrInstructionStructFieldPtr *instruction)
3222	3222	{
3223	3223	LLVMValueRef struct_ptr = ir_llvm_value(g, instruction->struct_ptr);
3224		// not necessarily a pointer. could be TypeTableEntryIdStruct
	3224	// not necessarily a pointer. could be ZigTypeIdStruct
3225	3225	ZigType *struct_ptr_type = instruction->struct_ptr->value.type;
3226	3226	TypeStructField *field = instruction->field;
3227	3227
3228	3228	if (!type_has_bits(field->type_entry))
3229	3229	return nullptr;
3230	3230
3231		if (struct_ptr_type->id == TypeTableEntryIdPointer &&
	3231	if (struct_ptr_type->id == ZigTypeIdPointer &&
3232	3232	struct_ptr_type->data.pointer.unaligned_bit_count != 0)
3233	3233	{
3234	3234	return struct_ptr;
...	...	@@ -3242,9 +3242,9 @@ static LLVMValueRef ir_render_union_field_ptr(CodeGen g, IrExecutable executab
3242	3242	IrInstructionUnionFieldPtr *instruction)
3243	3243	{
3244	3244	ZigType *union_ptr_type = instruction->union_ptr->value.type;
3245		assert(union_ptr_type->id == TypeTableEntryIdPointer);
	3245	assert(union_ptr_type->id == ZigTypeIdPointer);
3246	3246	ZigType *union_type = union_ptr_type->data.pointer.child_type;
3247		assert(union_type->id == TypeTableEntryIdUnion);
	3247	assert(union_type->id == ZigTypeIdUnion);
3248	3248
3249	3249	TypeUnionField *field = instruction->field;
3250	3250
...	...	@@ -3412,7 +3412,7 @@ static LLVMValueRef ir_render_asm(CodeGen g, IrExecutable executable, IrInstru
3412	3412	}
3413	3413
3414	3414	static LLVMValueRef gen_non_null_bit(CodeGen g, ZigType maybe_type, LLVMValueRef maybe_handle) {
3415		assert(maybe_type->id == TypeTableEntryIdOptional);
	3415	assert(maybe_type->id == ZigTypeIdOptional);
3416	3416	ZigType *child_type = maybe_type->data.maybe.child_type;
3417	3417	if (child_type->zero_bits) {
3418	3418	return maybe_handle;
...	...	@@ -3437,9 +3437,9 @@ static LLVMValueRef ir_render_unwrap_maybe(CodeGen g, IrExecutable executable,
3437	3437	IrInstructionUnwrapOptional *instruction)
3438	3438	{
3439	3439	ZigType *ptr_type = instruction->value->value.type;
3440		assert(ptr_type->id == TypeTableEntryIdPointer);
	3440	assert(ptr_type->id == ZigTypeIdPointer);
3441	3441	ZigType *maybe_type = ptr_type->data.pointer.child_type;
3442		assert(maybe_type->id == TypeTableEntryIdOptional);
	3442	assert(maybe_type->id == ZigTypeIdOptional);
3443	3443	ZigType *child_type = maybe_type->data.maybe.child_type;
3444	3444	LLVMValueRef maybe_ptr = ir_llvm_value(g, instruction->value);
3445	3445	LLVMValueRef maybe_handle = get_handle_value(g, maybe_ptr, maybe_type, ptr_type);
...	...	@@ -3612,7 +3612,7 @@ static LLVMValueRef ir_render_err_name(CodeGen g, IrExecutable executable, IrI
3612	3612	}
3613	3613
3614	3614	static LLVMValueRef get_enum_tag_name_function(CodeGen g, ZigType enum_type) {
3615		assert(enum_type->id == TypeTableEntryIdEnum);
	3615	assert(enum_type->id == ZigTypeIdEnum);
3616	3616	if (enum_type->data.enumeration.name_function)
3617	3617	return enum_type->data.enumeration.name_function;
3618	3618
...	...	@@ -3710,7 +3710,7 @@ static LLVMValueRef ir_render_enum_tag_name(CodeGen g, IrExecutable executable
3710	3710	IrInstructionTagName *instruction)
3711	3711	{
3712	3712	ZigType *enum_type = instruction->target->value.type;
3713		assert(enum_type->id == TypeTableEntryIdEnum);
	3713	assert(enum_type->id == ZigTypeIdEnum);
3714	3714
3715	3715	LLVMValueRef enum_name_function = get_enum_tag_name_function(g, enum_type);
3716	3716
...	...	@@ -3723,7 +3723,7 @@ static LLVMValueRef ir_render_field_parent_ptr(CodeGen g, IrExecutable executa
3723	3723	IrInstructionFieldParentPtr *instruction)
3724	3724	{
3725	3725	ZigType *container_ptr_type = instruction->base.value.type;
3726		assert(container_ptr_type->id == TypeTableEntryIdPointer);
	3726	assert(container_ptr_type->id == ZigTypeIdPointer);
3727	3727
3728	3728	ZigType *container_type = container_ptr_type->data.pointer.child_type;
3729	3729
...	...	@@ -3760,27 +3760,27 @@ static LLVMValueRef ir_render_align_cast(CodeGen g, IrExecutable executable, I
3760	3760	uint32_t align_bytes;
3761	3761	LLVMValueRef ptr_val;
3762	3762
3763		if (target_type->id == TypeTableEntryIdPointer) {
	3763	if (target_type->id == ZigTypeIdPointer) {
3764	3764	align_bytes = target_type->data.pointer.alignment;
3765	3765	ptr_val = target_val;
3766		} else if (target_type->id == TypeTableEntryIdFn) {
	3766	} else if (target_type->id == ZigTypeIdFn) {
3767	3767	align_bytes = target_type->data.fn.fn_type_id.alignment;
3768	3768	ptr_val = target_val;
3769		} else if (target_type->id == TypeTableEntryIdOptional &&
3770		target_type->data.maybe.child_type->id == TypeTableEntryIdPointer)
	3769	} else if (target_type->id == ZigTypeIdOptional &&
	3770	target_type->data.maybe.child_type->id == ZigTypeIdPointer)
3771	3771	{
3772	3772	align_bytes = target_type->data.maybe.child_type->data.pointer.alignment;
3773	3773	ptr_val = target_val;
3774		} else if (target_type->id == TypeTableEntryIdOptional &&
3775		target_type->data.maybe.child_type->id == TypeTableEntryIdFn)
	3774	} else if (target_type->id == ZigTypeIdOptional &&
	3775	target_type->data.maybe.child_type->id == ZigTypeIdFn)
3776	3776	{
3777	3777	align_bytes = target_type->data.maybe.child_type->data.fn.fn_type_id.alignment;
3778	3778	ptr_val = target_val;
3779		} else if (target_type->id == TypeTableEntryIdOptional &&
3780		target_type->data.maybe.child_type->id == TypeTableEntryIdPromise)
	3779	} else if (target_type->id == ZigTypeIdOptional &&
	3780	target_type->data.maybe.child_type->id == ZigTypeIdPromise)
3781	3781	{
3782	3782	zig_panic("TODO audit this function");
3783		} else if (target_type->id == TypeTableEntryIdStruct && target_type->data.structure.is_slice) {
	3783	} else if (target_type->id == ZigTypeIdStruct && target_type->data.structure.is_slice) {
3784	3784	ZigType *slice_ptr_type = target_type->data.structure.fields[slice_ptr_index].type_entry;
3785	3785	align_bytes = slice_ptr_type->data.pointer.alignment;
3786	3786
...	...	@@ -3878,7 +3878,7 @@ static LLVMValueRef ir_render_cmpxchg(CodeGen g, IrExecutable executable, IrIn
3878	3878	success_order, failure_order, instruction->is_weak);
3879	3879
3880	3880	ZigType *maybe_type = instruction->base.value.type;
3881		assert(maybe_type->id == TypeTableEntryIdOptional);
	3881	assert(maybe_type->id == ZigTypeIdOptional);
3882	3882	ZigType *child_type = maybe_type->data.maybe.child_type;
3883	3883
3884	3884	if (type_is_codegen_pointer(child_type)) {
...	...	@@ -3932,7 +3932,7 @@ static LLVMValueRef ir_render_memset(CodeGen g, IrExecutable executable, IrIns
3932	3932	LLVMValueRef dest_ptr_casted = LLVMBuildBitCast(g->builder, dest_ptr, ptr_u8, "");
3933	3933
3934	3934	ZigType *ptr_type = instruction->dest_ptr->value.type;
3935		assert(ptr_type->id == TypeTableEntryIdPointer);
	3935	assert(ptr_type->id == ZigTypeIdPointer);
3936	3936
3937	3937	LLVMValueRef is_volatile = ptr_type->data.pointer.is_volatile ?
3938	3938	LLVMConstAllOnes(LLVMInt1Type()) : LLVMConstNull(LLVMInt1Type());
...	...	@@ -3964,8 +3964,8 @@ static LLVMValueRef ir_render_memcpy(CodeGen g, IrExecutable executable, IrIns
3964	3964	ZigType *dest_ptr_type = instruction->dest_ptr->value.type;
3965	3965	ZigType *src_ptr_type = instruction->src_ptr->value.type;
3966	3966
3967		assert(dest_ptr_type->id == TypeTableEntryIdPointer);
3968		assert(src_ptr_type->id == TypeTableEntryIdPointer);
	3967	assert(dest_ptr_type->id == ZigTypeIdPointer);
	3968	assert(src_ptr_type->id == ZigTypeIdPointer);
3969	3969
3970	3970	LLVMValueRef is_volatile = (dest_ptr_type->data.pointer.is_volatile \|\| src_ptr_type->data.pointer.is_volatile) ?
3971	3971	LLVMConstAllOnes(LLVMInt1Type()) : LLVMConstNull(LLVMInt1Type());
...	...	@@ -3990,7 +3990,7 @@ static LLVMValueRef ir_render_slice(CodeGen g, IrExecutable executable, IrInst
3990	3990
3991	3991	LLVMValueRef array_ptr_ptr = ir_llvm_value(g, instruction->ptr);
3992	3992	ZigType *array_ptr_type = instruction->ptr->value.type;
3993		assert(array_ptr_type->id == TypeTableEntryIdPointer);
	3993	assert(array_ptr_type->id == ZigTypeIdPointer);
3994	3994	ZigType *array_type = array_ptr_type->data.pointer.child_type;
3995	3995	LLVMValueRef array_ptr = get_handle_value(g, array_ptr_ptr, array_type, array_ptr_type);
3996	3996
...	...	@@ -3998,10 +3998,10 @@ static LLVMValueRef ir_render_slice(CodeGen g, IrExecutable executable, IrInst
3998	3998
3999	3999	bool want_runtime_safety = instruction->safety_check_on && ir_want_runtime_safety(g, &instruction->base);
4000	4000
4001		if (array_type->id == TypeTableEntryIdArray \|\|
4002		(array_type->id == TypeTableEntryIdPointer && array_type->data.pointer.ptr_len == PtrLenSingle))
	4001	if (array_type->id == ZigTypeIdArray \|\|
	4002	(array_type->id == ZigTypeIdPointer && array_type->data.pointer.ptr_len == PtrLenSingle))
4003	4003	{
4004		if (array_type->id == TypeTableEntryIdPointer) {
	4004	if (array_type->id == ZigTypeIdPointer) {
4005	4005	array_type = array_type->data.pointer.child_type;
4006	4006	}
4007	4007	LLVMValueRef start_val = ir_llvm_value(g, instruction->start);
...	...	@@ -4042,7 +4042,7 @@ static LLVMValueRef ir_render_slice(CodeGen g, IrExecutable executable, IrInst
4042	4042	gen_store_untyped(g, len_value, len_field_ptr, 0, false);
4043	4043
4044	4044	return tmp_struct_ptr;
4045		} else if (array_type->id == TypeTableEntryIdPointer) {
	4045	} else if (array_type->id == ZigTypeIdPointer) {
4046	4046	assert(array_type->data.pointer.ptr_len == PtrLenUnknown);
4047	4047	LLVMValueRef start_val = ir_llvm_value(g, instruction->start);
4048	4048	LLVMValueRef end_val = ir_llvm_value(g, instruction->end);
...	...	@@ -4064,7 +4064,7 @@ static LLVMValueRef ir_render_slice(CodeGen g, IrExecutable executable, IrInst
4064	4064	gen_store_untyped(g, len_value, len_field_ptr, 0, false);
4065	4065
4066	4066	return tmp_struct_ptr;
4067		} else if (array_type->id == TypeTableEntryIdStruct) {
	4067	} else if (array_type->id == ZigTypeIdStruct) {
4068	4068	assert(array_type->data.structure.is_slice);
4069	4069	assert(LLVMGetTypeKind(LLVMTypeOf(array_ptr)) == LLVMPointerTypeKind);
4070	4070	assert(LLVMGetTypeKind(LLVMGetElementType(LLVMTypeOf(array_ptr))) == LLVMStructTypeKind);
...	...	@@ -4179,7 +4179,7 @@ static LLVMValueRef ir_render_handle(CodeGen g, IrExecutable executable,
4179	4179
4180	4180	static LLVMValueRef render_shl_with_overflow(CodeGen g, IrInstructionOverflowOp instruction) {
4181	4181	ZigType *int_type = instruction->result_ptr_type;
4182		assert(int_type->id == TypeTableEntryIdInt);
	4182	assert(int_type->id == ZigTypeIdInt);
4183	4183
4184	4184	LLVMValueRef op1 = ir_llvm_value(g, instruction->op1);
4185	4185	LLVMValueRef op2 = ir_llvm_value(g, instruction->op2);
...	...	@@ -4219,7 +4219,7 @@ static LLVMValueRef ir_render_overflow_op(CodeGen g, IrExecutable executable,
4219	4219	}
4220	4220
4221	4221	ZigType *int_type = instruction->result_ptr_type;
4222		assert(int_type->id == TypeTableEntryIdInt);
	4222	assert(int_type->id == ZigTypeIdInt);
4223	4223
4224	4224	LLVMValueRef fn_val = get_int_overflow_fn(g, int_type, add_sub_mul);
4225	4225
...	...	@@ -4259,7 +4259,7 @@ static LLVMValueRef ir_render_test_err(CodeGen g, IrExecutable executable, IrI
4259	4259
4260	4260	static LLVMValueRef ir_render_unwrap_err_code(CodeGen g, IrExecutable executable, IrInstructionUnwrapErrCode *instruction) {
4261	4261	ZigType *ptr_type = instruction->value->value.type;
4262		assert(ptr_type->id == TypeTableEntryIdPointer);
	4262	assert(ptr_type->id == ZigTypeIdPointer);
4263	4263	ZigType *err_union_type = ptr_type->data.pointer.child_type;
4264	4264	ZigType *payload_type = err_union_type->data.error_union.payload_type;
4265	4265	LLVMValueRef err_union_ptr = ir_llvm_value(g, instruction->value);
...	...	@@ -4275,7 +4275,7 @@ static LLVMValueRef ir_render_unwrap_err_code(CodeGen g, IrExecutable executab
4275	4275
4276	4276	static LLVMValueRef ir_render_unwrap_err_payload(CodeGen g, IrExecutable executable, IrInstructionUnwrapErrPayload *instruction) {
4277	4277	ZigType *ptr_type = instruction->value->value.type;
4278		assert(ptr_type->id == TypeTableEntryIdPointer);
	4278	assert(ptr_type->id == ZigTypeIdPointer);
4279	4279	ZigType *err_union_type = ptr_type->data.pointer.child_type;
4280	4280	ZigType *payload_type = err_union_type->data.error_union.payload_type;
4281	4281	LLVMValueRef err_union_ptr = ir_llvm_value(g, instruction->value);
...	...	@@ -4315,7 +4315,7 @@ static LLVMValueRef ir_render_unwrap_err_payload(CodeGen g, IrExecutable execu
4315	4315	static LLVMValueRef ir_render_maybe_wrap(CodeGen g, IrExecutable executable, IrInstructionOptionalWrap *instruction) {
4316	4316	ZigType *wanted_type = instruction->base.value.type;
4317	4317
4318		assert(wanted_type->id == TypeTableEntryIdOptional);
	4318	assert(wanted_type->id == ZigTypeIdOptional);
4319	4319
4320	4320	ZigType *child_type = wanted_type->data.maybe.child_type;
4321	4321
...	...	@@ -4342,7 +4342,7 @@ static LLVMValueRef ir_render_maybe_wrap(CodeGen g, IrExecutable executable, I
4342	4342	static LLVMValueRef ir_render_err_wrap_code(CodeGen g, IrExecutable executable, IrInstructionErrWrapCode *instruction) {
4343	4343	ZigType *wanted_type = instruction->base.value.type;
4344	4344
4345		assert(wanted_type->id == TypeTableEntryIdErrorUnion);
	4345	assert(wanted_type->id == ZigTypeIdErrorUnion);
4346	4346
4347	4347	ZigType *payload_type = wanted_type->data.error_union.payload_type;
4348	4348	ZigType *err_set_type = wanted_type->data.error_union.err_set_type;
...	...	@@ -4363,7 +4363,7 @@ static LLVMValueRef ir_render_err_wrap_code(CodeGen g, IrExecutable executable
4363	4363	static LLVMValueRef ir_render_err_wrap_payload(CodeGen g, IrExecutable executable, IrInstructionErrWrapPayload *instruction) {
4364	4364	ZigType *wanted_type = instruction->base.value.type;
4365	4365
4366		assert(wanted_type->id == TypeTableEntryIdErrorUnion);
	4366	assert(wanted_type->id == ZigTypeIdErrorUnion);
4367	4367
4368	4368	ZigType *payload_type = wanted_type->data.error_union.payload_type;
4369	4369	ZigType *err_set_type = wanted_type->data.error_union.err_set_type;
...	...	@@ -4471,7 +4471,7 @@ static LLVMValueRef ir_render_container_init_list(CodeGen g, IrExecutable exec
4471	4471	IrInstructionContainerInitList *instruction)
4472	4472	{
4473	4473	ZigType *array_type = instruction->base.value.type;
4474		assert(array_type->id == TypeTableEntryIdArray);
	4474	assert(array_type->id == ZigTypeIdArray);
4475	4475	LLVMValueRef tmp_array_ptr = instruction->tmp_ptr;
4476	4476	assert(tmp_array_ptr);
4477	4477
...	...	@@ -4605,7 +4605,7 @@ static LLVMValueRef get_coro_alloc_helper_fn_val(CodeGen *g, LLVMTypeRef alloc_f
4605	4605	if (g->coro_alloc_helper_fn_val != nullptr)
4606	4606	return g->coro_alloc_helper_fn_val;
4607	4607
4608		assert(fn_type->id == TypeTableEntryIdFn);
	4608	assert(fn_type->id == ZigTypeIdFn);
4609	4609
4610	4610	ZigType *ptr_to_err_code_type = get_pointer_to_type(g, g->builtin_types.entry_global_error_set, false);
4611	4611
...	...	@@ -4734,7 +4734,7 @@ static LLVMValueRef ir_render_atomic_rmw(CodeGen g, IrExecutable executable,
4734	4734	{
4735	4735	bool is_signed;
4736	4736	ZigType *operand_type = instruction->operand->value.type;
4737		if (operand_type->id == TypeTableEntryIdInt) {
	4737	if (operand_type->id == ZigTypeIdInt) {
4738	4738	is_signed = operand_type->data.integral.is_signed;
4739	4739	} else {
4740	4740	is_signed = false;
...	...	@@ -4789,7 +4789,7 @@ static LLVMValueRef ir_render_mark_err_ret_trace_ptr(CodeGen g, IrExecutable e
4789	4789
4790	4790	static LLVMValueRef ir_render_sqrt(CodeGen g, IrExecutable executable, IrInstructionSqrt *instruction) {
4791	4791	LLVMValueRef op = ir_llvm_value(g, instruction->op);
4792		assert(instruction->base.value.type->id == TypeTableEntryIdFloat);
	4792	assert(instruction->base.value.type->id == ZigTypeIdFloat);
4793	4793	LLVMValueRef fn_val = get_float_fn(g, instruction->base.value.type, ZigLLVMFnIdSqrt);
4794	4794	return LLVMBuildCall(g->builder, fn_val, &op, 1, "");
4795	4795	}
...	...	@@ -5146,56 +5146,56 @@ static LLVMValueRef pack_const_int(CodeGen *g, LLVMTypeRef big_int_type_ref, Con
5146	5146	ZigType *type_entry = const_val->type;
5147	5147	assert(!type_entry->zero_bits);
5148	5148	switch (type_entry->id) {
5149		case TypeTableEntryIdInvalid:
5150		case TypeTableEntryIdMetaType:
5151		case TypeTableEntryIdUnreachable:
5152		case TypeTableEntryIdComptimeFloat:
5153		case TypeTableEntryIdComptimeInt:
5154		case TypeTableEntryIdUndefined:
5155		case TypeTableEntryIdNull:
5156		case TypeTableEntryIdErrorUnion:
5157		case TypeTableEntryIdErrorSet:
5158		case TypeTableEntryIdNamespace:
5159		case TypeTableEntryIdBlock:
5160		case TypeTableEntryIdBoundFn:
5161		case TypeTableEntryIdArgTuple:
5162		case TypeTableEntryIdVoid:
5163		case TypeTableEntryIdOpaque:
	5149	case ZigTypeIdInvalid:
	5150	case ZigTypeIdMetaType:
	5151	case ZigTypeIdUnreachable:
	5152	case ZigTypeIdComptimeFloat:
	5153	case ZigTypeIdComptimeInt:
	5154	case ZigTypeIdUndefined:
	5155	case ZigTypeIdNull:
	5156	case ZigTypeIdErrorUnion:
	5157	case ZigTypeIdErrorSet:
	5158	case ZigTypeIdNamespace:
	5159	case ZigTypeIdBlock:
	5160	case ZigTypeIdBoundFn:
	5161	case ZigTypeIdArgTuple:
	5162	case ZigTypeIdVoid:
	5163	case ZigTypeIdOpaque:
5164	5164	zig_unreachable();
5165		case TypeTableEntryIdBool:
	5165	case ZigTypeIdBool:
5166	5166	return LLVMConstInt(big_int_type_ref, const_val->data.x_bool ? 1 : 0, false);
5167		case TypeTableEntryIdEnum:
	5167	case ZigTypeIdEnum:
5168	5168	{
5169	5169	assert(type_entry->data.enumeration.decl_node->data.container_decl.init_arg_expr != nullptr);
5170	5170	LLVMValueRef int_val = gen_const_val(g, const_val, "");
5171	5171	return LLVMConstZExt(int_val, big_int_type_ref);
5172	5172	}
5173		case TypeTableEntryIdInt:
	5173	case ZigTypeIdInt:
5174	5174	{
5175	5175	LLVMValueRef int_val = gen_const_val(g, const_val, "");
5176	5176	return LLVMConstZExt(int_val, big_int_type_ref);
5177	5177	}
5178		case TypeTableEntryIdFloat:
	5178	case ZigTypeIdFloat:
5179	5179	{
5180	5180	LLVMValueRef float_val = gen_const_val(g, const_val, "");
5181	5181	LLVMValueRef int_val = LLVMConstFPToUI(float_val,
5182	5182	LLVMIntType((unsigned)type_entry->data.floating.bit_count));
5183	5183	return LLVMConstZExt(int_val, big_int_type_ref);
5184	5184	}
5185		case TypeTableEntryIdPointer:
5186		case TypeTableEntryIdFn:
5187		case TypeTableEntryIdOptional:
5188		case TypeTableEntryIdPromise:
	5185	case ZigTypeIdPointer:
	5186	case ZigTypeIdFn:
	5187	case ZigTypeIdOptional:
	5188	case ZigTypeIdPromise:
5189	5189	{
5190	5190	LLVMValueRef ptr_val = gen_const_val(g, const_val, "");
5191	5191	LLVMValueRef ptr_size_int_val = LLVMConstPtrToInt(ptr_val, g->builtin_types.entry_usize->type_ref);
5192	5192	return LLVMConstZExt(ptr_size_int_val, big_int_type_ref);
5193	5193	}
5194		case TypeTableEntryIdArray:
	5194	case ZigTypeIdArray:
5195	5195	zig_panic("TODO bit pack an array");
5196		case TypeTableEntryIdUnion:
	5196	case ZigTypeIdUnion:
5197	5197	zig_panic("TODO bit pack a union");
5198		case TypeTableEntryIdStruct:
	5198	case ZigTypeIdStruct:
5199	5199	{
5200	5200	assert(type_entry->data.structure.layout == ContainerLayoutPacked);
5201	5201	bool is_big_endian = g->is_big_endian; // TODO get endianness from struct type
...	...	@@ -5253,7 +5253,7 @@ static LLVMValueRef gen_const_val_ptr(CodeGen g, ConstExprValue const_val, con
5253	5253	render_const_val_global(g, const_val, name);
5254	5254	ConstExprValue *array_const_val = const_val->data.x_ptr.data.base_array.array_val;
5255	5255	size_t elem_index = const_val->data.x_ptr.data.base_array.elem_index;
5256		assert(array_const_val->type->id == TypeTableEntryIdArray);
	5256	assert(array_const_val->type->id == ZigTypeIdArray);
5257	5257	if (array_const_val->type->zero_bits) {
5258	5258	// make this a null pointer
5259	5259	ZigType *usize = g->builtin_types.entry_usize;
...	...	@@ -5273,7 +5273,7 @@ static LLVMValueRef gen_const_val_ptr(CodeGen g, ConstExprValue const_val, con
5273	5273	{
5274	5274	render_const_val_global(g, const_val, name);
5275	5275	ConstExprValue *struct_const_val = const_val->data.x_ptr.data.base_struct.struct_val;
5276		assert(struct_const_val->type->id == TypeTableEntryIdStruct);
	5276	assert(struct_const_val->type->id == ZigTypeIdStruct);
5277	5277	if (struct_const_val->type->zero_bits) {
5278	5278	// make this a null pointer
5279	5279	ZigType *usize = g->builtin_types.entry_usize;
...	...	@@ -5322,13 +5322,13 @@ static LLVMValueRef gen_const_val(CodeGen g, ConstExprValue const_val, const c
5322	5322	}
5323	5323
5324	5324	switch (type_entry->id) {
5325		case TypeTableEntryIdInt:
	5325	case ZigTypeIdInt:
5326	5326	return bigint_to_llvm_const(type_entry->type_ref, &const_val->data.x_bigint);
5327		case TypeTableEntryIdErrorSet:
	5327	case ZigTypeIdErrorSet:
5328	5328	assert(const_val->data.x_err_set != nullptr);
5329	5329	return LLVMConstInt(g->builtin_types.entry_global_error_set->type_ref,
5330	5330	const_val->data.x_err_set->value, false);
5331		case TypeTableEntryIdFloat:
	5331	case ZigTypeIdFloat:
5332	5332	switch (type_entry->data.floating.bit_count) {
5333	5333	case 16:
5334	5334	return LLVMConstReal(type_entry->type_ref, zig_f16_to_double(const_val->data.x_f16));
...	...	@@ -5348,13 +5348,13 @@ static LLVMValueRef gen_const_val(CodeGen g, ConstExprValue const_val, const c
5348	5348	default:
5349	5349	zig_unreachable();
5350	5350	}
5351		case TypeTableEntryIdBool:
	5351	case ZigTypeIdBool:
5352	5352	if (const_val->data.x_bool) {
5353	5353	return LLVMConstAllOnes(LLVMInt1Type());
5354	5354	} else {
5355	5355	return LLVMConstNull(LLVMInt1Type());
5356	5356	}
5357		case TypeTableEntryIdOptional:
	5357	case ZigTypeIdOptional:
5358	5358	{
5359	5359	ZigType *child_type = type_entry->data.maybe.child_type;
5360	5360	if (child_type->zero_bits) {
...	...	@@ -5387,7 +5387,7 @@ static LLVMValueRef gen_const_val(CodeGen g, ConstExprValue const_val, const c
5387	5387	}
5388	5388	}
5389	5389	}
5390		case TypeTableEntryIdStruct:
	5390	case ZigTypeIdStruct:
5391	5391	{
5392	5392	LLVMValueRef *fields = allocate<LLVMValueRef>(type_entry->data.structure.gen_field_count);
5393	5393	size_t src_field_count = type_entry->data.structure.src_field_count;
...	...	@@ -5463,7 +5463,7 @@ static LLVMValueRef gen_const_val(CodeGen g, ConstExprValue const_val, const c
5463	5463	return LLVMConstNamedStruct(type_entry->type_ref, fields, type_entry->data.structure.gen_field_count);
5464	5464	}
5465	5465	}
5466		case TypeTableEntryIdArray:
	5466	case ZigTypeIdArray:
5467	5467	{
5468	5468	uint64_t len = type_entry->data.array.len;
5469	5469	if (const_val->data.x_array.special == ConstArraySpecialUndef) {
...	...	@@ -5485,7 +5485,7 @@ static LLVMValueRef gen_const_val(CodeGen g, ConstExprValue const_val, const c
5485	5485	return LLVMConstArray(element_type_ref, values, (unsigned)len);
5486	5486	}
5487	5487	}
5488		case TypeTableEntryIdUnion:
	5488	case ZigTypeIdUnion:
5489	5489	{
5490	5490	LLVMTypeRef union_type_ref = type_entry->data.unionation.union_type_ref;
5491	5491
...	...	@@ -5549,15 +5549,15 @@ static LLVMValueRef gen_const_val(CodeGen g, ConstExprValue const_val, const c
5549	5549
5550	5550	}
5551	5551
5552		case TypeTableEntryIdEnum:
	5552	case ZigTypeIdEnum:
5553	5553	return bigint_to_llvm_const(type_entry->type_ref, &const_val->data.x_enum_tag);
5554		case TypeTableEntryIdFn:
	5554	case ZigTypeIdFn:
5555	5555	assert(const_val->data.x_ptr.special == ConstPtrSpecialFunction);
5556	5556	assert(const_val->data.x_ptr.mut == ConstPtrMutComptimeConst);
5557	5557	return fn_llvm_value(g, const_val->data.x_ptr.data.fn.fn_entry);
5558		case TypeTableEntryIdPointer:
	5558	case ZigTypeIdPointer:
5559	5559	return gen_const_val_ptr(g, const_val, name);
5560		case TypeTableEntryIdErrorUnion:
	5560	case ZigTypeIdErrorUnion:
5561	5561	{
5562	5562	ZigType *payload_type = type_entry->data.error_union.payload_type;
5563	5563	ZigType *err_set_type = type_entry->data.error_union.err_set_type;
...	...	@@ -5593,21 +5593,21 @@ static LLVMValueRef gen_const_val(CodeGen g, ConstExprValue const_val, const c
5593	5593	}
5594	5594	}
5595	5595	}
5596		case TypeTableEntryIdVoid:
	5596	case ZigTypeIdVoid:
5597	5597	return nullptr;
5598		case TypeTableEntryIdInvalid:
5599		case TypeTableEntryIdMetaType:
5600		case TypeTableEntryIdUnreachable:
5601		case TypeTableEntryIdComptimeFloat:
5602		case TypeTableEntryIdComptimeInt:
5603		case TypeTableEntryIdUndefined:
5604		case TypeTableEntryIdNull:
5605		case TypeTableEntryIdNamespace:
5606		case TypeTableEntryIdBlock:
5607		case TypeTableEntryIdBoundFn:
5608		case TypeTableEntryIdArgTuple:
5609		case TypeTableEntryIdOpaque:
5610		case TypeTableEntryIdPromise:
	5598	case ZigTypeIdInvalid:
	5599	case ZigTypeIdMetaType:
	5600	case ZigTypeIdUnreachable:
	5601	case ZigTypeIdComptimeFloat:
	5602	case ZigTypeIdComptimeInt:
	5603	case ZigTypeIdUndefined:
	5604	case ZigTypeIdNull:
	5605	case ZigTypeIdNamespace:
	5606	case ZigTypeIdBlock:
	5607	case ZigTypeIdBoundFn:
	5608	case ZigTypeIdArgTuple:
	5609	case ZigTypeIdOpaque:
	5610	case ZigTypeIdPromise:
5611	5611	zig_unreachable();
5612	5612
5613	5613	}
...	...	@@ -5790,7 +5790,7 @@ static void do_code_gen(CodeGen *g) {
5790	5790	TldVar *tld_var = g->global_vars.at(i);
5791	5791	ZigVar *var = tld_var->var;
5792	5792
5793		if (var->value->type->id == TypeTableEntryIdComptimeFloat) {
	5793	if (var->value->type->id == ZigTypeIdComptimeFloat) {
5794	5794	// Generate debug info for it but that's it.
5795	5795	ConstExprValue *const_val = var->value;
5796	5796	assert(const_val->special != ConstValSpecialRuntime);
...	...	@@ -5804,7 +5804,7 @@ static void do_code_gen(CodeGen *g) {
5804	5804	continue;
5805	5805	}
5806	5806
5807		if (var->value->type->id == TypeTableEntryIdComptimeInt) {
	5807	if (var->value->type->id == ZigTypeIdComptimeInt) {
5808	5808	// Generate debug info for it but that's it.
5809	5809	ConstExprValue *const_val = var->value;
5810	5810	assert(const_val->special != ConstValSpecialRuntime);
...	...	@@ -5852,7 +5852,7 @@ static void do_code_gen(CodeGen *g) {
5852	5852	LLVMSetAlignment(global_value, var->align_bytes);
5853	5853
5854	5854	// TODO debug info for function pointers
5855		if (var->gen_is_const && var->value->type->id != TypeTableEntryIdFn) {
	5855	if (var->gen_is_const && var->value->type->id != ZigTypeIdFn) {
5856	5856	gen_global_var(g, var, var->value->global_refs->llvm_value, var->value->type);
5857	5857	}
5858	5858
...	...	@@ -5910,7 +5910,7 @@ static void do_code_gen(CodeGen *g) {
5910	5910	} else if (instruction->id == IrInstructionIdRef) {
5911	5911	IrInstructionRef ref_instruction = (IrInstructionRef )instruction;
5912	5912	slot = &ref_instruction->tmp_ptr;
5913		assert(instruction->value.type->id == TypeTableEntryIdPointer);
	5913	assert(instruction->value.type->id == ZigTypeIdPointer);
5914	5914	slot_type = instruction->value.type->data.pointer.child_type;
5915	5915	} else if (instruction->id == IrInstructionIdContainerInitList) {
5916	5916	IrInstructionContainerInitList container_init_list_instruction = (IrInstructionContainerInitList )instruction;
...	...	@@ -6173,51 +6173,51 @@ static const GlobalLinkageValue global_linkage_values[] = {
6173	6173	static void define_builtin_types(CodeGen *g) {
6174	6174	{
6175	6175	// if this type is anywhere in the AST, we should never hit codegen.
6176		ZigType *entry = new_type_table_entry(TypeTableEntryIdInvalid);
	6176	ZigType *entry = new_type_table_entry(ZigTypeIdInvalid);
6177	6177	buf_init_from_str(&entry->name, "(invalid)");
6178	6178	entry->zero_bits = true;
6179	6179	g->builtin_types.entry_invalid = entry;
6180	6180	}
6181	6181	{
6182		ZigType *entry = new_type_table_entry(TypeTableEntryIdNamespace);
	6182	ZigType *entry = new_type_table_entry(ZigTypeIdNamespace);
6183	6183	buf_init_from_str(&entry->name, "(namespace)");
6184	6184	entry->zero_bits = true;
6185	6185	g->builtin_types.entry_namespace = entry;
6186	6186	}
6187	6187	{
6188		ZigType *entry = new_type_table_entry(TypeTableEntryIdBlock);
	6188	ZigType *entry = new_type_table_entry(ZigTypeIdBlock);
6189	6189	buf_init_from_str(&entry->name, "(block)");
6190	6190	entry->zero_bits = true;
6191	6191	g->builtin_types.entry_block = entry;
6192	6192	}
6193	6193	{
6194		ZigType *entry = new_type_table_entry(TypeTableEntryIdComptimeFloat);
	6194	ZigType *entry = new_type_table_entry(ZigTypeIdComptimeFloat);
6195	6195	buf_init_from_str(&entry->name, "comptime_float");
6196	6196	entry->zero_bits = true;
6197	6197	g->builtin_types.entry_num_lit_float = entry;
6198	6198	g->primitive_type_table.put(&entry->name, entry);
6199	6199	}
6200	6200	{
6201		ZigType *entry = new_type_table_entry(TypeTableEntryIdComptimeInt);
	6201	ZigType *entry = new_type_table_entry(ZigTypeIdComptimeInt);
6202	6202	buf_init_from_str(&entry->name, "comptime_int");
6203	6203	entry->zero_bits = true;
6204	6204	g->builtin_types.entry_num_lit_int = entry;
6205	6205	g->primitive_type_table.put(&entry->name, entry);
6206	6206	}
6207	6207	{
6208		ZigType *entry = new_type_table_entry(TypeTableEntryIdUndefined);
	6208	ZigType *entry = new_type_table_entry(ZigTypeIdUndefined);
6209	6209	buf_init_from_str(&entry->name, "(undefined)");
6210	6210	entry->zero_bits = true;
6211	6211	g->builtin_types.entry_undef = entry;
6212	6212	}
6213	6213	{
6214		ZigType *entry = new_type_table_entry(TypeTableEntryIdNull);
	6214	ZigType *entry = new_type_table_entry(ZigTypeIdNull);
6215	6215	buf_init_from_str(&entry->name, "(null)");
6216	6216	entry->zero_bits = true;
6217	6217	g->builtin_types.entry_null = entry;
6218	6218	}
6219	6219	{
6220		ZigType *entry = new_type_table_entry(TypeTableEntryIdArgTuple);
	6220	ZigType *entry = new_type_table_entry(ZigTypeIdArgTuple);
6221	6221	buf_init_from_str(&entry->name, "(args)");
6222	6222	entry->zero_bits = true;
6223	6223	g->builtin_types.entry_arg_tuple = entry;
...	...	@@ -6228,7 +6228,7 @@ static void define_builtin_types(CodeGen *g) {
6228	6228	uint32_t size_in_bits = target_c_type_size_in_bits(&g->zig_target, info->id);
6229	6229	bool is_signed = info->is_signed;
6230	6230
6231		ZigType *entry = new_type_table_entry(TypeTableEntryIdInt);
	6231	ZigType *entry = new_type_table_entry(ZigTypeIdInt);
6232	6232	entry->type_ref = LLVMIntType(size_in_bits);
6233	6233
6234	6234	buf_init_from_str(&entry->name, info->name);
...	...	@@ -6245,7 +6245,7 @@ static void define_builtin_types(CodeGen *g) {
6245	6245	}
6246	6246
6247	6247	{
6248		ZigType *entry = new_type_table_entry(TypeTableEntryIdBool);
	6248	ZigType *entry = new_type_table_entry(ZigTypeIdBool);
6249	6249	entry->type_ref = LLVMInt1Type();
6250	6250	buf_init_from_str(&entry->name, "bool");
6251	6251	uint64_t debug_size_in_bits = 8*LLVMStoreSizeOfType(g->target_data_ref, entry->type_ref);
...	...	@@ -6259,7 +6259,7 @@ static void define_builtin_types(CodeGen *g) {
6259	6259	for (size_t sign_i = 0; sign_i < array_length(is_signed_list); sign_i += 1) {
6260	6260	bool is_signed = is_signed_list[sign_i];
6261	6261
6262		ZigType *entry = new_type_table_entry(TypeTableEntryIdInt);
	6262	ZigType *entry = new_type_table_entry(ZigTypeIdInt);
6263	6263	entry->type_ref = LLVMIntType(g->pointer_size_bytes * 8);
6264	6264
6265	6265	const char u_or_i = is_signed ? 'i' : 'u';
...	...	@@ -6287,7 +6287,7 @@ static void define_builtin_types(CodeGen *g) {
6287	6287	uint32_t bit_count,
6288	6288	LLVMTypeRef type_ref,
6289	6289	ZigType **field) {
6290		ZigType *entry = new_type_table_entry(TypeTableEntryIdFloat);
	6290	ZigType *entry = new_type_table_entry(ZigTypeIdFloat);
6291	6291	entry->type_ref = type_ref;
6292	6292	buf_init_from_str(&entry->name, name);
6293	6293	entry->data.floating.bit_count = bit_count;
...	...	@@ -6306,7 +6306,7 @@ static void define_builtin_types(CodeGen *g) {
6306	6306	add_fp_entry(g, "c_longdouble", 80, LLVMX86FP80Type(), &g->builtin_types.entry_c_longdouble);
6307	6307
6308	6308	{
6309		ZigType *entry = new_type_table_entry(TypeTableEntryIdVoid);
	6309	ZigType *entry = new_type_table_entry(ZigTypeIdVoid);
6310	6310	entry->type_ref = LLVMVoidType();
6311	6311	entry->zero_bits = true;
6312	6312	buf_init_from_str(&entry->name, "void");
...	...	@@ -6317,7 +6317,7 @@ static void define_builtin_types(CodeGen *g) {
6317	6317	g->primitive_type_table.put(&entry->name, entry);
6318	6318	}
6319	6319	{
6320		ZigType *entry = new_type_table_entry(TypeTableEntryIdUnreachable);
	6320	ZigType *entry = new_type_table_entry(ZigTypeIdUnreachable);
6321	6321	entry->type_ref = LLVMVoidType();
6322	6322	entry->zero_bits = true;
6323	6323	buf_init_from_str(&entry->name, "noreturn");
...	...	@@ -6326,7 +6326,7 @@ static void define_builtin_types(CodeGen *g) {
6326	6326	g->primitive_type_table.put(&entry->name, entry);
6327	6327	}
6328	6328	{
6329		ZigType *entry = new_type_table_entry(TypeTableEntryIdMetaType);
	6329	ZigType *entry = new_type_table_entry(ZigTypeIdMetaType);
6330	6330	buf_init_from_str(&entry->name, "type");
6331	6331	entry->zero_bits = true;
6332	6332	g->builtin_types.entry_type = entry;
...	...	@@ -6348,7 +6348,7 @@ static void define_builtin_types(CodeGen *g) {
6348	6348	}
6349	6349
6350	6350	{
6351		ZigType *entry = new_type_table_entry(TypeTableEntryIdErrorSet);
	6351	ZigType *entry = new_type_table_entry(ZigTypeIdErrorSet);
6352	6352	buf_init_from_str(&entry->name, "error");
6353	6353	entry->data.error_set.err_count = UINT32_MAX;
6354	6354
...	...	@@ -7226,57 +7226,57 @@ static void prepend_c_type_to_decl_list(CodeGen g, GenH gen_h, ZigType *type_e
7226	7226	type_entry->gen_h_loop_flag = true;
7227	7227
7228	7228	switch (type_entry->id) {
7229		case TypeTableEntryIdInvalid:
7230		case TypeTableEntryIdMetaType:
7231		case TypeTableEntryIdComptimeFloat:
7232		case TypeTableEntryIdComptimeInt:
7233		case TypeTableEntryIdUndefined:
7234		case TypeTableEntryIdNull:
7235		case TypeTableEntryIdNamespace:
7236		case TypeTableEntryIdBlock:
7237		case TypeTableEntryIdBoundFn:
7238		case TypeTableEntryIdArgTuple:
7239		case TypeTableEntryIdErrorUnion:
7240		case TypeTableEntryIdErrorSet:
7241		case TypeTableEntryIdPromise:
	7229	case ZigTypeIdInvalid:
	7230	case ZigTypeIdMetaType:
	7231	case ZigTypeIdComptimeFloat:
	7232	case ZigTypeIdComptimeInt:
	7233	case ZigTypeIdUndefined:
	7234	case ZigTypeIdNull:
	7235	case ZigTypeIdNamespace:
	7236	case ZigTypeIdBlock:
	7237	case ZigTypeIdBoundFn:
	7238	case ZigTypeIdArgTuple:
	7239	case ZigTypeIdErrorUnion:
	7240	case ZigTypeIdErrorSet:
	7241	case ZigTypeIdPromise:
7242	7242	zig_unreachable();
7243		case TypeTableEntryIdVoid:
7244		case TypeTableEntryIdUnreachable:
7245		case TypeTableEntryIdBool:
7246		case TypeTableEntryIdInt:
7247		case TypeTableEntryIdFloat:
	7243	case ZigTypeIdVoid:
	7244	case ZigTypeIdUnreachable:
	7245	case ZigTypeIdBool:
	7246	case ZigTypeIdInt:
	7247	case ZigTypeIdFloat:
7248	7248	return;
7249		case TypeTableEntryIdOpaque:
	7249	case ZigTypeIdOpaque:
7250	7250	gen_h->types_to_declare.append(type_entry);
7251	7251	return;
7252		case TypeTableEntryIdStruct:
	7252	case ZigTypeIdStruct:
7253	7253	for (uint32_t i = 0; i < type_entry->data.structure.src_field_count; i += 1) {
7254	7254	TypeStructField *field = &type_entry->data.structure.fields[i];
7255	7255	prepend_c_type_to_decl_list(g, gen_h, field->type_entry);
7256	7256	}
7257	7257	gen_h->types_to_declare.append(type_entry);
7258	7258	return;
7259		case TypeTableEntryIdUnion:
	7259	case ZigTypeIdUnion:
7260	7260	for (uint32_t i = 0; i < type_entry->data.unionation.src_field_count; i += 1) {
7261	7261	TypeUnionField *field = &type_entry->data.unionation.fields[i];
7262	7262	prepend_c_type_to_decl_list(g, gen_h, field->type_entry);
7263	7263	}
7264	7264	gen_h->types_to_declare.append(type_entry);
7265	7265	return;
7266		case TypeTableEntryIdEnum:
	7266	case ZigTypeIdEnum:
7267	7267	prepend_c_type_to_decl_list(g, gen_h, type_entry->data.enumeration.tag_int_type);
7268	7268	gen_h->types_to_declare.append(type_entry);
7269	7269	return;
7270		case TypeTableEntryIdPointer:
	7270	case ZigTypeIdPointer:
7271	7271	prepend_c_type_to_decl_list(g, gen_h, type_entry->data.pointer.child_type);
7272	7272	return;
7273		case TypeTableEntryIdArray:
	7273	case ZigTypeIdArray:
7274	7274	prepend_c_type_to_decl_list(g, gen_h, type_entry->data.array.child_type);
7275	7275	return;
7276		case TypeTableEntryIdOptional:
	7276	case ZigTypeIdOptional:
7277	7277	prepend_c_type_to_decl_list(g, gen_h, type_entry->data.maybe.child_type);
7278	7278	return;
7279		case TypeTableEntryIdFn:
	7279	case ZigTypeIdFn:
7280	7280	for (size_t i = 0; i < type_entry->data.fn.fn_type_id.param_count; i += 1) {
7281	7281	prepend_c_type_to_decl_list(g, gen_h, type_entry->data.fn.fn_type_id.param_info[i].type);
7282	7282	}
...	...	@@ -7316,17 +7316,17 @@ static void get_c_type(CodeGen g, GenH gen_h, ZigType type_entry, Buf out_bu
7316	7316	prepend_c_type_to_decl_list(g, gen_h, type_entry);
7317	7317
7318	7318	switch (type_entry->id) {
7319		case TypeTableEntryIdVoid:
	7319	case ZigTypeIdVoid:
7320	7320	buf_init_from_str(out_buf, "void");
7321	7321	break;
7322		case TypeTableEntryIdBool:
	7322	case ZigTypeIdBool:
7323	7323	buf_init_from_str(out_buf, "bool");
7324	7324	g->c_want_stdbool = true;
7325	7325	break;
7326		case TypeTableEntryIdUnreachable:
	7326	case ZigTypeIdUnreachable:
7327	7327	buf_init_from_str(out_buf, "__attribute__((__noreturn__)) void");
7328	7328	break;
7329		case TypeTableEntryIdFloat:
	7329	case ZigTypeIdFloat:
7330	7330	switch (type_entry->data.floating.bit_count) {
7331	7331	case 32:
7332	7332	buf_init_from_str(out_buf, "float");
...	...	@@ -7344,14 +7344,14 @@ static void get_c_type(CodeGen g, GenH gen_h, ZigType type_entry, Buf out_bu
7344	7344	zig_unreachable();
7345	7345	}
7346	7346	break;
7347		case TypeTableEntryIdInt:
	7347	case ZigTypeIdInt:
7348	7348	g->c_want_stdint = true;
7349	7349	buf_resize(out_buf, 0);
7350	7350	buf_appendf(out_buf, "%sint%" PRIu32 "_t",
7351	7351	type_entry->data.integral.is_signed ? "" : "u",
7352	7352	type_entry->data.integral.bit_count);
7353	7353	break;
7354		case TypeTableEntryIdPointer:
	7354	case ZigTypeIdPointer:
7355	7355	{
7356	7356	Buf child_buf = BUF_INIT;
7357	7357	ZigType *child_type = type_entry->data.pointer.child_type;
...	...	@@ -7362,7 +7362,7 @@ static void get_c_type(CodeGen g, GenH gen_h, ZigType type_entry, Buf out_bu
7362	7362	buf_appendf(out_buf, "%s%s *", const_str, buf_ptr(&child_buf));
7363	7363	break;
7364	7364	}
7365		case TypeTableEntryIdOptional:
	7365	case ZigTypeIdOptional:
7366	7366	{
7367	7367	ZigType *child_type = type_entry->data.maybe.child_type;
7368	7368	if (child_type->zero_bits) {
...	...	@@ -7374,28 +7374,28 @@ static void get_c_type(CodeGen g, GenH gen_h, ZigType type_entry, Buf out_bu
7374	7374	zig_unreachable();
7375	7375	}
7376	7376	}
7377		case TypeTableEntryIdStruct:
7378		case TypeTableEntryIdOpaque:
	7377	case ZigTypeIdStruct:
	7378	case ZigTypeIdOpaque:
7379	7379	{
7380	7380	buf_init_from_str(out_buf, "struct ");
7381	7381	buf_append_buf(out_buf, &type_entry->name);
7382	7382	return;
7383	7383	}
7384		case TypeTableEntryIdUnion:
	7384	case ZigTypeIdUnion:
7385	7385	{
7386	7386	buf_init_from_str(out_buf, "union ");
7387	7387	buf_append_buf(out_buf, &type_entry->name);
7388	7388	return;
7389	7389	}
7390		case TypeTableEntryIdEnum:
	7390	case ZigTypeIdEnum:
7391	7391	{
7392	7392	buf_init_from_str(out_buf, "enum ");
7393	7393	buf_append_buf(out_buf, &type_entry->name);
7394	7394	return;
7395	7395	}
7396		case TypeTableEntryIdArray:
	7396	case ZigTypeIdArray:
7397	7397	{
7398		TypeTableEntryArray *array_data = &type_entry->data.array;
	7398	ZigTypeArray *array_data = &type_entry->data.array;
7399	7399
7400	7400	Buf *child_buf = buf_alloc();
7401	7401	get_c_type(g, gen_h, array_data->child_type, child_buf);
...	...	@@ -7404,21 +7404,21 @@ static void get_c_type(CodeGen g, GenH gen_h, ZigType type_entry, Buf out_bu
7404	7404	buf_appendf(out_buf, "%s", buf_ptr(child_buf));
7405	7405	return;
7406	7406	}
7407		case TypeTableEntryIdErrorUnion:
7408		case TypeTableEntryIdErrorSet:
7409		case TypeTableEntryIdFn:
	7407	case ZigTypeIdErrorUnion:
	7408	case ZigTypeIdErrorSet:
	7409	case ZigTypeIdFn:
7410	7410	zig_panic("TODO implement get_c_type for more types");
7411		case TypeTableEntryIdInvalid:
7412		case TypeTableEntryIdMetaType:
7413		case TypeTableEntryIdBoundFn:
7414		case TypeTableEntryIdNamespace:
7415		case TypeTableEntryIdBlock:
7416		case TypeTableEntryIdComptimeFloat:
7417		case TypeTableEntryIdComptimeInt:
7418		case TypeTableEntryIdUndefined:
7419		case TypeTableEntryIdNull:
7420		case TypeTableEntryIdArgTuple:
7421		case TypeTableEntryIdPromise:
	7411	case ZigTypeIdInvalid:
	7412	case ZigTypeIdMetaType:
	7413	case ZigTypeIdBoundFn:
	7414	case ZigTypeIdNamespace:
	7415	case ZigTypeIdBlock:
	7416	case ZigTypeIdComptimeFloat:
	7417	case ZigTypeIdComptimeInt:
	7418	case ZigTypeIdUndefined:
	7419	case ZigTypeIdNull:
	7420	case ZigTypeIdArgTuple:
	7421	case ZigTypeIdPromise:
7422	7422	zig_unreachable();
7423	7423	}
7424	7424	}
...	...	@@ -7509,7 +7509,7 @@ static void gen_h_file(CodeGen *g) {
7509	7509	const char *restrict_str = param_info->is_noalias ? "restrict" : "";
7510	7510	get_c_type(g, gen_h, param_info->type, &param_type_c);
7511	7511
7512		if (param_info->type->id == TypeTableEntryIdArray) {
	7512	if (param_info->type->id == ZigTypeIdArray) {
7513	7513	// Arrays decay to pointers
7514	7514	buf_appendf(&h_buf, "%s%s%s %s[]", comma_str, buf_ptr(&param_type_c),
7515	7515	restrict_str, buf_ptr(param_name));
...	...	@@ -7557,30 +7557,30 @@ static void gen_h_file(CodeGen *g) {
7557	7557	for (size_t type_i = 0; type_i < gen_h->types_to_declare.length; type_i += 1) {
7558	7558	ZigType *type_entry = gen_h->types_to_declare.at(type_i);
7559	7559	switch (type_entry->id) {
7560		case TypeTableEntryIdInvalid:
7561		case TypeTableEntryIdMetaType:
7562		case TypeTableEntryIdVoid:
7563		case TypeTableEntryIdBool:
7564		case TypeTableEntryIdUnreachable:
7565		case TypeTableEntryIdInt:
7566		case TypeTableEntryIdFloat:
7567		case TypeTableEntryIdPointer:
7568		case TypeTableEntryIdComptimeFloat:
7569		case TypeTableEntryIdComptimeInt:
7570		case TypeTableEntryIdArray:
7571		case TypeTableEntryIdUndefined:
7572		case TypeTableEntryIdNull:
7573		case TypeTableEntryIdErrorUnion:
7574		case TypeTableEntryIdErrorSet:
7575		case TypeTableEntryIdNamespace:
7576		case TypeTableEntryIdBlock:
7577		case TypeTableEntryIdBoundFn:
7578		case TypeTableEntryIdArgTuple:
7579		case TypeTableEntryIdOptional:
7580		case TypeTableEntryIdFn:
7581		case TypeTableEntryIdPromise:
	7560	case ZigTypeIdInvalid:
	7561	case ZigTypeIdMetaType:
	7562	case ZigTypeIdVoid:
	7563	case ZigTypeIdBool:
	7564	case ZigTypeIdUnreachable:
	7565	case ZigTypeIdInt:
	7566	case ZigTypeIdFloat:
	7567	case ZigTypeIdPointer:
	7568	case ZigTypeIdComptimeFloat:
	7569	case ZigTypeIdComptimeInt:
	7570	case ZigTypeIdArray:
	7571	case ZigTypeIdUndefined:
	7572	case ZigTypeIdNull:
	7573	case ZigTypeIdErrorUnion:
	7574	case ZigTypeIdErrorSet:
	7575	case ZigTypeIdNamespace:
	7576	case ZigTypeIdBlock:
	7577	case ZigTypeIdBoundFn:
	7578	case ZigTypeIdArgTuple:
	7579	case ZigTypeIdOptional:
	7580	case ZigTypeIdFn:
	7581	case ZigTypeIdPromise:
7582	7582	zig_unreachable();
7583		case TypeTableEntryIdEnum:
	7583	case ZigTypeIdEnum:
7584	7584	if (type_entry->data.enumeration.layout == ContainerLayoutExtern) {
7585	7585	fprintf(out_h, "enum %s {\n", buf_ptr(&type_entry->name));
7586	7586	for (uint32_t field_i = 0; field_i < type_entry->data.enumeration.src_field_count; field_i += 1) {
...	...	@@ -7598,7 +7598,7 @@ static void gen_h_file(CodeGen *g) {
7598	7598	fprintf(out_h, "enum %s;\n", buf_ptr(&type_entry->name));
7599	7599	}
7600	7600	break;
7601		case TypeTableEntryIdStruct:
	7601	case ZigTypeIdStruct:
7602	7602	if (type_entry->data.structure.layout == ContainerLayoutExtern) {
7603	7603	fprintf(out_h, "struct %s {\n", buf_ptr(&type_entry->name));
7604	7604	for (uint32_t field_i = 0; field_i < type_entry->data.structure.src_field_count; field_i += 1) {
...	...	@@ -7607,7 +7607,7 @@ static void gen_h_file(CodeGen *g) {
7607	7607	Buf *type_name_buf = buf_alloc();
7608	7608	get_c_type(g, gen_h, struct_field->type_entry, type_name_buf);
7609	7609
7610		if (struct_field->type_entry->id == TypeTableEntryIdArray) {
	7610	if (struct_field->type_entry->id == ZigTypeIdArray) {
7611	7611	fprintf(out_h, " %s %s[%" ZIG_PRI_u64 "];\n", buf_ptr(type_name_buf),
7612	7612	buf_ptr(struct_field->name),
7613	7613	struct_field->type_entry->data.array.len);
...	...	@@ -7621,7 +7621,7 @@ static void gen_h_file(CodeGen *g) {
7621	7621	fprintf(out_h, "struct %s;\n", buf_ptr(&type_entry->name));
7622	7622	}
7623	7623	break;
7624		case TypeTableEntryIdUnion:
	7624	case ZigTypeIdUnion:
7625	7625	if (type_entry->data.unionation.layout == ContainerLayoutExtern) {
7626	7626	fprintf(out_h, "union %s {\n", buf_ptr(&type_entry->name));
7627	7627	for (uint32_t field_i = 0; field_i < type_entry->data.unionation.src_field_count; field_i += 1) {
...	...	@@ -7636,7 +7636,7 @@ static void gen_h_file(CodeGen *g) {
7636	7636	fprintf(out_h, "union %s;\n", buf_ptr(&type_entry->name));
7637	7637	}
7638	7638	break;
7639		case TypeTableEntryIdOpaque:
	7639	case ZigTypeIdOpaque:
7640	7640	fprintf(out_h, "struct %s;\n\n", buf_ptr(&type_entry->name));
7641	7641	break;
7642	7642	}

src/ir.cpp+896-896

...	...	@@ -198,7 +198,7 @@ static bool types_have_same_zig_comptime_repr(ZigType a, ZigType b) {
198	198
199	199	ConstExprValue const_ptr_pointee(CodeGen g, ConstExprValue *const_val) {
200	200	ConstExprValue *result = const_ptr_pointee_unchecked(g, const_val);
201		if (const_val->type->id == TypeTableEntryIdPointer) {
	201	if (const_val->type->id == ZigTypeIdPointer) {
202	202	assert(types_have_same_zig_comptime_repr(const_val->type->data.pointer.child_type, result->type));
203	203	}
204	204	return result;
...	...	@@ -253,7 +253,7 @@ static bool instr_is_comptime(IrInstruction *instruction) {
253	253	}
254	254
255	255	static bool instr_is_unreachable(IrInstruction *instruction) {
256		return instruction->value.type && instruction->value.type->id == TypeTableEntryIdUnreachable;
	256	return instruction->value.type && instruction->value.type->id == ZigTypeIdUnreachable;
257	257	}
258	258
259	259	static void ir_link_new_instruction(IrInstruction new_instruction, IrInstruction old_instruction) {
...	...	@@ -3072,7 +3072,7 @@ static bool ir_gen_defers_for_block(IrBuilder irb, Scope inner_scope, Scope *o
3072	3072	Scope *defer_expr_scope = defer_node->data.defer.expr_scope;
3073	3073	IrInstruction *defer_expr_value = ir_gen_node(irb, defer_expr_node, defer_expr_scope);
3074	3074	if (defer_expr_value != irb->codegen->invalid_instruction) {
3075		if (defer_expr_value->value.type != nullptr && defer_expr_value->value.type->id == TypeTableEntryIdUnreachable) {
	3075	if (defer_expr_value->value.type != nullptr && defer_expr_value->value.type->id == ZigTypeIdUnreachable) {
3076	3076	is_noreturn = true;
3077	3077	} else {
3078	3078	ir_mark_gen(ir_build_check_statement_is_void(irb, defer_expr_scope, defer_expr_node, defer_expr_value));
...	...	@@ -6587,10 +6587,10 @@ static IrInstruction ir_gen_container_decl(IrBuilder irb, Scope *parent_scope,
6587	6587
6588	6588	// errors should be populated with set1's values
6589	6589	static ZigType get_error_set_union(CodeGen g, ErrorTableEntry *errors, ZigType set1, ZigType *set2) {
6590		assert(set1->id == TypeTableEntryIdErrorSet);
6591		assert(set2->id == TypeTableEntryIdErrorSet);
	6590	assert(set1->id == ZigTypeIdErrorSet);
	6591	assert(set2->id == ZigTypeIdErrorSet);
6592	6592
6593		ZigType *err_set_type = new_type_table_entry(TypeTableEntryIdErrorSet);
	6593	ZigType *err_set_type = new_type_table_entry(ZigTypeIdErrorSet);
6594	6594	buf_resize(&err_set_type->name, 0);
6595	6595	buf_appendf(&err_set_type->name, "error{");
6596	6596
...	...	@@ -6642,7 +6642,7 @@ static ZigType get_error_set_union(CodeGen g, ErrorTableEntry **errors, ZigTyp
6642	6642	static ZigType make_err_set_with_one_item(CodeGen g, Scope parent_scope, AstNode node,
6643	6643	ErrorTableEntry *err_entry)
6644	6644	{
6645		ZigType *err_set_type = new_type_table_entry(TypeTableEntryIdErrorSet);
	6645	ZigType *err_set_type = new_type_table_entry(ZigTypeIdErrorSet);
6646	6646	buf_resize(&err_set_type->name, 0);
6647	6647	buf_appendf(&err_set_type->name, "error{%s}", buf_ptr(&err_entry->name));
6648	6648	err_set_type->is_copyable = true;
...	...	@@ -6664,7 +6664,7 @@ static IrInstruction ir_gen_err_set_decl(IrBuilder irb, Scope *parent_scope, A
6664	6664	uint32_t err_count = node->data.err_set_decl.decls.length;
6665	6665
6666	6666	Buf *type_name = get_anon_type_name(irb->codegen, irb->exec, "error set", node);
6667		ZigType *err_set_type = new_type_table_entry(TypeTableEntryIdErrorSet);
	6667	ZigType *err_set_type = new_type_table_entry(ZigTypeIdErrorSet);
6668	6668	buf_init_from_buf(&err_set_type->name, type_name);
6669	6669	err_set_type->is_copyable = true;
6670	6670	err_set_type->data.error_set.err_count = err_count;
...	...	@@ -7628,7 +7628,7 @@ static ErrorMsg ir_add_error(IrAnalyze ira, IrInstruction *source_instruction,
7628	7628	static ConstExprValue ir_const_ptr_pointee(IrAnalyze ira, ConstExprValue const_val, AstNode source_node) {
7629	7629	ConstExprValue *val = const_ptr_pointee_unchecked(ira->codegen, const_val);
7630	7630	assert(val != nullptr);
7631		assert(const_val->type->id == TypeTableEntryIdPointer);
	7631	assert(const_val->type->id == ZigTypeIdPointer);
7632	7632	ZigType *expected_type = const_val->type->data.pointer.child_type;
7633	7633	if (!types_have_same_zig_comptime_repr(val->type, expected_type)) {
7634	7634	ir_add_error_node(ira, source_node,
...	...	@@ -7669,16 +7669,16 @@ static bool ir_emit_global_runtime_side_effect(IrAnalyze ira, IrInstruction so
7669	7669	}
7670	7670
7671	7671	static bool const_val_fits_in_num_lit(ConstExprValue const_val, ZigType num_lit_type) {
7672		return ((num_lit_type->id == TypeTableEntryIdComptimeFloat &&
7673		(const_val->type->id == TypeTableEntryIdFloat \|\| const_val->type->id == TypeTableEntryIdComptimeFloat)) \|\|
7674		(num_lit_type->id == TypeTableEntryIdComptimeInt &&
7675		(const_val->type->id == TypeTableEntryIdInt \|\| const_val->type->id == TypeTableEntryIdComptimeInt)));
	7672	return ((num_lit_type->id == ZigTypeIdComptimeFloat &&
	7673	(const_val->type->id == ZigTypeIdFloat \|\| const_val->type->id == ZigTypeIdComptimeFloat)) \|\|
	7674	(num_lit_type->id == ZigTypeIdComptimeInt &&
	7675	(const_val->type->id == ZigTypeIdInt \|\| const_val->type->id == ZigTypeIdComptimeInt)));
7676	7676	}
7677	7677
7678	7678	static bool float_has_fraction(ConstExprValue *const_val) {
7679		if (const_val->type->id == TypeTableEntryIdComptimeFloat) {
	7679	if (const_val->type->id == ZigTypeIdComptimeFloat) {
7680	7680	return bigfloat_has_fraction(&const_val->data.x_bigfloat);
7681		} else if (const_val->type->id == TypeTableEntryIdFloat) {
	7681	} else if (const_val->type->id == ZigTypeIdFloat) {
7682	7682	switch (const_val->type->data.floating.bit_count) {
7683	7683	case 16:
7684	7684	{
...	...	@@ -7704,9 +7704,9 @@ static bool float_has_fraction(ConstExprValue *const_val) {
7704	7704	}
7705	7705
7706	7706	static void float_append_buf(Buf buf, ConstExprValue const_val) {
7707		if (const_val->type->id == TypeTableEntryIdComptimeFloat) {
	7707	if (const_val->type->id == ZigTypeIdComptimeFloat) {
7708	7708	bigfloat_append_buf(buf, &const_val->data.x_bigfloat);
7709		} else if (const_val->type->id == TypeTableEntryIdFloat) {
	7709	} else if (const_val->type->id == ZigTypeIdFloat) {
7710	7710	switch (const_val->type->data.floating.bit_count) {
7711	7711	case 16:
7712	7712	buf_appendf(buf, "%f", zig_f16_to_double(const_val->data.x_f16));
...	...	@@ -7742,9 +7742,9 @@ static void float_append_buf(Buf buf, ConstExprValue const_val) {
7742	7742	}
7743	7743
7744	7744	static void float_init_bigint(BigInt bigint, ConstExprValue const_val) {
7745		if (const_val->type->id == TypeTableEntryIdComptimeFloat) {
	7745	if (const_val->type->id == ZigTypeIdComptimeFloat) {
7746	7746	bigint_init_bigfloat(bigint, &const_val->data.x_bigfloat);
7747		} else if (const_val->type->id == TypeTableEntryIdFloat) {
	7747	} else if (const_val->type->id == ZigTypeIdFloat) {
7748	7748	switch (const_val->type->data.floating.bit_count) {
7749	7749	case 16:
7750	7750	{
...	...	@@ -7789,9 +7789,9 @@ static void float_init_bigint(BigInt bigint, ConstExprValue const_val) {
7789	7789	}
7790	7790
7791	7791	static void float_init_bigfloat(ConstExprValue dest_val, BigFloat bigfloat) {
7792		if (dest_val->type->id == TypeTableEntryIdComptimeFloat) {
	7792	if (dest_val->type->id == ZigTypeIdComptimeFloat) {
7793	7793	bigfloat_init_bigfloat(&dest_val->data.x_bigfloat, bigfloat);
7794		} else if (dest_val->type->id == TypeTableEntryIdFloat) {
	7794	} else if (dest_val->type->id == ZigTypeIdFloat) {
7795	7795	switch (dest_val->type->data.floating.bit_count) {
7796	7796	case 16:
7797	7797	dest_val->data.x_f16 = bigfloat_to_f16(bigfloat);
...	...	@@ -7814,9 +7814,9 @@ static void float_init_bigfloat(ConstExprValue dest_val, BigFloat bigfloat) {
7814	7814	}
7815	7815
7816	7816	static void float_init_f16(ConstExprValue *dest_val, float16_t x) {
7817		if (dest_val->type->id == TypeTableEntryIdComptimeFloat) {
	7817	if (dest_val->type->id == ZigTypeIdComptimeFloat) {
7818	7818	bigfloat_init_16(&dest_val->data.x_bigfloat, x);
7819		} else if (dest_val->type->id == TypeTableEntryIdFloat) {
	7819	} else if (dest_val->type->id == ZigTypeIdFloat) {
7820	7820	switch (dest_val->type->data.floating.bit_count) {
7821	7821	case 16:
7822	7822	dest_val->data.x_f16 = x;
...	...	@@ -7839,9 +7839,9 @@ static void float_init_f16(ConstExprValue *dest_val, float16_t x) {
7839	7839	}
7840	7840
7841	7841	static void float_init_f32(ConstExprValue *dest_val, float x) {
7842		if (dest_val->type->id == TypeTableEntryIdComptimeFloat) {
	7842	if (dest_val->type->id == ZigTypeIdComptimeFloat) {
7843	7843	bigfloat_init_32(&dest_val->data.x_bigfloat, x);
7844		} else if (dest_val->type->id == TypeTableEntryIdFloat) {
	7844	} else if (dest_val->type->id == ZigTypeIdFloat) {
7845	7845	switch (dest_val->type->data.floating.bit_count) {
7846	7846	case 16:
7847	7847	dest_val->data.x_f16 = zig_double_to_f16(x);
...	...	@@ -7868,9 +7868,9 @@ static void float_init_f32(ConstExprValue *dest_val, float x) {
7868	7868	}
7869	7869
7870	7870	static void float_init_f64(ConstExprValue *dest_val, double x) {
7871		if (dest_val->type->id == TypeTableEntryIdComptimeFloat) {
	7871	if (dest_val->type->id == ZigTypeIdComptimeFloat) {
7872	7872	bigfloat_init_64(&dest_val->data.x_bigfloat, x);
7873		} else if (dest_val->type->id == TypeTableEntryIdFloat) {
	7873	} else if (dest_val->type->id == ZigTypeIdFloat) {
7874	7874	switch (dest_val->type->data.floating.bit_count) {
7875	7875	case 16:
7876	7876	dest_val->data.x_f16 = zig_double_to_f16(x);
...	...	@@ -7897,9 +7897,9 @@ static void float_init_f64(ConstExprValue *dest_val, double x) {
7897	7897	}
7898	7898
7899	7899	static void float_init_f128(ConstExprValue *dest_val, float128_t x) {
7900		if (dest_val->type->id == TypeTableEntryIdComptimeFloat) {
	7900	if (dest_val->type->id == ZigTypeIdComptimeFloat) {
7901	7901	bigfloat_init_128(&dest_val->data.x_bigfloat, x);
7902		} else if (dest_val->type->id == TypeTableEntryIdFloat) {
	7902	} else if (dest_val->type->id == ZigTypeIdFloat) {
7903	7903	switch (dest_val->type->data.floating.bit_count) {
7904	7904	case 16:
7905	7905	dest_val->data.x_f16 = f128M_to_f16(&x);
...	...	@@ -7930,9 +7930,9 @@ static void float_init_f128(ConstExprValue *dest_val, float128_t x) {
7930	7930	}
7931	7931
7932	7932	static void float_init_float(ConstExprValue dest_val, ConstExprValue src_val) {
7933		if (src_val->type->id == TypeTableEntryIdComptimeFloat) {
	7933	if (src_val->type->id == ZigTypeIdComptimeFloat) {
7934	7934	float_init_bigfloat(dest_val, &src_val->data.x_bigfloat);
7935		} else if (src_val->type->id == TypeTableEntryIdFloat) {
	7935	} else if (src_val->type->id == ZigTypeIdFloat) {
7936	7936	switch (src_val->type->data.floating.bit_count) {
7937	7937	case 16:
7938	7938	float_init_f16(dest_val, src_val->data.x_f16);
...	...	@@ -7956,9 +7956,9 @@ static void float_init_float(ConstExprValue dest_val, ConstExprValue src_val)
7956	7956
7957	7957	static Cmp float_cmp(ConstExprValue op1, ConstExprValue op2) {
7958	7958	assert(op1->type == op2->type);
7959		if (op1->type->id == TypeTableEntryIdComptimeFloat) {
	7959	if (op1->type->id == ZigTypeIdComptimeFloat) {
7960	7960	return bigfloat_cmp(&op1->data.x_bigfloat, &op2->data.x_bigfloat);
7961		} else if (op1->type->id == TypeTableEntryIdFloat) {
	7961	} else if (op1->type->id == ZigTypeIdFloat) {
7962	7962	switch (op1->type->data.floating.bit_count) {
7963	7963	case 16:
7964	7964	if (f16_lt(op1->data.x_f16, op2->data.x_f16)) {
...	...	@@ -8001,9 +8001,9 @@ static Cmp float_cmp(ConstExprValue op1, ConstExprValue op2) {
8001	8001	}
8002	8002
8003	8003	static Cmp float_cmp_zero(ConstExprValue *op) {
8004		if (op->type->id == TypeTableEntryIdComptimeFloat) {
	8004	if (op->type->id == ZigTypeIdComptimeFloat) {
8005	8005	return bigfloat_cmp_zero(&op->data.x_bigfloat);
8006		} else if (op->type->id == TypeTableEntryIdFloat) {
	8006	} else if (op->type->id == ZigTypeIdFloat) {
8007	8007	switch (op->type->data.floating.bit_count) {
8008	8008	case 16:
8009	8009	{
...	...	@@ -8053,9 +8053,9 @@ static Cmp float_cmp_zero(ConstExprValue *op) {
8053	8053	static void float_add(ConstExprValue out_val, ConstExprValue op1, ConstExprValue *op2) {
8054	8054	assert(op1->type == op2->type);
8055	8055	out_val->type = op1->type;
8056		if (op1->type->id == TypeTableEntryIdComptimeFloat) {
	8056	if (op1->type->id == ZigTypeIdComptimeFloat) {
8057	8057	bigfloat_add(&out_val->data.x_bigfloat, &op1->data.x_bigfloat, &op2->data.x_bigfloat);
8058		} else if (op1->type->id == TypeTableEntryIdFloat) {
	8058	} else if (op1->type->id == ZigTypeIdFloat) {
8059	8059	switch (op1->type->data.floating.bit_count) {
8060	8060	case 16:
8061	8061	out_val->data.x_f16 = f16_add(op1->data.x_f16, op2->data.x_f16);
...	...	@@ -8080,9 +8080,9 @@ static void float_add(ConstExprValue out_val, ConstExprValue op1, ConstExprVal
8080	8080	static void float_sub(ConstExprValue out_val, ConstExprValue op1, ConstExprValue *op2) {
8081	8081	assert(op1->type == op2->type);
8082	8082	out_val->type = op1->type;
8083		if (op1->type->id == TypeTableEntryIdComptimeFloat) {
	8083	if (op1->type->id == ZigTypeIdComptimeFloat) {
8084	8084	bigfloat_sub(&out_val->data.x_bigfloat, &op1->data.x_bigfloat, &op2->data.x_bigfloat);
8085		} else if (op1->type->id == TypeTableEntryIdFloat) {
	8085	} else if (op1->type->id == ZigTypeIdFloat) {
8086	8086	switch (op1->type->data.floating.bit_count) {
8087	8087	case 16:
8088	8088	out_val->data.x_f16 = f16_sub(op1->data.x_f16, op2->data.x_f16);
...	...	@@ -8107,9 +8107,9 @@ static void float_sub(ConstExprValue out_val, ConstExprValue op1, ConstExprVal
8107	8107	static void float_mul(ConstExprValue out_val, ConstExprValue op1, ConstExprValue *op2) {
8108	8108	assert(op1->type == op2->type);
8109	8109	out_val->type = op1->type;
8110		if (op1->type->id == TypeTableEntryIdComptimeFloat) {
	8110	if (op1->type->id == ZigTypeIdComptimeFloat) {
8111	8111	bigfloat_mul(&out_val->data.x_bigfloat, &op1->data.x_bigfloat, &op2->data.x_bigfloat);
8112		} else if (op1->type->id == TypeTableEntryIdFloat) {
	8112	} else if (op1->type->id == ZigTypeIdFloat) {
8113	8113	switch (op1->type->data.floating.bit_count) {
8114	8114	case 16:
8115	8115	out_val->data.x_f16 = f16_mul(op1->data.x_f16, op2->data.x_f16);
...	...	@@ -8134,9 +8134,9 @@ static void float_mul(ConstExprValue out_val, ConstExprValue op1, ConstExprVal
8134	8134	static void float_div(ConstExprValue out_val, ConstExprValue op1, ConstExprValue *op2) {
8135	8135	assert(op1->type == op2->type);
8136	8136	out_val->type = op1->type;
8137		if (op1->type->id == TypeTableEntryIdComptimeFloat) {
	8137	if (op1->type->id == ZigTypeIdComptimeFloat) {
8138	8138	bigfloat_div(&out_val->data.x_bigfloat, &op1->data.x_bigfloat, &op2->data.x_bigfloat);
8139		} else if (op1->type->id == TypeTableEntryIdFloat) {
	8139	} else if (op1->type->id == ZigTypeIdFloat) {
8140	8140	switch (op1->type->data.floating.bit_count) {
8141	8141	case 16:
8142	8142	out_val->data.x_f16 = f16_div(op1->data.x_f16, op2->data.x_f16);
...	...	@@ -8161,9 +8161,9 @@ static void float_div(ConstExprValue out_val, ConstExprValue op1, ConstExprVal
8161	8161	static void float_div_trunc(ConstExprValue out_val, ConstExprValue op1, ConstExprValue *op2) {
8162	8162	assert(op1->type == op2->type);
8163	8163	out_val->type = op1->type;
8164		if (op1->type->id == TypeTableEntryIdComptimeFloat) {
	8164	if (op1->type->id == ZigTypeIdComptimeFloat) {
8165	8165	bigfloat_div_trunc(&out_val->data.x_bigfloat, &op1->data.x_bigfloat, &op2->data.x_bigfloat);
8166		} else if (op1->type->id == TypeTableEntryIdFloat) {
	8166	} else if (op1->type->id == ZigTypeIdFloat) {
8167	8167	switch (op1->type->data.floating.bit_count) {
8168	8168	case 16:
8169	8169	out_val->data.x_f16 = f16_div(op1->data.x_f16, op2->data.x_f16);
...	...	@@ -8190,9 +8190,9 @@ static void float_div_trunc(ConstExprValue out_val, ConstExprValue op1, ConstE
8190	8190	static void float_div_floor(ConstExprValue out_val, ConstExprValue op1, ConstExprValue *op2) {
8191	8191	assert(op1->type == op2->type);
8192	8192	out_val->type = op1->type;
8193		if (op1->type->id == TypeTableEntryIdComptimeFloat) {
	8193	if (op1->type->id == ZigTypeIdComptimeFloat) {
8194	8194	bigfloat_div_floor(&out_val->data.x_bigfloat, &op1->data.x_bigfloat, &op2->data.x_bigfloat);
8195		} else if (op1->type->id == TypeTableEntryIdFloat) {
	8195	} else if (op1->type->id == ZigTypeIdFloat) {
8196	8196	switch (op1->type->data.floating.bit_count) {
8197	8197	case 16:
8198	8198	out_val->data.x_f16 = f16_div(op1->data.x_f16, op2->data.x_f16);
...	...	@@ -8219,9 +8219,9 @@ static void float_div_floor(ConstExprValue out_val, ConstExprValue op1, ConstE
8219	8219	static void float_rem(ConstExprValue out_val, ConstExprValue op1, ConstExprValue *op2) {
8220	8220	assert(op1->type == op2->type);
8221	8221	out_val->type = op1->type;
8222		if (op1->type->id == TypeTableEntryIdComptimeFloat) {
	8222	if (op1->type->id == ZigTypeIdComptimeFloat) {
8223	8223	bigfloat_rem(&out_val->data.x_bigfloat, &op1->data.x_bigfloat, &op2->data.x_bigfloat);
8224		} else if (op1->type->id == TypeTableEntryIdFloat) {
	8224	} else if (op1->type->id == ZigTypeIdFloat) {
8225	8225	switch (op1->type->data.floating.bit_count) {
8226	8226	case 16:
8227	8227	out_val->data.x_f16 = f16_rem(op1->data.x_f16, op2->data.x_f16);
...	...	@@ -8264,9 +8264,9 @@ static void zig_f128M_mod(const float128_t* a, const float128_t* b, float128_t*
8264	8264	static void float_mod(ConstExprValue out_val, ConstExprValue op1, ConstExprValue *op2) {
8265	8265	assert(op1->type == op2->type);
8266	8266	out_val->type = op1->type;
8267		if (op1->type->id == TypeTableEntryIdComptimeFloat) {
	8267	if (op1->type->id == ZigTypeIdComptimeFloat) {
8268	8268	bigfloat_mod(&out_val->data.x_bigfloat, &op1->data.x_bigfloat, &op2->data.x_bigfloat);
8269		} else if (op1->type->id == TypeTableEntryIdFloat) {
	8269	} else if (op1->type->id == ZigTypeIdFloat) {
8270	8270	switch (op1->type->data.floating.bit_count) {
8271	8271	case 16:
8272	8272	out_val->data.x_f16 = zig_f16_mod(op1->data.x_f16, op2->data.x_f16);
...	...	@@ -8290,9 +8290,9 @@ static void float_mod(ConstExprValue out_val, ConstExprValue op1, ConstExprVal
8290	8290
8291	8291	static void float_negate(ConstExprValue out_val, ConstExprValue op) {
8292	8292	out_val->type = op->type;
8293		if (op->type->id == TypeTableEntryIdComptimeFloat) {
	8293	if (op->type->id == ZigTypeIdComptimeFloat) {
8294	8294	bigfloat_negate(&out_val->data.x_bigfloat, &op->data.x_bigfloat);
8295		} else if (op->type->id == TypeTableEntryIdFloat) {
	8295	} else if (op->type->id == ZigTypeIdFloat) {
8296	8296	switch (op->type->data.floating.bit_count) {
8297	8297	case 16:
8298	8298	{
...	...	@@ -8320,7 +8320,7 @@ static void float_negate(ConstExprValue out_val, ConstExprValue op) {
8320	8320	}
8321	8321
8322	8322	void float_write_ieee597(ConstExprValue op, uint8_t buf, bool is_big_endian) {
8323		if (op->type->id == TypeTableEntryIdFloat) {
	8323	if (op->type->id == ZigTypeIdFloat) {
8324	8324	switch (op->type->data.floating.bit_count) {
8325	8325	case 16:
8326	8326	memcpy(buf, &op->data.x_f16, 2); // TODO wrong when compiler is big endian
...	...	@@ -8343,7 +8343,7 @@ void float_write_ieee597(ConstExprValue op, uint8_t buf, bool is_big_endian) {
8343	8343	}
8344	8344
8345	8345	void float_read_ieee597(ConstExprValue val, uint8_t buf, bool is_big_endian) {
8346		if (val->type->id == TypeTableEntryIdFloat) {
	8346	if (val->type->id == ZigTypeIdFloat) {
8347	8347	switch (val->type->data.floating.bit_count) {
8348	8348	case 16:
8349	8349	memcpy(&val->data.x_f16, buf, 2); // TODO wrong when compiler is big endian
...	...	@@ -8375,13 +8375,13 @@ static bool ir_num_lit_fits_in_other_type(IrAnalyze ira, IrInstruction instruc
8375	8375	ConstExprValue *const_val = &instruction->value;
8376	8376	assert(const_val->special != ConstValSpecialRuntime);
8377	8377
8378		bool const_val_is_int = (const_val->type->id == TypeTableEntryIdInt \|\|
8379		const_val->type->id == TypeTableEntryIdComptimeInt);
8380		bool const_val_is_float = (const_val->type->id == TypeTableEntryIdFloat \|\|
8381		const_val->type->id == TypeTableEntryIdComptimeFloat);
8382		if (other_type->id == TypeTableEntryIdFloat) {
	8378	bool const_val_is_int = (const_val->type->id == ZigTypeIdInt \|\|
	8379	const_val->type->id == ZigTypeIdComptimeInt);
	8380	bool const_val_is_float = (const_val->type->id == ZigTypeIdFloat \|\|
	8381	const_val->type->id == ZigTypeIdComptimeFloat);
	8382	if (other_type->id == ZigTypeIdFloat) {
8383	8383	return true;
8384		} else if (other_type->id == TypeTableEntryIdInt && const_val_is_int) {
	8384	} else if (other_type->id == ZigTypeIdInt && const_val_is_int) {
8385	8385	if (!other_type->data.integral.is_signed && const_val->data.x_bigint.is_negative) {
8386	8386	Buf *val_buf = buf_alloc();
8387	8387	bigint_append_buf(val_buf, &const_val->data.x_bigint, 10);
...	...	@@ -8398,11 +8398,11 @@ static bool ir_num_lit_fits_in_other_type(IrAnalyze ira, IrInstruction instruc
8398	8398	}
8399	8399	} else if (const_val_fits_in_num_lit(const_val, other_type)) {
8400	8400	return true;
8401		} else if (other_type->id == TypeTableEntryIdOptional) {
	8401	} else if (other_type->id == ZigTypeIdOptional) {
8402	8402	ZigType *child_type = other_type->data.maybe.child_type;
8403	8403	if (const_val_fits_in_num_lit(const_val, child_type)) {
8404	8404	return true;
8405		} else if (child_type->id == TypeTableEntryIdInt && const_val_is_int) {
	8405	} else if (child_type->id == ZigTypeIdInt && const_val_is_int) {
8406	8406	if (!child_type->data.integral.is_signed && const_val->data.x_bigint.is_negative) {
8407	8407	Buf *val_buf = buf_alloc();
8408	8408	bigint_append_buf(val_buf, &const_val->data.x_bigint, 10);
...	...	@@ -8418,11 +8418,11 @@ static bool ir_num_lit_fits_in_other_type(IrAnalyze ira, IrInstruction instruc
8418	8418	{
8419	8419	return true;
8420	8420	}
8421		} else if (child_type->id == TypeTableEntryIdFloat && const_val_is_float) {
	8421	} else if (child_type->id == ZigTypeIdFloat && const_val_is_float) {
8422	8422	return true;
8423	8423	}
8424	8424	}
8425		if (explicit_cast && (other_type->id == TypeTableEntryIdInt \|\| other_type->id == TypeTableEntryIdComptimeInt) &&
	8425	if (explicit_cast && (other_type->id == ZigTypeIdInt \|\| other_type->id == ZigTypeIdComptimeInt) &&
8426	8426	const_val_is_float)
8427	8427	{
8428	8428	if (float_has_fraction(const_val)) {
...	...	@@ -8435,7 +8435,7 @@ static bool ir_num_lit_fits_in_other_type(IrAnalyze ira, IrInstruction instruc
8435	8435	buf_ptr(&other_type->name)));
8436	8436	return false;
8437	8437	} else {
8438		if (other_type->id == TypeTableEntryIdComptimeInt) {
	8438	if (other_type->id == ZigTypeIdComptimeInt) {
8439	8439	return true;
8440	8440	} else {
8441	8441	BigInt bigint;
...	...	@@ -8468,7 +8468,7 @@ static bool ir_num_lit_fits_in_other_type(IrAnalyze ira, IrInstruction instruc
8468	8468	}
8469	8469
8470	8470	static bool is_slice(ZigType *type) {
8471		return type->id == TypeTableEntryIdStruct && type->data.structure.is_slice;
	8471	return type->id == ZigTypeIdStruct && type->data.structure.is_slice;
8472	8472	}
8473	8473
8474	8474	static bool slice_is_const(ZigType *type) {
...	...	@@ -8479,8 +8479,8 @@ static bool slice_is_const(ZigType *type) {
8479	8479	static ZigType get_error_set_intersection(IrAnalyze ira, ZigType set1, ZigType set2,
8480	8480	AstNode *source_node)
8481	8481	{
8482		assert(set1->id == TypeTableEntryIdErrorSet);
8483		assert(set2->id == TypeTableEntryIdErrorSet);
	8482	assert(set1->id == ZigTypeIdErrorSet);
	8483	assert(set2->id == ZigTypeIdErrorSet);
8484	8484
8485	8485	if (!resolve_inferred_error_set(ira->codegen, set1, source_node)) {
8486	8486	return ira->codegen->builtin_types.entry_invalid;
...	...	@@ -8502,7 +8502,7 @@ static ZigType get_error_set_intersection(IrAnalyze ira, ZigType *set1, ZigTyp
8502	8502	}
8503	8503	ZigList<ErrorTableEntry *> intersection_list = {};
8504	8504
8505		ZigType *err_set_type = new_type_table_entry(TypeTableEntryIdErrorSet);
	8505	ZigType *err_set_type = new_type_table_entry(ZigTypeIdErrorSet);
8506	8506	buf_resize(&err_set_type->name, 0);
8507	8507	buf_appendf(&err_set_type->name, "error{");
8508	8508
...	...	@@ -8544,9 +8544,9 @@ static ConstCastOnly types_match_const_cast_only(IrAnalyze ira, ZigType wanted
8544	8544	// T and []T may const-cast-only to ?U and ?[]U, respectively
8545	8545	// but not if we want a mutable pointer
8546	8546	// and not if the actual pointer has zero bits
8547		if (!wanted_is_mutable && wanted_type->id == TypeTableEntryIdOptional &&
8548		wanted_type->data.maybe.child_type->id == TypeTableEntryIdPointer &&
8549		actual_type->id == TypeTableEntryIdPointer && type_has_bits(actual_type))
	8547	if (!wanted_is_mutable && wanted_type->id == ZigTypeIdOptional &&
	8548	wanted_type->data.maybe.child_type->id == ZigTypeIdPointer &&
	8549	actual_type->id == ZigTypeIdPointer && type_has_bits(actual_type))
8550	8550	{
8551	8551	ConstCastOnly child = types_match_const_cast_only(ira,
8552	8552	wanted_type->data.maybe.child_type, actual_type, source_node, wanted_is_mutable);
...	...	@@ -8559,10 +8559,10 @@ static ConstCastOnly types_match_const_cast_only(IrAnalyze ira, ZigType wanted
8559	8559	}
8560	8560
8561	8561	// T and []T can always cast to *c_void
8562		if (wanted_type->id == TypeTableEntryIdPointer &&
	8562	if (wanted_type->id == ZigTypeIdPointer &&
8563	8563	wanted_type->data.pointer.ptr_len == PtrLenSingle &&
8564	8564	wanted_type->data.pointer.child_type == g->builtin_types.entry_c_void &&
8565		actual_type->id == TypeTableEntryIdPointer &&
	8565	actual_type->id == ZigTypeIdPointer &&
8566	8566	(!actual_type->data.pointer.is_const \|\| wanted_type->data.pointer.is_const) &&
8567	8567	(!actual_type->data.pointer.is_volatile \|\| wanted_type->data.pointer.is_volatile))
8568	8568	{
...	...	@@ -8571,7 +8571,7 @@ static ConstCastOnly types_match_const_cast_only(IrAnalyze ira, ZigType wanted
8571	8571	}
8572	8572
8573	8573	// pointer const
8574		if (wanted_type->id == TypeTableEntryIdPointer && actual_type->id == TypeTableEntryIdPointer) {
	8574	if (wanted_type->id == ZigTypeIdPointer && actual_type->id == ZigTypeIdPointer) {
8575	8575	ConstCastOnly child = types_match_const_cast_only(ira, wanted_type->data.pointer.child_type,
8576	8576	actual_type->data.pointer.child_type, source_node, !wanted_type->data.pointer.is_const);
8577	8577	if (child.id != ConstCastResultIdOk) {
...	...	@@ -8617,7 +8617,7 @@ static ConstCastOnly types_match_const_cast_only(IrAnalyze ira, ZigType wanted
8617	8617	}
8618	8618
8619	8619	// maybe
8620		if (wanted_type->id == TypeTableEntryIdOptional && actual_type->id == TypeTableEntryIdOptional) {
	8620	if (wanted_type->id == ZigTypeIdOptional && actual_type->id == ZigTypeIdOptional) {
8621	8621	ConstCastOnly child = types_match_const_cast_only(ira, wanted_type->data.maybe.child_type,
8622	8622	actual_type->data.maybe.child_type, source_node, wanted_is_mutable);
8623	8623	if (child.id != ConstCastResultIdOk) {
...	...	@@ -8631,7 +8631,7 @@ static ConstCastOnly types_match_const_cast_only(IrAnalyze ira, ZigType wanted
8631	8631	}
8632	8632
8633	8633	// error union
8634		if (wanted_type->id == TypeTableEntryIdErrorUnion && actual_type->id == TypeTableEntryIdErrorUnion) {
	8634	if (wanted_type->id == ZigTypeIdErrorUnion && actual_type->id == ZigTypeIdErrorUnion) {
8635	8635	ConstCastOnly payload_child = types_match_const_cast_only(ira, wanted_type->data.error_union.payload_type,
8636	8636	actual_type->data.error_union.payload_type, source_node, wanted_is_mutable);
8637	8637	if (payload_child.id != ConstCastResultIdOk) {
...	...	@@ -8656,7 +8656,7 @@ static ConstCastOnly types_match_const_cast_only(IrAnalyze ira, ZigType wanted
8656	8656	}
8657	8657
8658	8658	// error set
8659		if (wanted_type->id == TypeTableEntryIdErrorSet && actual_type->id == TypeTableEntryIdErrorSet) {
	8659	if (wanted_type->id == ZigTypeIdErrorSet && actual_type->id == ZigTypeIdErrorSet) {
8660	8660	ZigType *contained_set = actual_type;
8661	8661	ZigType *container_set = wanted_type;
8662	8662
...	...	@@ -8701,14 +8701,14 @@ static ConstCastOnly types_match_const_cast_only(IrAnalyze ira, ZigType wanted
8701	8701	}
8702	8702
8703	8703	if (wanted_type == ira->codegen->builtin_types.entry_promise &&
8704		actual_type->id == TypeTableEntryIdPromise)
	8704	actual_type->id == ZigTypeIdPromise)
8705	8705	{
8706	8706	return result;
8707	8707	}
8708	8708
8709	8709	// fn
8710		if (wanted_type->id == TypeTableEntryIdFn &&
8711		actual_type->id == TypeTableEntryIdFn)
	8710	if (wanted_type->id == ZigTypeIdFn &&
	8711	actual_type->id == ZigTypeIdFn)
8712	8712	{
8713	8713	if (wanted_type->data.fn.fn_type_id.alignment > actual_type->data.fn.fn_type_id.alignment) {
8714	8714	result.id = ConstCastResultIdFnAlign;
...	...	@@ -8727,7 +8727,7 @@ static ConstCastOnly types_match_const_cast_only(IrAnalyze ira, ZigType wanted
8727	8727	return result;
8728	8728	}
8729	8729	if (!wanted_type->data.fn.is_generic &&
8730		actual_type->data.fn.fn_type_id.return_type->id != TypeTableEntryIdUnreachable)
	8730	actual_type->data.fn.fn_type_id.return_type->id != ZigTypeIdUnreachable)
8731	8731	{
8732	8732	ConstCastOnly child = types_match_const_cast_only(ira, wanted_type->data.fn.fn_type_id.return_type,
8733	8733	actual_type->data.fn.fn_type_id.return_type, source_node, false);
...	...	@@ -8807,7 +8807,7 @@ static ZigType ir_resolve_peer_types(IrAnalyze ira, AstNode *source_node, ZigT
8807	8807	ErrorTableEntry **errors = nullptr;
8808	8808	size_t errors_count = 0;
8809	8809	ZigType *err_set_type = nullptr;
8810		if (prev_inst->value.type->id == TypeTableEntryIdErrorSet) {
	8810	if (prev_inst->value.type->id == ZigTypeIdErrorSet) {
8811	8811	if (type_is_global_error_set(prev_inst->value.type)) {
8812	8812	err_set_type = ira->codegen->builtin_types.entry_global_error_set;
8813	8813	} else {
...	...	@@ -8825,7 +8825,7 @@ static ZigType ir_resolve_peer_types(IrAnalyze ira, AstNode *source_node, ZigT
8825	8825	}
8826	8826	}
8827	8827
8828		bool any_are_null = (prev_inst->value.type->id == TypeTableEntryIdNull);
	8828	bool any_are_null = (prev_inst->value.type->id == ZigTypeIdNull);
8829	8829	bool convert_to_const_slice = false;
8830	8830	for (size_t i = 1; i < instruction_count; i += 1) {
8831	8831	IrInstruction *cur_inst = instructions[i];
...	...	@@ -8836,18 +8836,18 @@ static ZigType ir_resolve_peer_types(IrAnalyze ira, AstNode *source_node, ZigT
8836	8836	return cur_type;
8837	8837	}
8838	8838
8839		if (prev_type->id == TypeTableEntryIdUnreachable) {
	8839	if (prev_type->id == ZigTypeIdUnreachable) {
8840	8840	prev_inst = cur_inst;
8841	8841	continue;
8842	8842	}
8843	8843
8844		if (cur_type->id == TypeTableEntryIdUnreachable) {
	8844	if (cur_type->id == ZigTypeIdUnreachable) {
8845	8845	continue;
8846	8846	}
8847	8847
8848		if (prev_type->id == TypeTableEntryIdErrorSet) {
	8848	if (prev_type->id == ZigTypeIdErrorSet) {
8849	8849	assert(err_set_type != nullptr);
8850		if (cur_type->id == TypeTableEntryIdErrorSet) {
	8850	if (cur_type->id == ZigTypeIdErrorSet) {
8851	8851	if (type_is_global_error_set(err_set_type)) {
8852	8852	continue;
8853	8853	}
...	...	@@ -8911,7 +8911,7 @@ static ZigType ir_resolve_peer_types(IrAnalyze ira, AstNode *source_node, ZigT
8911	8911	err_set_type = get_error_set_union(ira->codegen, errors, cur_type, err_set_type);
8912	8912	assert(errors != nullptr);
8913	8913	continue;
8914		} else if (cur_type->id == TypeTableEntryIdErrorUnion) {
	8914	} else if (cur_type->id == ZigTypeIdErrorUnion) {
8915	8915	if (type_is_global_error_set(err_set_type)) {
8916	8916	prev_inst = cur_inst;
8917	8917	continue;
...	...	@@ -8969,8 +8969,8 @@ static ZigType ir_resolve_peer_types(IrAnalyze ira, AstNode *source_node, ZigT
8969	8969	}
8970	8970	}
8971	8971
8972		if (cur_type->id == TypeTableEntryIdErrorSet) {
8973		if (prev_type->id == TypeTableEntryIdArray) {
	8972	if (cur_type->id == ZigTypeIdErrorSet) {
	8973	if (prev_type->id == ZigTypeIdArray) {
8974	8974	convert_to_const_slice = true;
8975	8975	}
8976	8976	if (type_is_global_error_set(cur_type)) {
...	...	@@ -8987,7 +8987,7 @@ static ZigType ir_resolve_peer_types(IrAnalyze ira, AstNode *source_node, ZigT
8987	8987	update_errors_helper(ira->codegen, &errors, &errors_count);
8988	8988
8989	8989	if (err_set_type == nullptr) {
8990		if (prev_type->id == TypeTableEntryIdErrorUnion) {
	8990	if (prev_type->id == ZigTypeIdErrorUnion) {
8991	8991	err_set_type = prev_type->data.error_union.err_set_type;
8992	8992	} else {
8993	8993	err_set_type = cur_type;
...	...	@@ -9020,7 +9020,7 @@ static ZigType ir_resolve_peer_types(IrAnalyze ira, AstNode *source_node, ZigT
9020	9020	continue;
9021	9021	}
9022	9022
9023		if (prev_type->id == TypeTableEntryIdErrorUnion && cur_type->id == TypeTableEntryIdErrorUnion) {
	9023	if (prev_type->id == ZigTypeIdErrorUnion && cur_type->id == ZigTypeIdErrorUnion) {
9024	9024	ZigType *prev_payload_type = prev_type->data.error_union.payload_type;
9025	9025	ZigType *cur_payload_type = cur_type->data.error_union.payload_type;
9026	9026
...	...	@@ -9104,12 +9104,12 @@ static ZigType ir_resolve_peer_types(IrAnalyze ira, AstNode *source_node, ZigT
9104	9104	}
9105	9105	}
9106	9106
9107		if (prev_type->id == TypeTableEntryIdNull) {
	9107	if (prev_type->id == ZigTypeIdNull) {
9108	9108	prev_inst = cur_inst;
9109	9109	continue;
9110	9110	}
9111	9111
9112		if (cur_type->id == TypeTableEntryIdNull) {
	9112	if (cur_type->id == ZigTypeIdNull) {
9113	9113	any_are_null = true;
9114	9114	continue;
9115	9115	}
...	...	@@ -9123,8 +9123,8 @@ static ZigType ir_resolve_peer_types(IrAnalyze ira, AstNode *source_node, ZigT
9123	9123	continue;
9124	9124	}
9125	9125
9126		if (prev_type->id == TypeTableEntryIdInt &&
9127		cur_type->id == TypeTableEntryIdInt &&
	9126	if (prev_type->id == ZigTypeIdInt &&
	9127	cur_type->id == ZigTypeIdInt &&
9128	9128	prev_type->data.integral.is_signed == cur_type->data.integral.is_signed)
9129	9129	{
9130	9130	if (cur_type->data.integral.bit_count > prev_type->data.integral.bit_count) {
...	...	@@ -9133,21 +9133,21 @@ static ZigType ir_resolve_peer_types(IrAnalyze ira, AstNode *source_node, ZigT
9133	9133	continue;
9134	9134	}
9135	9135
9136		if (prev_type->id == TypeTableEntryIdFloat && cur_type->id == TypeTableEntryIdFloat) {
	9136	if (prev_type->id == ZigTypeIdFloat && cur_type->id == ZigTypeIdFloat) {
9137	9137	if (cur_type->data.floating.bit_count > prev_type->data.floating.bit_count) {
9138	9138	prev_inst = cur_inst;
9139	9139	}
9140	9140	continue;
9141	9141	}
9142	9142
9143		if (prev_type->id == TypeTableEntryIdErrorUnion &&
	9143	if (prev_type->id == ZigTypeIdErrorUnion &&
9144	9144	types_match_const_cast_only(ira, prev_type->data.error_union.payload_type, cur_type,
9145	9145	source_node, false).id == ConstCastResultIdOk)
9146	9146	{
9147	9147	continue;
9148	9148	}
9149	9149
9150		if (cur_type->id == TypeTableEntryIdErrorUnion &&
	9150	if (cur_type->id == ZigTypeIdErrorUnion &&
9151	9151	types_match_const_cast_only(ira, cur_type->data.error_union.payload_type, prev_type,
9152	9152	source_node, false).id == ConstCastResultIdOk)
9153	9153	{
...	...	@@ -9170,14 +9170,14 @@ static ZigType ir_resolve_peer_types(IrAnalyze ira, AstNode *source_node, ZigT
9170	9170	continue;
9171	9171	}
9172	9172
9173		if (prev_type->id == TypeTableEntryIdOptional &&
	9173	if (prev_type->id == ZigTypeIdOptional &&
9174	9174	types_match_const_cast_only(ira, prev_type->data.maybe.child_type, cur_type,
9175	9175	source_node, false).id == ConstCastResultIdOk)
9176	9176	{
9177	9177	continue;
9178	9178	}
9179	9179
9180		if (cur_type->id == TypeTableEntryIdOptional &&
	9180	if (cur_type->id == ZigTypeIdOptional &&
9181	9181	types_match_const_cast_only(ira, cur_type->data.maybe.child_type, prev_type,
9182	9182	source_node, false).id == ConstCastResultIdOk)
9183	9183	{
...	...	@@ -9185,17 +9185,17 @@ static ZigType ir_resolve_peer_types(IrAnalyze ira, AstNode *source_node, ZigT
9185	9185	continue;
9186	9186	}
9187	9187
9188		if (cur_type->id == TypeTableEntryIdUndefined) {
	9188	if (cur_type->id == ZigTypeIdUndefined) {
9189	9189	continue;
9190	9190	}
9191	9191
9192		if (prev_type->id == TypeTableEntryIdUndefined) {
	9192	if (prev_type->id == ZigTypeIdUndefined) {
9193	9193	prev_inst = cur_inst;
9194	9194	continue;
9195	9195	}
9196	9196
9197		if (prev_type->id == TypeTableEntryIdComptimeInt \|\|
9198		prev_type->id == TypeTableEntryIdComptimeFloat)
	9197	if (prev_type->id == ZigTypeIdComptimeInt \|\|
	9198	prev_type->id == ZigTypeIdComptimeFloat)
9199	9199	{
9200	9200	if (ir_num_lit_fits_in_other_type(ira, prev_inst, cur_type, false)) {
9201	9201	prev_inst = cur_inst;
...	...	@@ -9205,8 +9205,8 @@ static ZigType ir_resolve_peer_types(IrAnalyze ira, AstNode *source_node, ZigT
9205	9205	}
9206	9206	}
9207	9207
9208		if (cur_type->id == TypeTableEntryIdComptimeInt \|\|
9209		cur_type->id == TypeTableEntryIdComptimeFloat)
	9208	if (cur_type->id == ZigTypeIdComptimeInt \|\|
	9209	cur_type->id == ZigTypeIdComptimeFloat)
9210	9210	{
9211	9211	if (ir_num_lit_fits_in_other_type(ira, cur_inst, prev_type, false)) {
9212	9212	continue;
...	...	@@ -9215,7 +9215,7 @@ static ZigType ir_resolve_peer_types(IrAnalyze ira, AstNode *source_node, ZigT
9215	9215	}
9216	9216	}
9217	9217
9218		if (cur_type->id == TypeTableEntryIdArray && prev_type->id == TypeTableEntryIdArray &&
	9218	if (cur_type->id == ZigTypeIdArray && prev_type->id == ZigTypeIdArray &&
9219	9219	cur_type->data.array.len != prev_type->data.array.len &&
9220	9220	types_match_const_cast_only(ira, cur_type->data.array.child_type, prev_type->data.array.child_type,
9221	9221	source_node, false).id == ConstCastResultIdOk)
...	...	@@ -9225,7 +9225,7 @@ static ZigType ir_resolve_peer_types(IrAnalyze ira, AstNode *source_node, ZigT
9225	9225	continue;
9226	9226	}
9227	9227
9228		if (cur_type->id == TypeTableEntryIdArray && prev_type->id == TypeTableEntryIdArray &&
	9228	if (cur_type->id == ZigTypeIdArray && prev_type->id == ZigTypeIdArray &&
9229	9229	cur_type->data.array.len != prev_type->data.array.len &&
9230	9230	types_match_const_cast_only(ira, prev_type->data.array.child_type, cur_type->data.array.child_type,
9231	9231	source_node, false).id == ConstCastResultIdOk)
...	...	@@ -9234,7 +9234,7 @@ static ZigType ir_resolve_peer_types(IrAnalyze ira, AstNode *source_node, ZigT
9234	9234	continue;
9235	9235	}
9236	9236
9237		if (cur_type->id == TypeTableEntryIdArray && is_slice(prev_type) &&
	9237	if (cur_type->id == ZigTypeIdArray && is_slice(prev_type) &&
9238	9238	(prev_type->data.structure.fields[slice_ptr_index].type_entry->data.pointer.is_const \|\|
9239	9239	cur_type->data.array.len == 0) &&
9240	9240	types_match_const_cast_only(ira,
...	...	@@ -9245,7 +9245,7 @@ static ZigType ir_resolve_peer_types(IrAnalyze ira, AstNode *source_node, ZigT
9245	9245	continue;
9246	9246	}
9247	9247
9248		if (prev_type->id == TypeTableEntryIdArray && is_slice(cur_type) &&
	9248	if (prev_type->id == ZigTypeIdArray && is_slice(cur_type) &&
9249	9249	(cur_type->data.structure.fields[slice_ptr_index].type_entry->data.pointer.is_const \|\|
9250	9250	prev_type->data.array.len == 0) &&
9251	9251	types_match_const_cast_only(ira,
...	...	@@ -9257,7 +9257,7 @@ static ZigType ir_resolve_peer_types(IrAnalyze ira, AstNode *source_node, ZigT
9257	9257	continue;
9258	9258	}
9259	9259
9260		if (prev_type->id == TypeTableEntryIdEnum && cur_type->id == TypeTableEntryIdUnion &&
	9260	if (prev_type->id == ZigTypeIdEnum && cur_type->id == ZigTypeIdUnion &&
9261	9261	(cur_type->data.unionation.decl_node->data.container_decl.auto_enum \|\| cur_type->data.unionation.decl_node->data.container_decl.init_arg_expr != nullptr))
9262	9262	{
9263	9263	if ((err = type_ensure_zero_bits_known(ira->codegen, cur_type)))
...	...	@@ -9267,7 +9267,7 @@ static ZigType ir_resolve_peer_types(IrAnalyze ira, AstNode *source_node, ZigT
9267	9267	}
9268	9268	}
9269	9269
9270		if (cur_type->id == TypeTableEntryIdEnum && prev_type->id == TypeTableEntryIdUnion &&
	9270	if (cur_type->id == ZigTypeIdEnum && prev_type->id == ZigTypeIdUnion &&
9271	9271	(prev_type->data.unionation.decl_node->data.container_decl.auto_enum \|\| prev_type->data.unionation.decl_node->data.container_decl.init_arg_expr != nullptr))
9272	9272	{
9273	9273	if ((err = type_ensure_zero_bits_known(ira->codegen, prev_type)))
...	...	@@ -9292,7 +9292,7 @@ static ZigType ir_resolve_peer_types(IrAnalyze ira, AstNode *source_node, ZigT
9292	9292	free(errors);
9293	9293
9294	9294	if (convert_to_const_slice) {
9295		assert(prev_inst->value.type->id == TypeTableEntryIdArray);
	9295	assert(prev_inst->value.type->id == ZigTypeIdArray);
9296	9296	ZigType *ptr_type = get_pointer_to_type_extra(
9297	9297	ira->codegen, prev_inst->value.type->data.array.child_type,
9298	9298	true, false, PtrLenUnknown,
...	...	@@ -9305,20 +9305,20 @@ static ZigType ir_resolve_peer_types(IrAnalyze ira, AstNode *source_node, ZigT
9305	9305	return slice_type;
9306	9306	}
9307	9307	} else if (err_set_type != nullptr) {
9308		if (prev_inst->value.type->id == TypeTableEntryIdErrorSet) {
	9308	if (prev_inst->value.type->id == ZigTypeIdErrorSet) {
9309	9309	return err_set_type;
9310		} else if (prev_inst->value.type->id == TypeTableEntryIdErrorUnion) {
	9310	} else if (prev_inst->value.type->id == ZigTypeIdErrorUnion) {
9311	9311	return get_error_union_type(ira->codegen, err_set_type, prev_inst->value.type->data.error_union.payload_type);
9312		} else if (expected_type != nullptr && expected_type->id == TypeTableEntryIdErrorUnion) {
	9312	} else if (expected_type != nullptr && expected_type->id == ZigTypeIdErrorUnion) {
9313	9313	return get_error_union_type(ira->codegen, err_set_type, expected_type->data.error_union.payload_type);
9314	9314	} else {
9315		if (prev_inst->value.type->id == TypeTableEntryIdComptimeInt \|\|
9316		prev_inst->value.type->id == TypeTableEntryIdComptimeFloat)
	9315	if (prev_inst->value.type->id == ZigTypeIdComptimeInt \|\|
	9316	prev_inst->value.type->id == ZigTypeIdComptimeFloat)
9317	9317	{
9318	9318	ir_add_error_node(ira, source_node,
9319	9319	buf_sprintf("unable to make error union out of number literal"));
9320	9320	return ira->codegen->builtin_types.entry_invalid;
9321		} else if (prev_inst->value.type->id == TypeTableEntryIdNull) {
	9321	} else if (prev_inst->value.type->id == ZigTypeIdNull) {
9322	9322	ir_add_error_node(ira, source_node,
9323	9323	buf_sprintf("unable to make error union out of null literal"));
9324	9324	return ira->codegen->builtin_types.entry_invalid;
...	...	@@ -9326,14 +9326,14 @@ static ZigType ir_resolve_peer_types(IrAnalyze ira, AstNode *source_node, ZigT
9326	9326	return get_error_union_type(ira->codegen, err_set_type, prev_inst->value.type);
9327	9327	}
9328	9328	}
9329		} else if (any_are_null && prev_inst->value.type->id != TypeTableEntryIdNull) {
9330		if (prev_inst->value.type->id == TypeTableEntryIdComptimeInt \|\|
9331		prev_inst->value.type->id == TypeTableEntryIdComptimeFloat)
	9329	} else if (any_are_null && prev_inst->value.type->id != ZigTypeIdNull) {
	9330	if (prev_inst->value.type->id == ZigTypeIdComptimeInt \|\|
	9331	prev_inst->value.type->id == ZigTypeIdComptimeFloat)
9332	9332	{
9333	9333	ir_add_error_node(ira, source_node,
9334	9334	buf_sprintf("unable to make maybe out of number literal"));
9335	9335	return ira->codegen->builtin_types.entry_invalid;
9336		} else if (prev_inst->value.type->id == TypeTableEntryIdOptional) {
	9336	} else if (prev_inst->value.type->id == ZigTypeIdOptional) {
9337	9337	return prev_inst->value.type;
9338	9338	} else {
9339	9339	return get_optional_type(ira->codegen, prev_inst->value.type);
...	...	@@ -9357,7 +9357,7 @@ static void copy_const_val(ConstExprValue dest, ConstExprValue src, bool same_
9357	9357	dest = src;
9358	9358	if (!same_global_refs) {
9359	9359	dest->global_refs = global_refs;
9360		if (dest->type->id == TypeTableEntryIdStruct) {
	9360	if (dest->type->id == ZigTypeIdStruct) {
9361	9361	dest->data.x_struct.fields = allocate_nonzero<ConstExprValue>(dest->type->data.structure.src_field_count);
9362	9362	memcpy(dest->data.x_struct.fields, src->data.x_struct.fields, sizeof(ConstExprValue) * dest->type->data.structure.src_field_count);
9363	9363	}
...	...	@@ -9387,8 +9387,8 @@ static bool eval_const_expr_implicit_cast(IrAnalyze ira, IrInstruction source_
9387	9387	break;
9388	9388	}
9389	9389	case CastOpNumLitToConcrete:
9390		if (other_val->type->id == TypeTableEntryIdComptimeFloat) {
9391		assert(new_type->id == TypeTableEntryIdFloat);
	9390	if (other_val->type->id == ZigTypeIdComptimeFloat) {
	9391	assert(new_type->id == ZigTypeIdFloat);
9392	9392	switch (new_type->data.floating.bit_count) {
9393	9393	case 16:
9394	9394	const_val->data.x_f16 = bigfloat_to_f16(&other_val->data.x_bigfloat);
...	...	@@ -9405,7 +9405,7 @@ static bool eval_const_expr_implicit_cast(IrAnalyze ira, IrInstruction source_
9405	9405	default:
9406	9406	zig_unreachable();
9407	9407	}
9408		} else if (other_val->type->id == TypeTableEntryIdComptimeInt) {
	9408	} else if (other_val->type->id == ZigTypeIdComptimeInt) {
9409	9409	bigint_init_bigint(&const_val->data.x_bigint, &other_val->data.x_bigint);
9410	9410	} else {
9411	9411	zig_unreachable();
...	...	@@ -9418,7 +9418,7 @@ static bool eval_const_expr_implicit_cast(IrAnalyze ira, IrInstruction source_
9418	9418	zig_unreachable();
9419	9419	case CastOpIntToFloat:
9420	9420	{
9421		assert(new_type->id == TypeTableEntryIdFloat);
	9421	assert(new_type->id == ZigTypeIdFloat);
9422	9422
9423	9423	BigFloat bigfloat;
9424	9424	bigfloat_init_bigint(&bigfloat, &other_val->data.x_bigint);
...	...	@@ -9443,7 +9443,7 @@ static bool eval_const_expr_implicit_cast(IrAnalyze ira, IrInstruction source_
9443	9443	}
9444	9444	case CastOpFloatToInt:
9445	9445	float_init_bigint(&const_val->data.x_bigint, other_val);
9446		if (new_type->id == TypeTableEntryIdInt) {
	9446	if (new_type->id == ZigTypeIdInt) {
9447	9447	if (!bigint_fits_in_bits(&const_val->data.x_bigint, new_type->data.integral.bit_count,
9448	9448	new_type->data.integral.is_signed))
9449	9449	{
...	...	@@ -9493,7 +9493,7 @@ static IrInstruction ir_resolve_cast(IrAnalyze ira, IrInstruction *source_inst
9493	9493	static IrInstruction ir_resolve_ptr_of_array_to_unknown_len_ptr(IrAnalyze ira, IrInstruction *source_instr,
9494	9494	IrInstruction value, ZigType wanted_type)
9495	9495	{
9496		assert(value->value.type->id == TypeTableEntryIdPointer);
	9496	assert(value->value.type->id == ZigTypeIdPointer);
9497	9497	wanted_type = adjust_ptr_align(ira->codegen, wanted_type, value->value.type->data.pointer.alignment);
9498	9498
9499	9499	if (instr_is_comptime(value)) {
...	...	@@ -9529,7 +9529,7 @@ static IrInstruction ir_resolve_ptr_of_array_to_slice(IrAnalyze ira, IrInstruc
9529	9529	if (pointee == nullptr)
9530	9530	return ira->codegen->invalid_instruction;
9531	9531	if (pointee->special != ConstValSpecialRuntime) {
9532		assert(value->value.type->id == TypeTableEntryIdPointer);
	9532	assert(value->value.type->id == ZigTypeIdPointer);
9533	9533	ZigType *array_type = value->value.type->data.pointer.child_type;
9534	9534	assert(is_slice(wanted_type));
9535	9535	bool is_const = wanted_type->data.structure.fields[slice_ptr_index].type_entry->data.pointer.is_const;
...	...	@@ -9552,9 +9552,9 @@ static IrInstruction ir_resolve_ptr_of_array_to_slice(IrAnalyze ira, IrInstruc
9552	9552	}
9553	9553
9554	9554	static bool is_container(ZigType *type) {
9555		return type->id == TypeTableEntryIdStruct \|\|
9556		type->id == TypeTableEntryIdEnum \|\|
9557		type->id == TypeTableEntryIdUnion;
	9555	return type->id == ZigTypeIdStruct \|\|
	9556	type->id == ZigTypeIdEnum \|\|
	9557	type->id == ZigTypeIdUnion;
9558	9558	}
9559	9559
9560	9560	static IrBasicBlock ir_get_new_bb(IrAnalyze ira, IrBasicBlock old_bb, IrInstruction ref_old_instruction) {
...	...	@@ -9665,7 +9665,7 @@ static ZigType ir_inline_bb(IrAnalyze ira, IrInstruction *source_instruction,
9665	9665	}
9666	9666
9667	9667	static ZigType ir_finish_anal(IrAnalyze ira, ZigType *result_type) {
9668		if (result_type->id == TypeTableEntryIdUnreachable)
	9668	if (result_type->id == ZigTypeIdUnreachable)
9669	9669	ir_finish_bb(ira);
9670	9670	return result_type;
9671	9671	}
...	...	@@ -9803,7 +9803,7 @@ static ZigType ir_resolve_type(IrAnalyze ira, IrInstruction *type_value) {
9803	9803	if (type_is_invalid(type_value->value.type))
9804	9804	return ira->codegen->builtin_types.entry_invalid;
9805	9805
9806		if (type_value->value.type->id != TypeTableEntryIdMetaType) {
	9806	if (type_value->value.type->id != ZigTypeIdMetaType) {
9807	9807	ir_add_error(ira, type_value,
9808	9808	buf_sprintf("expected type 'type', found '%s'", buf_ptr(&type_value->value.type->name)));
9809	9809	return ira->codegen->builtin_types.entry_invalid;
...	...	@@ -9823,7 +9823,7 @@ static ZigFn ir_resolve_fn(IrAnalyze ira, IrInstruction *fn_value) {
9823	9823	if (type_is_invalid(fn_value->value.type))
9824	9824	return nullptr;
9825	9825
9826		if (fn_value->value.type->id != TypeTableEntryIdFn) {
	9826	if (fn_value->value.type->id != ZigTypeIdFn) {
9827	9827	ir_add_error_node(ira, fn_value->source_node,
9828	9828	buf_sprintf("expected function type, found '%s'", buf_ptr(&fn_value->value.type->name)));
9829	9829	return nullptr;
...	...	@@ -9838,7 +9838,7 @@ static ZigFn ir_resolve_fn(IrAnalyze ira, IrInstruction *fn_value) {
9838	9838	}
9839	9839
9840	9840	static IrInstruction ir_analyze_maybe_wrap(IrAnalyze ira, IrInstruction source_instr, IrInstruction value, ZigType *wanted_type) {
9841		assert(wanted_type->id == TypeTableEntryIdOptional);
	9841	assert(wanted_type->id == ZigTypeIdOptional);
9842	9842
9843	9843	if (instr_is_comptime(value)) {
9844	9844	ZigType *payload_type = wanted_type->data.maybe.child_type;
...	...	@@ -9872,7 +9872,7 @@ static IrInstruction ir_analyze_maybe_wrap(IrAnalyze ira, IrInstruction *sourc
9872	9872	static IrInstruction ir_analyze_err_wrap_payload(IrAnalyze ira, IrInstruction *source_instr,
9873	9873	IrInstruction value, ZigType wanted_type)
9874	9874	{
9875		assert(wanted_type->id == TypeTableEntryIdErrorUnion);
	9875	assert(wanted_type->id == ZigTypeIdErrorUnion);
9876	9876
9877	9877	if (instr_is_comptime(value)) {
9878	9878	ZigType *payload_type = wanted_type->data.error_union.payload_type;
...	...	@@ -9903,8 +9903,8 @@ static IrInstruction ir_analyze_err_wrap_payload(IrAnalyze ira, IrInstruction
9903	9903	static IrInstruction ir_analyze_err_set_cast(IrAnalyze ira, IrInstruction source_instr, IrInstruction value,
9904	9904	ZigType *wanted_type)
9905	9905	{
9906		assert(value->value.type->id == TypeTableEntryIdErrorSet);
9907		assert(wanted_type->id == TypeTableEntryIdErrorSet);
	9906	assert(value->value.type->id == ZigTypeIdErrorSet);
	9907	assert(wanted_type->id == ZigTypeIdErrorSet);
9908	9908
9909	9909	if (instr_is_comptime(value)) {
9910	9910	ConstExprValue *val = ir_resolve_const(ira, value, UndefBad);
...	...	@@ -9944,7 +9944,7 @@ static IrInstruction ir_analyze_err_set_cast(IrAnalyze ira, IrInstruction *sou
9944	9944	}
9945	9945
9946	9946	static IrInstruction ir_analyze_err_wrap_code(IrAnalyze ira, IrInstruction source_instr, IrInstruction value, ZigType *wanted_type) {
9947		assert(wanted_type->id == TypeTableEntryIdErrorUnion);
	9947	assert(wanted_type->id == ZigTypeIdErrorUnion);
9948	9948
9949	9949	IrInstruction *casted_value = ir_implicit_cast(ira, value, wanted_type->data.error_union.err_set_type);
9950	9950
...	...	@@ -10006,7 +10006,7 @@ static IrInstruction ir_analyze_cast_ref(IrAnalyze ira, IrInstruction *source_
10006	10006	}
10007	10007
10008	10008	static IrInstruction ir_analyze_null_to_maybe(IrAnalyze ira, IrInstruction source_instr, IrInstruction value, ZigType *wanted_type) {
10009		assert(wanted_type->id == TypeTableEntryIdOptional);
	10009	assert(wanted_type->id == ZigTypeIdOptional);
10010	10010	assert(instr_is_comptime(value));
10011	10011
10012	10012	ConstExprValue *val = ir_resolve_const(ira, value, UndefBad);
...	...	@@ -10062,14 +10062,14 @@ static IrInstruction ir_analyze_array_to_slice(IrAnalyze ira, IrInstruction *s
10062	10062
10063	10063	IrInstruction *array_ptr = nullptr;
10064	10064	IrInstruction *array;
10065		if (array_arg->value.type->id == TypeTableEntryIdPointer) {
	10065	if (array_arg->value.type->id == ZigTypeIdPointer) {
10066	10066	array = ir_get_deref(ira, source_instr, array_arg);
10067	10067	array_ptr = array_arg;
10068	10068	} else {
10069	10069	array = array_arg;
10070	10070	}
10071	10071	ZigType *array_type = array->value.type;
10072		assert(array_type->id == TypeTableEntryIdArray);
	10072	assert(array_type->id == ZigTypeIdArray);
10073	10073
10074	10074	if (instr_is_comptime(array)) {
10075	10075	IrInstruction *result = ir_create_const(&ira->new_irb, source_instr->scope,
...	...	@@ -10103,7 +10103,7 @@ static IrInstruction ir_analyze_enum_to_int(IrAnalyze ira, IrInstruction *sour
10103	10103	IrInstruction target, ZigType wanted_type)
10104	10104	{
10105	10105	Error err;
10106		assert(wanted_type->id == TypeTableEntryIdInt);
	10106	assert(wanted_type->id == ZigTypeIdInt);
10107	10107
10108	10108	ZigType *actual_type = target->value.type;
10109	10109	if ((err = ensure_complete_type(ira->codegen, actual_type)))
...	...	@@ -10117,7 +10117,7 @@ static IrInstruction ir_analyze_enum_to_int(IrAnalyze ira, IrInstruction *sour
10117	10117	return ira->codegen->invalid_instruction;
10118	10118	}
10119	10119
10120		assert(actual_type->id == TypeTableEntryIdEnum);
	10120	assert(actual_type->id == ZigTypeIdEnum);
10121	10121
10122	10122	if (instr_is_comptime(target)) {
10123	10123	ConstExprValue *val = ir_resolve_const(ira, target, UndefBad);
...	...	@@ -10138,8 +10138,8 @@ static IrInstruction ir_analyze_enum_to_int(IrAnalyze ira, IrInstruction *sour
10138	10138	static IrInstruction ir_analyze_union_to_tag(IrAnalyze ira, IrInstruction *source_instr,
10139	10139	IrInstruction target, ZigType wanted_type)
10140	10140	{
10141		assert(target->value.type->id == TypeTableEntryIdUnion);
10142		assert(wanted_type->id == TypeTableEntryIdEnum);
	10141	assert(target->value.type->id == ZigTypeIdUnion);
	10142	assert(wanted_type->id == ZigTypeIdEnum);
10143	10143	assert(wanted_type == target->value.type->data.unionation.tag_type);
10144	10144
10145	10145	if (instr_is_comptime(target)) {
...	...	@@ -10173,8 +10173,8 @@ static IrInstruction ir_analyze_enum_to_union(IrAnalyze ira, IrInstruction *so
10173	10173	IrInstruction target, ZigType wanted_type)
10174	10174	{
10175	10175	Error err;
10176		assert(wanted_type->id == TypeTableEntryIdUnion);
10177		assert(target->value.type->id == TypeTableEntryIdEnum);
	10176	assert(wanted_type->id == ZigTypeIdUnion);
	10177	assert(target->value.type->id == ZigTypeIdEnum);
10178	10178
10179	10179	if (instr_is_comptime(target)) {
10180	10180	ConstExprValue *val = ir_resolve_const(ira, target, UndefBad);
...	...	@@ -10231,13 +10231,13 @@ static IrInstruction ir_analyze_enum_to_union(IrAnalyze ira, IrInstruction *so
10231	10231	static IrInstruction ir_analyze_widen_or_shorten(IrAnalyze ira, IrInstruction *source_instr,
10232	10232	IrInstruction target, ZigType wanted_type)
10233	10233	{
10234		assert(wanted_type->id == TypeTableEntryIdInt \|\| wanted_type->id == TypeTableEntryIdFloat);
	10234	assert(wanted_type->id == ZigTypeIdInt \|\| wanted_type->id == ZigTypeIdFloat);
10235	10235
10236	10236	if (instr_is_comptime(target)) {
10237	10237	ConstExprValue *val = ir_resolve_const(ira, target, UndefBad);
10238	10238	if (!val)
10239	10239	return ira->codegen->invalid_instruction;
10240		if (wanted_type->id == TypeTableEntryIdInt) {
	10240	if (wanted_type->id == ZigTypeIdInt) {
10241	10241	if (bigint_cmp_zero(&val->data.x_bigint) == CmpLT && !wanted_type->data.integral.is_signed) {
10242	10242	ir_add_error(ira, source_instr,
10243	10243	buf_sprintf("attempt to cast negative value to unsigned integer"));
...	...	@@ -10255,7 +10255,7 @@ static IrInstruction ir_analyze_widen_or_shorten(IrAnalyze ira, IrInstruction
10255	10255	IrInstruction *result = ir_create_const(&ira->new_irb, source_instr->scope,
10256	10256	source_instr->source_node, wanted_type);
10257	10257	result->value.type = wanted_type;
10258		if (wanted_type->id == TypeTableEntryIdInt) {
	10258	if (wanted_type->id == ZigTypeIdInt) {
10259	10259	bigint_init_bigint(&result->value.data.x_bigint, &val->data.x_bigint);
10260	10260	} else {
10261	10261	float_init_float(&result->value, val);
...	...	@@ -10273,7 +10273,7 @@ static IrInstruction ir_analyze_int_to_enum(IrAnalyze ira, IrInstruction *sour
10273	10273	IrInstruction target, ZigType wanted_type)
10274	10274	{
10275	10275	Error err;
10276		assert(wanted_type->id == TypeTableEntryIdEnum);
	10276	assert(wanted_type->id == ZigTypeIdEnum);
10277	10277
10278	10278	ZigType *actual_type = target->value.type;
10279	10279
...	...	@@ -10288,7 +10288,7 @@ static IrInstruction ir_analyze_int_to_enum(IrAnalyze ira, IrInstruction *sour
10288	10288	return ira->codegen->invalid_instruction;
10289	10289	}
10290	10290
10291		assert(actual_type->id == TypeTableEntryIdInt);
	10291	assert(actual_type->id == ZigTypeIdInt);
10292	10292
10293	10293	if (instr_is_comptime(target)) {
10294	10294	ConstExprValue *val = ir_resolve_const(ira, target, UndefBad);
...	...	@@ -10328,9 +10328,9 @@ static IrInstruction ir_analyze_number_to_literal(IrAnalyze ira, IrInstruction
10328	10328
10329	10329	IrInstruction *result = ir_create_const(&ira->new_irb, source_instr->scope,
10330	10330	source_instr->source_node, wanted_type);
10331		if (wanted_type->id == TypeTableEntryIdComptimeFloat) {
	10331	if (wanted_type->id == ZigTypeIdComptimeFloat) {
10332	10332	float_init_float(&result->value, val);
10333		} else if (wanted_type->id == TypeTableEntryIdComptimeInt) {
	10333	} else if (wanted_type->id == ZigTypeIdComptimeInt) {
10334	10334	bigint_init_bigint(&result->value.data.x_bigint, &val->data.x_bigint);
10335	10335	} else {
10336	10336	zig_unreachable();
...	...	@@ -10341,9 +10341,9 @@ static IrInstruction ir_analyze_number_to_literal(IrAnalyze ira, IrInstruction
10341	10341	static IrInstruction ir_analyze_int_to_err(IrAnalyze ira, IrInstruction source_instr, IrInstruction target,
10342	10342	ZigType *wanted_type)
10343	10343	{
10344		assert(target->value.type->id == TypeTableEntryIdInt);
	10344	assert(target->value.type->id == ZigTypeIdInt);
10345	10345	assert(!target->value.type->data.integral.is_signed);
10346		assert(wanted_type->id == TypeTableEntryIdErrorSet);
	10346	assert(wanted_type->id == ZigTypeIdErrorSet);
10347	10347
10348	10348	if (instr_is_comptime(target)) {
10349	10349	ConstExprValue *val = ir_resolve_const(ira, target, UndefBad);
...	...	@@ -10406,7 +10406,7 @@ static IrInstruction ir_analyze_int_to_err(IrAnalyze ira, IrInstruction *sourc
10406	10406	static IrInstruction ir_analyze_err_to_int(IrAnalyze ira, IrInstruction source_instr, IrInstruction target,
10407	10407	ZigType *wanted_type)
10408	10408	{
10409		assert(wanted_type->id == TypeTableEntryIdInt);
	10409	assert(wanted_type->id == ZigTypeIdInt);
10410	10410
10411	10411	ZigType *err_type = target->value.type;
10412	10412
...	...	@@ -10419,9 +10419,9 @@ static IrInstruction ir_analyze_err_to_int(IrAnalyze ira, IrInstruction *sourc
10419	10419	source_instr->source_node, wanted_type);
10420	10420
10421	10421	ErrorTableEntry *err;
10422		if (err_type->id == TypeTableEntryIdErrorUnion) {
	10422	if (err_type->id == ZigTypeIdErrorUnion) {
10423	10423	err = val->data.x_err_union.err;
10424		} else if (err_type->id == TypeTableEntryIdErrorSet) {
	10424	} else if (err_type->id == ZigTypeIdErrorSet) {
10425	10425	err = val->data.x_err_set;
10426	10426	} else {
10427	10427	zig_unreachable();
...	...	@@ -10443,9 +10443,9 @@ static IrInstruction ir_analyze_err_to_int(IrAnalyze ira, IrInstruction *sourc
10443	10443	}
10444	10444
10445	10445	ZigType *err_set_type;
10446		if (err_type->id == TypeTableEntryIdErrorUnion) {
	10446	if (err_type->id == ZigTypeIdErrorUnion) {
10447	10447	err_set_type = err_type->data.error_union.err_set_type;
10448		} else if (err_type->id == TypeTableEntryIdErrorSet) {
	10448	} else if (err_type->id == ZigTypeIdErrorSet) {
10449	10449	err_set_type = err_type;
10450	10450	} else {
10451	10451	zig_unreachable();
...	...	@@ -10486,10 +10486,10 @@ static IrInstruction ir_analyze_err_to_int(IrAnalyze ira, IrInstruction *sourc
10486	10486	static IrInstruction ir_analyze_ptr_to_array(IrAnalyze ira, IrInstruction source_instr, IrInstruction target,
10487	10487	ZigType *wanted_type)
10488	10488	{
10489		assert(wanted_type->id == TypeTableEntryIdPointer);
	10489	assert(wanted_type->id == ZigTypeIdPointer);
10490	10490	wanted_type = adjust_ptr_align(ira->codegen, wanted_type, target->value.type->data.pointer.alignment);
10491	10491	ZigType *array_type = wanted_type->data.pointer.child_type;
10492		assert(array_type->id == TypeTableEntryIdArray);
	10492	assert(array_type->id == ZigTypeIdArray);
10493	10493	assert(array_type->data.array.len == 1);
10494	10494
10495	10495	if (instr_is_comptime(target)) {
...	...	@@ -10497,7 +10497,7 @@ static IrInstruction ir_analyze_ptr_to_array(IrAnalyze ira, IrInstruction *sou
10497	10497	if (!val)
10498	10498	return ira->codegen->invalid_instruction;
10499	10499
10500		assert(val->type->id == TypeTableEntryIdPointer);
	10500	assert(val->type->id == ZigTypeIdPointer);
10501	10501	ConstExprValue *pointee = ir_const_ptr_pointee(ira, val, source_instr->source_node);
10502	10502	if (pointee == nullptr)
10503	10503	return ira->codegen->invalid_instruction;
...	...	@@ -10638,8 +10638,8 @@ static IrInstruction ir_analyze_cast(IrAnalyze ira, IrInstruction *source_inst
10638	10638	}
10639	10639
10640	10640	// widening conversion
10641		if (wanted_type->id == TypeTableEntryIdInt &&
10642		actual_type->id == TypeTableEntryIdInt &&
	10641	if (wanted_type->id == ZigTypeIdInt &&
	10642	actual_type->id == ZigTypeIdInt &&
10643	10643	wanted_type->data.integral.is_signed == actual_type->data.integral.is_signed &&
10644	10644	wanted_type->data.integral.bit_count >= actual_type->data.integral.bit_count)
10645	10645	{
...	...	@@ -10647,16 +10647,16 @@ static IrInstruction ir_analyze_cast(IrAnalyze ira, IrInstruction *source_inst
10647	10647	}
10648	10648
10649	10649	// small enough unsigned ints can get casted to large enough signed ints
10650		if (wanted_type->id == TypeTableEntryIdInt && wanted_type->data.integral.is_signed &&
10651		actual_type->id == TypeTableEntryIdInt && !actual_type->data.integral.is_signed &&
	10650	if (wanted_type->id == ZigTypeIdInt && wanted_type->data.integral.is_signed &&
	10651	actual_type->id == ZigTypeIdInt && !actual_type->data.integral.is_signed &&
10652	10652	wanted_type->data.integral.bit_count > actual_type->data.integral.bit_count)
10653	10653	{
10654	10654	return ir_analyze_widen_or_shorten(ira, source_instr, value, wanted_type);
10655	10655	}
10656	10656
10657	10657	// float widening conversion
10658		if (wanted_type->id == TypeTableEntryIdFloat &&
10659		actual_type->id == TypeTableEntryIdFloat &&
	10658	if (wanted_type->id == ZigTypeIdFloat &&
	10659	actual_type->id == ZigTypeIdFloat &&
10660	10660	wanted_type->data.floating.bit_count >= actual_type->data.floating.bit_count)
10661	10661	{
10662	10662	return ir_analyze_widen_or_shorten(ira, source_instr, value, wanted_type);
...	...	@@ -10664,9 +10664,9 @@ static IrInstruction ir_analyze_cast(IrAnalyze ira, IrInstruction *source_inst
10664	10664
10665	10665
10666	10666	// cast from [N]T to []const T
10667		if (is_slice(wanted_type) && actual_type->id == TypeTableEntryIdArray) {
	10667	if (is_slice(wanted_type) && actual_type->id == ZigTypeIdArray) {
10668	10668	ZigType *ptr_type = wanted_type->data.structure.fields[slice_ptr_index].type_entry;
10669		assert(ptr_type->id == TypeTableEntryIdPointer);
	10669	assert(ptr_type->id == ZigTypeIdPointer);
10670	10670	if ((ptr_type->data.pointer.is_const \|\| actual_type->data.array.len == 0) &&
10671	10671	types_match_const_cast_only(ira, ptr_type->data.pointer.child_type, actual_type->data.array.child_type,
10672	10672	source_node, false).id == ConstCastResultIdOk)
...	...	@@ -10677,12 +10677,12 @@ static IrInstruction ir_analyze_cast(IrAnalyze ira, IrInstruction *source_inst
10677	10677
10678	10678	// cast from *const [N]T to []const T
10679	10679	if (is_slice(wanted_type) &&
10680		actual_type->id == TypeTableEntryIdPointer &&
	10680	actual_type->id == ZigTypeIdPointer &&
10681	10681	actual_type->data.pointer.is_const &&
10682		actual_type->data.pointer.child_type->id == TypeTableEntryIdArray)
	10682	actual_type->data.pointer.child_type->id == ZigTypeIdArray)
10683	10683	{
10684	10684	ZigType *ptr_type = wanted_type->data.structure.fields[slice_ptr_index].type_entry;
10685		assert(ptr_type->id == TypeTableEntryIdPointer);
	10685	assert(ptr_type->id == ZigTypeIdPointer);
10686	10686
10687	10687	ZigType *array_type = actual_type->data.pointer.child_type;
10688	10688
...	...	@@ -10695,14 +10695,14 @@ static IrInstruction ir_analyze_cast(IrAnalyze ira, IrInstruction *source_inst
10695	10695	}
10696	10696
10697	10697	// cast from [N]T to *const []const T
10698		if (wanted_type->id == TypeTableEntryIdPointer &&
	10698	if (wanted_type->id == ZigTypeIdPointer &&
10699	10699	wanted_type->data.pointer.is_const &&
10700	10700	is_slice(wanted_type->data.pointer.child_type) &&
10701		actual_type->id == TypeTableEntryIdArray)
	10701	actual_type->id == ZigTypeIdArray)
10702	10702	{
10703	10703	ZigType *ptr_type =
10704	10704	wanted_type->data.pointer.child_type->data.structure.fields[slice_ptr_index].type_entry;
10705		assert(ptr_type->id == TypeTableEntryIdPointer);
	10705	assert(ptr_type->id == ZigTypeIdPointer);
10706	10706	if ((ptr_type->data.pointer.is_const \|\| actual_type->data.array.len == 0) &&
10707	10707	types_match_const_cast_only(ira, ptr_type->data.pointer.child_type, actual_type->data.array.child_type,
10708	10708	source_node, false).id == ConstCastResultIdOk)
...	...	@@ -10720,13 +10720,13 @@ static IrInstruction ir_analyze_cast(IrAnalyze ira, IrInstruction *source_inst
10720	10720	}
10721	10721
10722	10722	// cast from [N]T to ?[]const T
10723		if (wanted_type->id == TypeTableEntryIdOptional &&
	10723	if (wanted_type->id == ZigTypeIdOptional &&
10724	10724	is_slice(wanted_type->data.maybe.child_type) &&
10725		actual_type->id == TypeTableEntryIdArray)
	10725	actual_type->id == ZigTypeIdArray)
10726	10726	{
10727	10727	ZigType *ptr_type =
10728	10728	wanted_type->data.maybe.child_type->data.structure.fields[slice_ptr_index].type_entry;
10729		assert(ptr_type->id == TypeTableEntryIdPointer);
	10729	assert(ptr_type->id == ZigTypeIdPointer);
10730	10730	if ((ptr_type->data.pointer.is_const \|\| actual_type->data.array.len == 0) &&
10731	10731	types_match_const_cast_only(ira, ptr_type->data.pointer.child_type, actual_type->data.array.child_type,
10732	10732	source_node, false).id == ConstCastResultIdOk)
...	...	@@ -10744,11 +10744,11 @@ static IrInstruction ir_analyze_cast(IrAnalyze ira, IrInstruction *source_inst
10744	10744	}
10745	10745
10746	10746	// [N]T to []T
10747		if (wanted_type->id == TypeTableEntryIdPointer &&
	10747	if (wanted_type->id == ZigTypeIdPointer &&
10748	10748	wanted_type->data.pointer.ptr_len == PtrLenUnknown &&
10749		actual_type->id == TypeTableEntryIdPointer &&
	10749	actual_type->id == ZigTypeIdPointer &&
10750	10750	actual_type->data.pointer.ptr_len == PtrLenSingle &&
10751		actual_type->data.pointer.child_type->id == TypeTableEntryIdArray &&
	10751	actual_type->data.pointer.child_type->id == ZigTypeIdArray &&
10752	10752	actual_type->data.pointer.alignment >= wanted_type->data.pointer.alignment &&
10753	10753	types_match_const_cast_only(ira, wanted_type->data.pointer.child_type,
10754	10754	actual_type->data.pointer.child_type->data.array.child_type, source_node,
...	...	@@ -10759,12 +10759,12 @@ static IrInstruction ir_analyze_cast(IrAnalyze ira, IrInstruction *source_inst
10759	10759
10760	10760	// *[N]T to []T
10761	10761	if (is_slice(wanted_type) &&
10762		actual_type->id == TypeTableEntryIdPointer &&
	10762	actual_type->id == ZigTypeIdPointer &&
10763	10763	actual_type->data.pointer.ptr_len == PtrLenSingle &&
10764		actual_type->data.pointer.child_type->id == TypeTableEntryIdArray)
	10764	actual_type->data.pointer.child_type->id == ZigTypeIdArray)
10765	10765	{
10766	10766	ZigType *slice_ptr_type = wanted_type->data.structure.fields[slice_ptr_index].type_entry;
10767		assert(slice_ptr_type->id == TypeTableEntryIdPointer);
	10767	assert(slice_ptr_type->id == ZigTypeIdPointer);
10768	10768	if (types_match_const_cast_only(ira, slice_ptr_type->data.pointer.child_type,
10769	10769	actual_type->data.pointer.child_type->data.array.child_type, source_node,
10770	10770	!slice_ptr_type->data.pointer.is_const).id == ConstCastResultIdOk)
...	...	@@ -10776,23 +10776,23 @@ static IrInstruction ir_analyze_cast(IrAnalyze ira, IrInstruction *source_inst
10776	10776
10777	10777	// cast from T to ?T
10778	10778	// note that the T to ?T case is handled via the "ConstCastOnly" mechanism
10779		if (wanted_type->id == TypeTableEntryIdOptional) {
	10779	if (wanted_type->id == ZigTypeIdOptional) {
10780	10780	ZigType *wanted_child_type = wanted_type->data.maybe.child_type;
10781	10781	if (types_match_const_cast_only(ira, wanted_child_type, actual_type, source_node,
10782	10782	false).id == ConstCastResultIdOk)
10783	10783	{
10784	10784	return ir_analyze_maybe_wrap(ira, source_instr, value, wanted_type);
10785		} else if (actual_type->id == TypeTableEntryIdComptimeInt \|\|
10786		actual_type->id == TypeTableEntryIdComptimeFloat)
	10785	} else if (actual_type->id == ZigTypeIdComptimeInt \|\|
	10786	actual_type->id == ZigTypeIdComptimeFloat)
10787	10787	{
10788	10788	if (ir_num_lit_fits_in_other_type(ira, value, wanted_child_type, true)) {
10789	10789	return ir_analyze_maybe_wrap(ira, source_instr, value, wanted_type);
10790	10790	} else {
10791	10791	return ira->codegen->invalid_instruction;
10792	10792	}
10793		} else if (wanted_child_type->id == TypeTableEntryIdPointer &&
	10793	} else if (wanted_child_type->id == ZigTypeIdPointer &&
10794	10794	wanted_child_type->data.pointer.is_const &&
10795		(actual_type->id == TypeTableEntryIdPointer \|\| is_container(actual_type)))
	10795	(actual_type->id == ZigTypeIdPointer \|\| is_container(actual_type)))
10796	10796	{
10797	10797	IrInstruction *cast1 = ir_analyze_cast(ira, source_instr, wanted_child_type, value);
10798	10798	if (type_is_invalid(cast1->value.type))
...	...	@@ -10804,11 +10804,11 @@ static IrInstruction ir_analyze_cast(IrAnalyze ira, IrInstruction *source_inst
10804	10804
10805	10805	return cast2;
10806	10806	} else if (
10807		wanted_child_type->id == TypeTableEntryIdPointer &&
	10807	wanted_child_type->id == ZigTypeIdPointer &&
10808	10808	wanted_child_type->data.pointer.ptr_len == PtrLenUnknown &&
10809		actual_type->id == TypeTableEntryIdPointer &&
	10809	actual_type->id == ZigTypeIdPointer &&
10810	10810	actual_type->data.pointer.ptr_len == PtrLenSingle &&
10811		actual_type->data.pointer.child_type->id == TypeTableEntryIdArray &&
	10811	actual_type->data.pointer.child_type->id == ZigTypeIdArray &&
10812	10812	actual_type->data.pointer.alignment >= wanted_child_type->data.pointer.alignment &&
10813	10813	types_match_const_cast_only(ira, wanted_child_type->data.pointer.child_type,
10814	10814	actual_type->data.pointer.child_type->data.array.child_type, source_node,
...	...	@@ -10822,20 +10822,20 @@ static IrInstruction ir_analyze_cast(IrAnalyze ira, IrInstruction *source_inst
10822	10822	}
10823	10823
10824	10824	// cast from null literal to maybe type
10825		if (wanted_type->id == TypeTableEntryIdOptional &&
10826		actual_type->id == TypeTableEntryIdNull)
	10825	if (wanted_type->id == ZigTypeIdOptional &&
	10826	actual_type->id == ZigTypeIdNull)
10827	10827	{
10828	10828	return ir_analyze_null_to_maybe(ira, source_instr, value, wanted_type);
10829	10829	}
10830	10830
10831	10831	// cast from child type of error type to error type
10832		if (wanted_type->id == TypeTableEntryIdErrorUnion) {
	10832	if (wanted_type->id == ZigTypeIdErrorUnion) {
10833	10833	if (types_match_const_cast_only(ira, wanted_type->data.error_union.payload_type, actual_type,
10834	10834	source_node, false).id == ConstCastResultIdOk)
10835	10835	{
10836	10836	return ir_analyze_err_wrap_payload(ira, source_instr, value, wanted_type);
10837		} else if (actual_type->id == TypeTableEntryIdComptimeInt \|\|
10838		actual_type->id == TypeTableEntryIdComptimeFloat)
	10837	} else if (actual_type->id == ZigTypeIdComptimeInt \|\|
	10838	actual_type->id == ZigTypeIdComptimeFloat)
10839	10839	{
10840	10840	if (ir_num_lit_fits_in_other_type(ira, value, wanted_type->data.error_union.payload_type, true)) {
10841	10841	return ir_analyze_err_wrap_payload(ira, source_instr, value, wanted_type);
...	...	@@ -10846,13 +10846,13 @@ static IrInstruction ir_analyze_cast(IrAnalyze ira, IrInstruction *source_inst
10846	10846	}
10847	10847
10848	10848	// cast from [N]T to E![]const T
10849		if (wanted_type->id == TypeTableEntryIdErrorUnion &&
	10849	if (wanted_type->id == ZigTypeIdErrorUnion &&
10850	10850	is_slice(wanted_type->data.error_union.payload_type) &&
10851		actual_type->id == TypeTableEntryIdArray)
	10851	actual_type->id == ZigTypeIdArray)
10852	10852	{
10853	10853	ZigType *ptr_type =
10854	10854	wanted_type->data.error_union.payload_type->data.structure.fields[slice_ptr_index].type_entry;
10855		assert(ptr_type->id == TypeTableEntryIdPointer);
	10855	assert(ptr_type->id == ZigTypeIdPointer);
10856	10856	if ((ptr_type->data.pointer.is_const \|\| actual_type->data.array.len == 0) &&
10857	10857	types_match_const_cast_only(ira, ptr_type->data.pointer.child_type, actual_type->data.array.child_type,
10858	10858	source_node, false).id == ConstCastResultIdOk)
...	...	@@ -10870,22 +10870,22 @@ static IrInstruction ir_analyze_cast(IrAnalyze ira, IrInstruction *source_inst
10870	10870	}
10871	10871
10872	10872	// cast from error set to error union type
10873		if (wanted_type->id == TypeTableEntryIdErrorUnion &&
10874		actual_type->id == TypeTableEntryIdErrorSet)
	10873	if (wanted_type->id == ZigTypeIdErrorUnion &&
	10874	actual_type->id == ZigTypeIdErrorSet)
10875	10875	{
10876	10876	return ir_analyze_err_wrap_code(ira, source_instr, value, wanted_type);
10877	10877	}
10878	10878
10879	10879	// cast from T to E!?T
10880		if (wanted_type->id == TypeTableEntryIdErrorUnion &&
10881		wanted_type->data.error_union.payload_type->id == TypeTableEntryIdOptional &&
10882		actual_type->id != TypeTableEntryIdOptional)
	10880	if (wanted_type->id == ZigTypeIdErrorUnion &&
	10881	wanted_type->data.error_union.payload_type->id == ZigTypeIdOptional &&
	10882	actual_type->id != ZigTypeIdOptional)
10883	10883	{
10884	10884	ZigType *wanted_child_type = wanted_type->data.error_union.payload_type->data.maybe.child_type;
10885	10885	if (types_match_const_cast_only(ira, wanted_child_type, actual_type, source_node, false).id == ConstCastResultIdOk \|\|
10886		actual_type->id == TypeTableEntryIdNull \|\|
10887		actual_type->id == TypeTableEntryIdComptimeInt \|\|
10888		actual_type->id == TypeTableEntryIdComptimeFloat)
	10886	actual_type->id == ZigTypeIdNull \|\|
	10887	actual_type->id == ZigTypeIdComptimeInt \|\|
	10888	actual_type->id == ZigTypeIdComptimeFloat)
10889	10889	{
10890	10890	IrInstruction *cast1 = ir_analyze_cast(ira, source_instr, wanted_type->data.error_union.payload_type, value);
10891	10891	if (type_is_invalid(cast1->value.type))
...	...	@@ -10901,12 +10901,12 @@ static IrInstruction ir_analyze_cast(IrAnalyze ira, IrInstruction *source_inst
10901	10901
10902	10902	// cast from number literal to another type
10903	10903	// cast from number literal to *const integer
10904		if (actual_type->id == TypeTableEntryIdComptimeFloat \|\|
10905		actual_type->id == TypeTableEntryIdComptimeInt)
	10904	if (actual_type->id == ZigTypeIdComptimeFloat \|\|
	10905	actual_type->id == ZigTypeIdComptimeInt)
10906	10906	{
10907	10907	if ((err = ensure_complete_type(ira->codegen, wanted_type)))
10908	10908	return ira->codegen->invalid_instruction;
10909		if (wanted_type->id == TypeTableEntryIdEnum) {
	10909	if (wanted_type->id == ZigTypeIdEnum) {
10910	10910	IrInstruction *cast1 = ir_analyze_cast(ira, source_instr, wanted_type->data.enumeration.tag_int_type, value);
10911	10911	if (type_is_invalid(cast1->value.type))
10912	10912	return ira->codegen->invalid_instruction;
...	...	@@ -10916,7 +10916,7 @@ static IrInstruction ir_analyze_cast(IrAnalyze ira, IrInstruction *source_inst
10916	10916	return ira->codegen->invalid_instruction;
10917	10917
10918	10918	return cast2;
10919		} else if (wanted_type->id == TypeTableEntryIdPointer &&
	10919	} else if (wanted_type->id == ZigTypeIdPointer &&
10920	10920	wanted_type->data.pointer.is_const)
10921	10921	{
10922	10922	IrInstruction *cast1 = ir_analyze_cast(ira, source_instr, wanted_type->data.pointer.child_type, value);
...	...	@@ -10930,15 +10930,15 @@ static IrInstruction ir_analyze_cast(IrAnalyze ira, IrInstruction *source_inst
10930	10930	return cast2;
10931	10931	} else if (ir_num_lit_fits_in_other_type(ira, value, wanted_type, true)) {
10932	10932	CastOp op;
10933		if ((actual_type->id == TypeTableEntryIdComptimeFloat &&
10934		wanted_type->id == TypeTableEntryIdFloat) \|\|
10935		(actual_type->id == TypeTableEntryIdComptimeInt &&
10936		wanted_type->id == TypeTableEntryIdInt))
	10933	if ((actual_type->id == ZigTypeIdComptimeFloat &&
	10934	wanted_type->id == ZigTypeIdFloat) \|\|
	10935	(actual_type->id == ZigTypeIdComptimeInt &&
	10936	wanted_type->id == ZigTypeIdInt))
10937	10937	{
10938	10938	op = CastOpNumLitToConcrete;
10939		} else if (wanted_type->id == TypeTableEntryIdInt) {
	10939	} else if (wanted_type->id == ZigTypeIdInt) {
10940	10940	op = CastOpFloatToInt;
10941		} else if (wanted_type->id == TypeTableEntryIdFloat) {
	10941	} else if (wanted_type->id == ZigTypeIdFloat) {
10942	10942	op = CastOpIntToFloat;
10943	10943	} else {
10944	10944	zig_unreachable();
...	...	@@ -10952,14 +10952,14 @@ static IrInstruction ir_analyze_cast(IrAnalyze ira, IrInstruction *source_inst
10952	10952	// cast from typed number to integer or float literal.
10953	10953	// works when the number is known at compile time
10954	10954	if (instr_is_comptime(value) &&
10955		((actual_type->id == TypeTableEntryIdInt && wanted_type->id == TypeTableEntryIdComptimeInt) \|\|
10956		(actual_type->id == TypeTableEntryIdFloat && wanted_type->id == TypeTableEntryIdComptimeFloat)))
	10955	((actual_type->id == ZigTypeIdInt && wanted_type->id == ZigTypeIdComptimeInt) \|\|
	10956	(actual_type->id == ZigTypeIdFloat && wanted_type->id == ZigTypeIdComptimeFloat)))
10957	10957	{
10958	10958	return ir_analyze_number_to_literal(ira, source_instr, value, wanted_type);
10959	10959	}
10960	10960
10961	10961	// cast from union to the enum type of the union
10962		if (actual_type->id == TypeTableEntryIdUnion && wanted_type->id == TypeTableEntryIdEnum) {
	10962	if (actual_type->id == ZigTypeIdUnion && wanted_type->id == ZigTypeIdEnum) {
10963	10963	if ((err = type_ensure_zero_bits_known(ira->codegen, actual_type)))
10964	10964	return ira->codegen->invalid_instruction;
10965	10965
...	...	@@ -10969,7 +10969,7 @@ static IrInstruction ir_analyze_cast(IrAnalyze ira, IrInstruction *source_inst
10969	10969	}
10970	10970
10971	10971	// enum to union which has the enum as the tag type
10972		if (wanted_type->id == TypeTableEntryIdUnion && actual_type->id == TypeTableEntryIdEnum &&
	10972	if (wanted_type->id == ZigTypeIdUnion && actual_type->id == ZigTypeIdEnum &&
10973	10973	(wanted_type->data.unionation.decl_node->data.container_decl.auto_enum \|\|
10974	10974	wanted_type->data.unionation.decl_node->data.container_decl.init_arg_expr != nullptr))
10975	10975	{
...	...	@@ -10982,7 +10982,7 @@ static IrInstruction ir_analyze_cast(IrAnalyze ira, IrInstruction *source_inst
10982	10982	}
10983	10983
10984	10984	// enum to &const union which has the enum as the tag type
10985		if (actual_type->id == TypeTableEntryIdEnum && wanted_type->id == TypeTableEntryIdPointer) {
	10985	if (actual_type->id == ZigTypeIdEnum && wanted_type->id == ZigTypeIdPointer) {
10986	10986	ZigType *union_type = wanted_type->data.pointer.child_type;
10987	10987	if (union_type->data.unionation.decl_node->data.container_decl.auto_enum \|\|
10988	10988	union_type->data.unionation.decl_node->data.container_decl.init_arg_expr != nullptr)
...	...	@@ -11005,11 +11005,11 @@ static IrInstruction ir_analyze_cast(IrAnalyze ira, IrInstruction *source_inst
11005	11005	}
11006	11006
11007	11007	// cast from T to [1]T
11008		if (wanted_type->id == TypeTableEntryIdPointer && wanted_type->data.pointer.ptr_len == PtrLenSingle &&
11009		actual_type->id == TypeTableEntryIdPointer && actual_type->data.pointer.ptr_len == PtrLenSingle)
	11008	if (wanted_type->id == ZigTypeIdPointer && wanted_type->data.pointer.ptr_len == PtrLenSingle &&
	11009	actual_type->id == ZigTypeIdPointer && actual_type->data.pointer.ptr_len == PtrLenSingle)
11010	11010	{
11011	11011	ZigType *array_type = wanted_type->data.pointer.child_type;
11012		if (array_type->id == TypeTableEntryIdArray && array_type->data.array.len == 1 &&
	11012	if (array_type->id == ZigTypeIdArray && array_type->data.array.len == 1 &&
11013	11013	types_match_const_cast_only(ira, array_type->data.array.child_type,
11014	11014	actual_type->data.pointer.child_type, source_node,
11015	11015	!wanted_type->data.pointer.is_const).id == ConstCastResultIdOk)
...	...	@@ -11029,7 +11029,7 @@ static IrInstruction ir_analyze_cast(IrAnalyze ira, IrInstruction *source_inst
11029	11029	}
11030	11030
11031	11031	// cast from T to *T where T is zero bits
11032		if (wanted_type->id == TypeTableEntryIdPointer && wanted_type->data.pointer.ptr_len == PtrLenSingle &&
	11032	if (wanted_type->id == ZigTypeIdPointer && wanted_type->data.pointer.ptr_len == PtrLenSingle &&
11033	11033	types_match_const_cast_only(ira, wanted_type->data.pointer.child_type,
11034	11034	actual_type, source_node, !wanted_type->data.pointer.is_const).id == ConstCastResultIdOk)
11035	11035	{
...	...	@@ -11043,7 +11043,7 @@ static IrInstruction ir_analyze_cast(IrAnalyze ira, IrInstruction *source_inst
11043	11043
11044	11044
11045	11045	// cast from undefined to anything
11046		if (actual_type->id == TypeTableEntryIdUndefined) {
	11046	if (actual_type->id == ZigTypeIdUndefined) {
11047	11047	return ir_analyze_undefined_to_anything(ira, source_instr, value, wanted_type);
11048	11048	}
11049	11049
...	...	@@ -11073,7 +11073,7 @@ static IrInstruction ir_implicit_cast(IrAnalyze ira, IrInstruction *value, Zig
11073	11073	return value; // anything will do
11074	11074	if (expected_type == value->value.type)
11075	11075	return value; // match
11076		if (value->value.type->id == TypeTableEntryIdUnreachable)
	11076	if (value->value.type->id == ZigTypeIdUnreachable)
11077	11077	return value;
11078	11078
11079	11079	return ir_analyze_cast(ira, value, expected_type, value);
...	...	@@ -11083,7 +11083,7 @@ static IrInstruction ir_get_deref(IrAnalyze ira, IrInstruction *source_instruc
11083	11083	ZigType *type_entry = ptr->value.type;
11084	11084	if (type_is_invalid(type_entry)) {
11085	11085	return ira->codegen->invalid_instruction;
11086		} else if (type_entry->id == TypeTableEntryIdPointer) {
	11086	} else if (type_entry->id == ZigTypeIdPointer) {
11087	11087	ZigType *child_type = type_entry->data.pointer.child_type;
11088	11088	if (instr_is_comptime(ptr)) {
11089	11089	if (ptr->value.data.x_ptr.mut == ConstPtrMutComptimeConst \|\|
...	...	@@ -11198,7 +11198,7 @@ static bool ir_resolve_atomic_order(IrAnalyze ira, IrInstruction value, Atomic
11198	11198	return false;
11199	11199
11200	11200	ConstExprValue *atomic_order_val = get_builtin_value(ira->codegen, "AtomicOrder");
11201		assert(atomic_order_val->type->id == TypeTableEntryIdMetaType);
	11201	assert(atomic_order_val->type->id == ZigTypeIdMetaType);
11202	11202	ZigType *atomic_order_type = atomic_order_val->data.x_type;
11203	11203
11204	11204	IrInstruction *casted_value = ir_implicit_cast(ira, value, atomic_order_type);
...	...	@@ -11218,7 +11218,7 @@ static bool ir_resolve_atomic_rmw_op(IrAnalyze ira, IrInstruction value, Atomi
11218	11218	return false;
11219	11219
11220	11220	ConstExprValue *atomic_rmw_op_val = get_builtin_value(ira->codegen, "AtomicRmwOp");
11221		assert(atomic_rmw_op_val->type->id == TypeTableEntryIdMetaType);
	11221	assert(atomic_rmw_op_val->type->id == ZigTypeIdMetaType);
11222	11222	ZigType *atomic_rmw_op_type = atomic_rmw_op_val->data.x_type;
11223	11223
11224	11224	IrInstruction *casted_value = ir_implicit_cast(ira, value, atomic_rmw_op_type);
...	...	@@ -11238,7 +11238,7 @@ static bool ir_resolve_global_linkage(IrAnalyze ira, IrInstruction value, Glob
11238	11238	return false;
11239	11239
11240	11240	ConstExprValue *global_linkage_val = get_builtin_value(ira->codegen, "GlobalLinkage");
11241		assert(global_linkage_val->type->id == TypeTableEntryIdMetaType);
	11241	assert(global_linkage_val->type->id == ZigTypeIdMetaType);
11242	11242	ZigType *global_linkage_type = global_linkage_val->data.x_type;
11243	11243
11244	11244	IrInstruction *casted_value = ir_implicit_cast(ira, value, global_linkage_type);
...	...	@@ -11258,7 +11258,7 @@ static bool ir_resolve_float_mode(IrAnalyze ira, IrInstruction value, FloatMod
11258	11258	return false;
11259	11259
11260	11260	ConstExprValue *float_mode_val = get_builtin_value(ira->codegen, "FloatMode");
11261		assert(float_mode_val->type->id == TypeTableEntryIdMetaType);
	11261	assert(float_mode_val->type->id == ZigTypeIdMetaType);
11262	11262	ZigType *float_mode_type = float_mode_val->data.x_type;
11263	11263
11264	11264	IrInstruction *casted_value = ir_implicit_cast(ira, value, float_mode_type);
...	...	@@ -11340,7 +11340,7 @@ static ZigType ir_analyze_instruction_return(IrAnalyze ira,
11340	11340	return ir_unreach_error(ira);
11341	11341
11342	11342	if (casted_value->value.special == ConstValSpecialRuntime &&
11343		casted_value->value.type->id == TypeTableEntryIdPointer &&
	11343	casted_value->value.type->id == ZigTypeIdPointer &&
11344	11344	casted_value->value.data.rh_ptr == RuntimeHintPtrStack)
11345	11345	{
11346	11346	ir_add_error(ira, casted_value, buf_sprintf("function returns address of local variable"));
...	...	@@ -11388,8 +11388,8 @@ static ZigType ir_analyze_bin_op_bool(IrAnalyze ira, IrInstructionBinOp *bin_o
11388	11388	if (op2_val == nullptr)
11389	11389	return ira->codegen->builtin_types.entry_invalid;
11390	11390
11391		assert(casted_op1->value.type->id == TypeTableEntryIdBool);
11392		assert(casted_op2->value.type->id == TypeTableEntryIdBool);
	11391	assert(casted_op1->value.type->id == ZigTypeIdBool);
	11392	assert(casted_op2->value.type->id == ZigTypeIdBool);
11393	11393	if (bin_op_instruction->op_id == IrBinOpBoolOr) {
11394	11394	out_val->data.x_bool = op1_val->data.x_bool \|\| op2_val->data.x_bool;
11395	11395	} else if (bin_op_instruction->op_id == IrBinOpBoolAnd) {
...	...	@@ -11442,19 +11442,19 @@ static ZigType ir_analyze_bin_op_cmp(IrAnalyze ira, IrInstructionBinOp *bin_op
11442	11442	IrBinOp op_id = bin_op_instruction->op_id;
11443	11443	bool is_equality_cmp = (op_id == IrBinOpCmpEq \|\| op_id == IrBinOpCmpNotEq);
11444	11444	if (is_equality_cmp &&
11445		((op1->value.type->id == TypeTableEntryIdNull && op2->value.type->id == TypeTableEntryIdOptional) \|\|
11446		(op2->value.type->id == TypeTableEntryIdNull && op1->value.type->id == TypeTableEntryIdOptional) \|\|
11447		(op1->value.type->id == TypeTableEntryIdNull && op2->value.type->id == TypeTableEntryIdNull)))
	11445	((op1->value.type->id == ZigTypeIdNull && op2->value.type->id == ZigTypeIdOptional) \|\|
	11446	(op2->value.type->id == ZigTypeIdNull && op1->value.type->id == ZigTypeIdOptional) \|\|
	11447	(op1->value.type->id == ZigTypeIdNull && op2->value.type->id == ZigTypeIdNull)))
11448	11448	{
11449		if (op1->value.type->id == TypeTableEntryIdNull && op2->value.type->id == TypeTableEntryIdNull) {
	11449	if (op1->value.type->id == ZigTypeIdNull && op2->value.type->id == ZigTypeIdNull) {
11450	11450	ConstExprValue *out_val = ir_build_const_from(ira, &bin_op_instruction->base);
11451	11451	out_val->data.x_bool = (op_id == IrBinOpCmpEq);
11452	11452	return ira->codegen->builtin_types.entry_bool;
11453	11453	}
11454	11454	IrInstruction *maybe_op;
11455		if (op1->value.type->id == TypeTableEntryIdNull) {
	11455	if (op1->value.type->id == ZigTypeIdNull) {
11456	11456	maybe_op = op2;
11457		} else if (op2->value.type->id == TypeTableEntryIdNull) {
	11457	} else if (op2->value.type->id == ZigTypeIdNull) {
11458	11458	maybe_op = op1;
11459	11459	} else {
11460	11460	zig_unreachable();
...	...	@@ -11481,7 +11481,7 @@ static ZigType ir_analyze_bin_op_cmp(IrAnalyze ira, IrInstructionBinOp *bin_op
11481	11481	return ira->codegen->builtin_types.entry_bool;
11482	11482	}
11483	11483
11484		if (op1->value.type->id == TypeTableEntryIdErrorSet && op2->value.type->id == TypeTableEntryIdErrorSet) {
	11484	if (op1->value.type->id == ZigTypeIdErrorSet && op2->value.type->id == ZigTypeIdErrorSet) {
11485	11485	if (!is_equality_cmp) {
11486	11486	ir_add_error_node(ira, source_node, buf_sprintf("operator not allowed for errors"));
11487	11487	return ira->codegen->builtin_types.entry_invalid;
...	...	@@ -11575,42 +11575,42 @@ static ZigType ir_analyze_bin_op_cmp(IrAnalyze ira, IrInstructionBinOp *bin_op
11575	11575
11576	11576	bool operator_allowed;
11577	11577	switch (resolved_type->id) {
11578		case TypeTableEntryIdInvalid:
	11578	case ZigTypeIdInvalid:
11579	11579	zig_unreachable(); // handled above
11580	11580
11581		case TypeTableEntryIdComptimeFloat:
11582		case TypeTableEntryIdComptimeInt:
11583		case TypeTableEntryIdInt:
11584		case TypeTableEntryIdFloat:
	11581	case ZigTypeIdComptimeFloat:
	11582	case ZigTypeIdComptimeInt:
	11583	case ZigTypeIdInt:
	11584	case ZigTypeIdFloat:
11585	11585	operator_allowed = true;
11586	11586	break;
11587	11587
11588		case TypeTableEntryIdBool:
11589		case TypeTableEntryIdMetaType:
11590		case TypeTableEntryIdVoid:
11591		case TypeTableEntryIdPointer:
11592		case TypeTableEntryIdErrorSet:
11593		case TypeTableEntryIdFn:
11594		case TypeTableEntryIdOpaque:
11595		case TypeTableEntryIdNamespace:
11596		case TypeTableEntryIdBlock:
11597		case TypeTableEntryIdBoundFn:
11598		case TypeTableEntryIdArgTuple:
11599		case TypeTableEntryIdPromise:
11600		case TypeTableEntryIdEnum:
	11588	case ZigTypeIdBool:
	11589	case ZigTypeIdMetaType:
	11590	case ZigTypeIdVoid:
	11591	case ZigTypeIdPointer:
	11592	case ZigTypeIdErrorSet:
	11593	case ZigTypeIdFn:
	11594	case ZigTypeIdOpaque:
	11595	case ZigTypeIdNamespace:
	11596	case ZigTypeIdBlock:
	11597	case ZigTypeIdBoundFn:
	11598	case ZigTypeIdArgTuple:
	11599	case ZigTypeIdPromise:
	11600	case ZigTypeIdEnum:
11601	11601	operator_allowed = is_equality_cmp;
11602	11602	break;
11603	11603
11604		case TypeTableEntryIdUnreachable:
11605		case TypeTableEntryIdArray:
11606		case TypeTableEntryIdStruct:
11607		case TypeTableEntryIdUndefined:
11608		case TypeTableEntryIdNull:
11609		case TypeTableEntryIdErrorUnion:
11610		case TypeTableEntryIdUnion:
	11604	case ZigTypeIdUnreachable:
	11605	case ZigTypeIdArray:
	11606	case ZigTypeIdStruct:
	11607	case ZigTypeIdUndefined:
	11608	case ZigTypeIdNull:
	11609	case ZigTypeIdErrorUnion:
	11610	case ZigTypeIdUnion:
11611	11611	operator_allowed = false;
11612	11612	break;
11613		case TypeTableEntryIdOptional:
	11613	case ZigTypeIdOptional:
11614	11614	operator_allowed = is_equality_cmp && get_codegen_ptr_type(resolved_type) != nullptr;
11615	11615	break;
11616	11616	}
...	...	@@ -11638,10 +11638,10 @@ static ZigType ir_analyze_bin_op_cmp(IrAnalyze ira, IrInstructionBinOp *bin_op
11638	11638	return ira->codegen->builtin_types.entry_invalid;
11639	11639
11640	11640	bool answer;
11641		if (resolved_type->id == TypeTableEntryIdComptimeFloat \|\| resolved_type->id == TypeTableEntryIdFloat) {
	11641	if (resolved_type->id == ZigTypeIdComptimeFloat \|\| resolved_type->id == ZigTypeIdFloat) {
11642	11642	Cmp cmp_result = float_cmp(op1_val, op2_val);
11643	11643	answer = resolve_cmp_op_id(op_id, cmp_result);
11644		} else if (resolved_type->id == TypeTableEntryIdComptimeInt \|\| resolved_type->id == TypeTableEntryIdInt) {
	11644	} else if (resolved_type->id == ZigTypeIdComptimeInt \|\| resolved_type->id == ZigTypeIdInt) {
11645	11645	Cmp cmp_result = bigint_cmp(&op1_val->data.x_bigint, &op2_val->data.x_bigint);
11646	11646	answer = resolve_cmp_op_id(op_id, cmp_result);
11647	11647	} else {
...	...	@@ -11661,7 +11661,7 @@ static ZigType ir_analyze_bin_op_cmp(IrAnalyze ira, IrInstructionBinOp *bin_op
11661	11661	}
11662	11662
11663	11663	// some comparisons with unsigned numbers can be evaluated
11664		if (resolved_type->id == TypeTableEntryIdInt && !resolved_type->data.integral.is_signed) {
	11664	if (resolved_type->id == ZigTypeIdInt && !resolved_type->data.integral.is_signed) {
11665	11665	ConstExprValue *known_left_val;
11666	11666	IrBinOp flipped_op_id;
11667	11667	if (instr_is_comptime(casted_op1)) {
...	...	@@ -11711,12 +11711,12 @@ static int ir_eval_math_op(ZigType type_entry, ConstExprValue op1_val,
11711	11711	bool is_int;
11712	11712	bool is_float;
11713	11713	Cmp op2_zcmp;
11714		if (type_entry->id == TypeTableEntryIdInt \|\| type_entry->id == TypeTableEntryIdComptimeInt) {
	11714	if (type_entry->id == ZigTypeIdInt \|\| type_entry->id == ZigTypeIdComptimeInt) {
11715	11715	is_int = true;
11716	11716	is_float = false;
11717	11717	op2_zcmp = bigint_cmp_zero(&op2_val->data.x_bigint);
11718		} else if (type_entry->id == TypeTableEntryIdFloat \|\|
11719		type_entry->id == TypeTableEntryIdComptimeFloat)
	11718	} else if (type_entry->id == ZigTypeIdFloat \|\|
	11719	type_entry->id == ZigTypeIdComptimeFloat)
11720	11720	{
11721	11721	is_int = false;
11722	11722	is_float = true;
...	...	@@ -11766,7 +11766,7 @@ static int ir_eval_math_op(ZigType type_entry, ConstExprValue op1_val,
11766	11766	bigint_shl(&out_val->data.x_bigint, &op1_val->data.x_bigint, &op2_val->data.x_bigint);
11767	11767	break;
11768	11768	case IrBinOpBitShiftLeftLossy:
11769		assert(type_entry->id == TypeTableEntryIdInt);
	11769	assert(type_entry->id == ZigTypeIdInt);
11770	11770	bigint_shl_trunc(&out_val->data.x_bigint, &op1_val->data.x_bigint, &op2_val->data.x_bigint,
11771	11771	type_entry->data.integral.bit_count, type_entry->data.integral.is_signed);
11772	11772	break;
...	...	@@ -11793,7 +11793,7 @@ static int ir_eval_math_op(ZigType type_entry, ConstExprValue op1_val,
11793	11793	}
11794	11794	break;
11795	11795	case IrBinOpAddWrap:
11796		assert(type_entry->id == TypeTableEntryIdInt);
	11796	assert(type_entry->id == ZigTypeIdInt);
11797	11797	bigint_add_wrap(&out_val->data.x_bigint, &op1_val->data.x_bigint, &op2_val->data.x_bigint,
11798	11798	type_entry->data.integral.bit_count, type_entry->data.integral.is_signed);
11799	11799	break;
...	...	@@ -11805,7 +11805,7 @@ static int ir_eval_math_op(ZigType type_entry, ConstExprValue op1_val,
11805	11805	}
11806	11806	break;
11807	11807	case IrBinOpSubWrap:
11808		assert(type_entry->id == TypeTableEntryIdInt);
	11808	assert(type_entry->id == ZigTypeIdInt);
11809	11809	bigint_sub_wrap(&out_val->data.x_bigint, &op1_val->data.x_bigint, &op2_val->data.x_bigint,
11810	11810	type_entry->data.integral.bit_count, type_entry->data.integral.is_signed);
11811	11811	break;
...	...	@@ -11817,7 +11817,7 @@ static int ir_eval_math_op(ZigType type_entry, ConstExprValue op1_val,
11817	11817	}
11818	11818	break;
11819	11819	case IrBinOpMultWrap:
11820		assert(type_entry->id == TypeTableEntryIdInt);
	11820	assert(type_entry->id == ZigTypeIdInt);
11821	11821	bigint_mul_wrap(&out_val->data.x_bigint, &op1_val->data.x_bigint, &op2_val->data.x_bigint,
11822	11822	type_entry->data.integral.bit_count, type_entry->data.integral.is_signed);
11823	11823	break;
...	...	@@ -11872,7 +11872,7 @@ static int ir_eval_math_op(ZigType type_entry, ConstExprValue op1_val,
11872	11872	break;
11873	11873	}
11874	11874
11875		if (type_entry->id == TypeTableEntryIdInt) {
	11875	if (type_entry->id == ZigTypeIdInt) {
11876	11876	if (!bigint_fits_in_bits(&out_val->data.x_bigint, type_entry->data.integral.bit_count,
11877	11877	type_entry->data.integral.is_signed))
11878	11878	{
...	...	@@ -11890,7 +11890,7 @@ static ZigType ir_analyze_bit_shift(IrAnalyze ira, IrInstructionBinOp *bin_op_
11890	11890	if (type_is_invalid(op1->value.type))
11891	11891	return ira->codegen->builtin_types.entry_invalid;
11892	11892
11893		if (op1->value.type->id != TypeTableEntryIdInt && op1->value.type->id != TypeTableEntryIdComptimeInt) {
	11893	if (op1->value.type->id != ZigTypeIdInt && op1->value.type->id != ZigTypeIdComptimeInt) {
11894	11894	ir_add_error(ira, &bin_op_instruction->base,
11895	11895	buf_sprintf("bit shifting operation expected integer type, found '%s'",
11896	11896	buf_ptr(&op1->value.type->name)));
...	...	@@ -11903,7 +11903,7 @@ static ZigType ir_analyze_bit_shift(IrAnalyze ira, IrInstructionBinOp *bin_op_
11903	11903
11904	11904	IrInstruction *casted_op2;
11905	11905	IrBinOp op_id = bin_op_instruction->op_id;
11906		if (op1->value.type->id == TypeTableEntryIdComptimeInt) {
	11906	if (op1->value.type->id == ZigTypeIdComptimeInt) {
11907	11907	casted_op2 = op2;
11908	11908
11909	11909	if (op_id == IrBinOpBitShiftLeftLossy) {
...	...	@@ -11920,7 +11920,7 @@ static ZigType ir_analyze_bit_shift(IrAnalyze ira, IrInstructionBinOp *bin_op_
11920	11920	ZigType *shift_amt_type = get_smallest_unsigned_int_type(ira->codegen,
11921	11921	op1->value.type->data.integral.bit_count - 1);
11922	11922	if (bin_op_instruction->op_id == IrBinOpBitShiftLeftLossy &&
11923		op2->value.type->id == TypeTableEntryIdComptimeInt) {
	11923	op2->value.type->id == ZigTypeIdComptimeInt) {
11924	11924	if (!bigint_fits_in_bits(&op2->value.data.x_bigint,
11925	11925	shift_amt_type->data.integral.bit_count,
11926	11926	op2->value.data.x_bigint.is_negative)) {
...	...	@@ -11974,7 +11974,7 @@ static ZigType ir_analyze_bit_shift(IrAnalyze ira, IrInstructionBinOp *bin_op_
11974	11974
11975	11975	ir_num_lit_fits_in_other_type(ira, result_instruction, op1->value.type, false);
11976	11976	return op1->value.type;
11977		} else if (op1->value.type->id == TypeTableEntryIdComptimeInt) {
	11977	} else if (op1->value.type->id == ZigTypeIdComptimeInt) {
11978	11978	ir_add_error(ira, &bin_op_instruction->base,
11979	11979	buf_sprintf("LHS of shift must be an integer type, or RHS must be compile-time known"));
11980	11980	return ira->codegen->builtin_types.entry_invalid;
...	...	@@ -11997,7 +11997,7 @@ static ZigType ir_analyze_bin_op_math(IrAnalyze ira, IrInstructionBinOp *bin_o
11997	11997	IrBinOp op_id = bin_op_instruction->op_id;
11998	11998
11999	11999	// look for pointer math
12000		if (op1->value.type->id == TypeTableEntryIdPointer && op1->value.type->data.pointer.ptr_len == PtrLenUnknown &&
	12000	if (op1->value.type->id == ZigTypeIdPointer && op1->value.type->data.pointer.ptr_len == PtrLenUnknown &&
12001	12001	(op_id == IrBinOpAdd \|\| op_id == IrBinOpSub))
12002	12002	{
12003	12003	IrInstruction *casted_op2 = ir_implicit_cast(ira, op2, ira->codegen->builtin_types.entry_usize);
...	...	@@ -12016,15 +12016,15 @@ static ZigType ir_analyze_bin_op_math(IrAnalyze ira, IrInstructionBinOp *bin_o
12016	12016	if (type_is_invalid(resolved_type))
12017	12017	return resolved_type;
12018	12018
12019		bool is_int = resolved_type->id == TypeTableEntryIdInt \|\| resolved_type->id == TypeTableEntryIdComptimeInt;
12020		bool is_float = resolved_type->id == TypeTableEntryIdFloat \|\| resolved_type->id == TypeTableEntryIdComptimeFloat;
	12019	bool is_int = resolved_type->id == ZigTypeIdInt \|\| resolved_type->id == ZigTypeIdComptimeInt;
	12020	bool is_float = resolved_type->id == ZigTypeIdFloat \|\| resolved_type->id == ZigTypeIdComptimeFloat;
12021	12021	bool is_signed_div = (
12022		(resolved_type->id == TypeTableEntryIdInt && resolved_type->data.integral.is_signed) \|\|
12023		resolved_type->id == TypeTableEntryIdFloat \|\|
12024		(resolved_type->id == TypeTableEntryIdComptimeFloat &&
	12022	(resolved_type->id == ZigTypeIdInt && resolved_type->data.integral.is_signed) \|\|
	12023	resolved_type->id == ZigTypeIdFloat \|\|
	12024	(resolved_type->id == ZigTypeIdComptimeFloat &&
12025	12025	((bigfloat_cmp_zero(&op1->value.data.x_bigfloat) != CmpGT) !=
12026	12026	(bigfloat_cmp_zero(&op2->value.data.x_bigfloat) != CmpGT))) \|\|
12027		(resolved_type->id == TypeTableEntryIdComptimeInt &&
	12027	(resolved_type->id == ZigTypeIdComptimeInt &&
12028	12028	((bigint_cmp_zero(&op1->value.data.x_bigint) != CmpGT) !=
12029	12029	(bigint_cmp_zero(&op2->value.data.x_bigint) != CmpGT)))
12030	12030	);
...	...	@@ -12146,7 +12146,7 @@ static ZigType ir_analyze_bin_op_math(IrAnalyze ira, IrInstructionBinOp *bin_o
12146	12146	return ira->codegen->builtin_types.entry_invalid;
12147	12147	}
12148	12148
12149		if (resolved_type->id == TypeTableEntryIdComptimeInt) {
	12149	if (resolved_type->id == ZigTypeIdComptimeInt) {
12150	12150	if (op_id == IrBinOpAddWrap) {
12151	12151	op_id = IrBinOpAdd;
12152	12152	} else if (op_id == IrBinOpSubWrap) {
...	...	@@ -12229,12 +12229,12 @@ static ZigType ir_analyze_array_cat(IrAnalyze ira, IrInstructionBinOp *instruc
12229	12229	size_t op1_array_index;
12230	12230	size_t op1_array_end;
12231	12231	ZigType *child_type;
12232		if (op1_type->id == TypeTableEntryIdArray) {
	12232	if (op1_type->id == ZigTypeIdArray) {
12233	12233	child_type = op1_type->data.array.child_type;
12234	12234	op1_array_val = op1_val;
12235	12235	op1_array_index = 0;
12236	12236	op1_array_end = op1_type->data.array.len;
12237		} else if (op1_type->id == TypeTableEntryIdPointer &&
	12237	} else if (op1_type->id == ZigTypeIdPointer &&
12238	12238	op1_type->data.pointer.child_type == ira->codegen->builtin_types.entry_u8 &&
12239	12239	op1_val->data.x_ptr.special == ConstPtrSpecialBaseArray &&
12240	12240	op1_val->data.x_ptr.data.base_array.is_cstr)
...	...	@@ -12260,7 +12260,7 @@ static ZigType ir_analyze_array_cat(IrAnalyze ira, IrInstructionBinOp *instruc
12260	12260	ConstExprValue *op2_array_val;
12261	12261	size_t op2_array_index;
12262	12262	size_t op2_array_end;
12263		if (op2_type->id == TypeTableEntryIdArray) {
	12263	if (op2_type->id == ZigTypeIdArray) {
12264	12264	if (op2_type->data.array.child_type != child_type) {
12265	12265	ir_add_error(ira, op2, buf_sprintf("expected array of type '%s', found '%s'",
12266	12266	buf_ptr(&child_type->name),
...	...	@@ -12270,7 +12270,7 @@ static ZigType ir_analyze_array_cat(IrAnalyze ira, IrInstructionBinOp *instruc
12270	12270	op2_array_val = op2_val;
12271	12271	op2_array_index = 0;
12272	12272	op2_array_end = op2_array_val->type->data.array.len;
12273		} else if (op2_type->id == TypeTableEntryIdPointer &&
	12273	} else if (op2_type->id == ZigTypeIdPointer &&
12274	12274	op2_type->data.pointer.child_type == ira->codegen->builtin_types.entry_u8 &&
12275	12275	op2_val->data.x_ptr.special == ConstPtrSpecialBaseArray &&
12276	12276	op2_val->data.x_ptr.data.base_array.is_cstr)
...	...	@@ -12308,7 +12308,7 @@ static ZigType ir_analyze_array_cat(IrAnalyze ira, IrInstructionBinOp *instruc
12308	12308	ZigType *result_type;
12309	12309	ConstExprValue *out_array_val;
12310	12310	size_t new_len = (op1_array_end - op1_array_index) + (op2_array_end - op2_array_index);
12311		if (op1_type->id == TypeTableEntryIdArray \|\| op2_type->id == TypeTableEntryIdArray) {
	12311	if (op1_type->id == ZigTypeIdArray \|\| op2_type->id == ZigTypeIdArray) {
12312	12312	result_type = get_array_type(ira->codegen, child_type, new_len);
12313	12313
12314	12314	out_array_val = out_val;
...	...	@@ -12392,7 +12392,7 @@ static ZigType ir_analyze_array_mult(IrAnalyze ira, IrInstructionBinOp *instru
12392	12392	return ira->codegen->builtin_types.entry_invalid;
12393	12393
12394	12394	ZigType *array_type = op1->value.type;
12395		if (array_type->id != TypeTableEntryIdArray) {
	12395	if (array_type->id != ZigTypeIdArray) {
12396	12396	ir_add_error(ira, op1, buf_sprintf("expected array type, found '%s'", buf_ptr(&op1->value.type->name)));
12397	12397	return ira->codegen->builtin_types.entry_invalid;
12398	12398	}
...	...	@@ -12555,8 +12555,8 @@ static ZigType ir_analyze_instruction_decl_var(IrAnalyze ira, IrInstructionDec
12555	12555	}
12556	12556
12557	12557	if (!type_is_invalid(result_type)) {
12558		if (result_type->id == TypeTableEntryIdUnreachable \|\|
12559		result_type->id == TypeTableEntryIdOpaque)
	12558	if (result_type->id == ZigTypeIdUnreachable \|\|
	12559	result_type->id == ZigTypeIdOpaque)
12560	12560	{
12561	12561	ir_add_error_node(ira, source_node,
12562	12562	buf_sprintf("variable of type '%s' not allowed", buf_ptr(&result_type->name)));
...	...	@@ -12571,7 +12571,7 @@ static ZigType ir_analyze_instruction_decl_var(IrAnalyze ira, IrInstructionDec
12571	12571	}
12572	12572	} else {
12573	12573	if (casted_init_value->value.special == ConstValSpecialStatic &&
12574		casted_init_value->value.type->id == TypeTableEntryIdFn &&
	12574	casted_init_value->value.type->id == ZigTypeIdFn &&
12575	12575	casted_init_value->value.data.x_ptr.data.fn.fn_entry->fn_inline == FnInlineAlways)
12576	12576	{
12577	12577	var_class_requires_const = true;
...	...	@@ -12680,10 +12680,10 @@ static ZigType ir_analyze_instruction_export(IrAnalyze ira, IrInstructionExpor
12680	12680	}
12681	12681
12682	12682	switch (target->value.type->id) {
12683		case TypeTableEntryIdInvalid:
12684		case TypeTableEntryIdUnreachable:
	12683	case ZigTypeIdInvalid:
	12684	case ZigTypeIdUnreachable:
12685	12685	zig_unreachable();
12686		case TypeTableEntryIdFn: {
	12686	case ZigTypeIdFn: {
12687	12687	assert(target->value.data.x_ptr.special == ConstPtrSpecialFunction);
12688	12688	ZigFn *fn_entry = target->value.data.x_ptr.data.fn.fn_entry;
12689	12689	CallingConvention cc = fn_entry->type_entry->data.fn.fn_type_id.cc;
...	...	@@ -12706,7 +12706,7 @@ static ZigType ir_analyze_instruction_export(IrAnalyze ira, IrInstructionExpor
12706	12706	break;
12707	12707	}
12708	12708	} break;
12709		case TypeTableEntryIdStruct:
	12709	case ZigTypeIdStruct:
12710	12710	if (is_slice(target->value.type)) {
12711	12711	ir_add_error(ira, target,
12712	12712	buf_sprintf("unable to export value of type '%s'", buf_ptr(&target->value.type->name)));
...	...	@@ -12716,26 +12716,26 @@ static ZigType ir_analyze_instruction_export(IrAnalyze ira, IrInstructionExpor
12716	12716	add_error_note(ira->codegen, msg, target->value.type->data.structure.decl_node, buf_sprintf("declared here"));
12717	12717	}
12718	12718	break;
12719		case TypeTableEntryIdUnion:
	12719	case ZigTypeIdUnion:
12720	12720	if (target->value.type->data.unionation.layout != ContainerLayoutExtern) {
12721	12721	ErrorMsg *msg = ir_add_error(ira, target,
12722	12722	buf_sprintf("exported union value must be declared extern"));
12723	12723	add_error_note(ira->codegen, msg, target->value.type->data.unionation.decl_node, buf_sprintf("declared here"));
12724	12724	}
12725	12725	break;
12726		case TypeTableEntryIdEnum:
	12726	case ZigTypeIdEnum:
12727	12727	if (target->value.type->data.enumeration.layout != ContainerLayoutExtern) {
12728	12728	ErrorMsg *msg = ir_add_error(ira, target,
12729	12729	buf_sprintf("exported enum value must be declared extern"));
12730	12730	add_error_note(ira->codegen, msg, target->value.type->data.enumeration.decl_node, buf_sprintf("declared here"));
12731	12731	}
12732	12732	break;
12733		case TypeTableEntryIdMetaType: {
	12733	case ZigTypeIdMetaType: {
12734	12734	ZigType *type_value = target->value.data.x_type;
12735	12735	switch (type_value->id) {
12736		case TypeTableEntryIdInvalid:
	12736	case ZigTypeIdInvalid:
12737	12737	zig_unreachable();
12738		case TypeTableEntryIdStruct:
	12738	case ZigTypeIdStruct:
12739	12739	if (is_slice(type_value)) {
12740	12740	ir_add_error(ira, target,
12741	12741	buf_sprintf("unable to export type '%s'", buf_ptr(&type_value->name)));
...	...	@@ -12745,73 +12745,73 @@ static ZigType ir_analyze_instruction_export(IrAnalyze ira, IrInstructionExpor
12745	12745	add_error_note(ira->codegen, msg, type_value->data.structure.decl_node, buf_sprintf("declared here"));
12746	12746	}
12747	12747	break;
12748		case TypeTableEntryIdUnion:
	12748	case ZigTypeIdUnion:
12749	12749	if (type_value->data.unionation.layout != ContainerLayoutExtern) {
12750	12750	ErrorMsg *msg = ir_add_error(ira, target,
12751	12751	buf_sprintf("exported union must be declared extern"));
12752	12752	add_error_note(ira->codegen, msg, type_value->data.unionation.decl_node, buf_sprintf("declared here"));
12753	12753	}
12754	12754	break;
12755		case TypeTableEntryIdEnum:
	12755	case ZigTypeIdEnum:
12756	12756	if (type_value->data.enumeration.layout != ContainerLayoutExtern) {
12757	12757	ErrorMsg *msg = ir_add_error(ira, target,
12758	12758	buf_sprintf("exported enum must be declared extern"));
12759	12759	add_error_note(ira->codegen, msg, type_value->data.enumeration.decl_node, buf_sprintf("declared here"));
12760	12760	}
12761	12761	break;
12762		case TypeTableEntryIdFn: {
	12762	case ZigTypeIdFn: {
12763	12763	if (type_value->data.fn.fn_type_id.cc == CallingConventionUnspecified) {
12764	12764	ir_add_error(ira, target,
12765	12765	buf_sprintf("exported function type must specify calling convention"));
12766	12766	}
12767	12767	} break;
12768		case TypeTableEntryIdInt:
12769		case TypeTableEntryIdFloat:
12770		case TypeTableEntryIdPointer:
12771		case TypeTableEntryIdArray:
12772		case TypeTableEntryIdBool:
	12768	case ZigTypeIdInt:
	12769	case ZigTypeIdFloat:
	12770	case ZigTypeIdPointer:
	12771	case ZigTypeIdArray:
	12772	case ZigTypeIdBool:
12773	12773	break;
12774		case TypeTableEntryIdMetaType:
12775		case TypeTableEntryIdVoid:
12776		case TypeTableEntryIdUnreachable:
12777		case TypeTableEntryIdComptimeFloat:
12778		case TypeTableEntryIdComptimeInt:
12779		case TypeTableEntryIdUndefined:
12780		case TypeTableEntryIdNull:
12781		case TypeTableEntryIdOptional:
12782		case TypeTableEntryIdErrorUnion:
12783		case TypeTableEntryIdErrorSet:
12784		case TypeTableEntryIdNamespace:
12785		case TypeTableEntryIdBlock:
12786		case TypeTableEntryIdBoundFn:
12787		case TypeTableEntryIdArgTuple:
12788		case TypeTableEntryIdOpaque:
12789		case TypeTableEntryIdPromise:
	12774	case ZigTypeIdMetaType:
	12775	case ZigTypeIdVoid:
	12776	case ZigTypeIdUnreachable:
	12777	case ZigTypeIdComptimeFloat:
	12778	case ZigTypeIdComptimeInt:
	12779	case ZigTypeIdUndefined:
	12780	case ZigTypeIdNull:
	12781	case ZigTypeIdOptional:
	12782	case ZigTypeIdErrorUnion:
	12783	case ZigTypeIdErrorSet:
	12784	case ZigTypeIdNamespace:
	12785	case ZigTypeIdBlock:
	12786	case ZigTypeIdBoundFn:
	12787	case ZigTypeIdArgTuple:
	12788	case ZigTypeIdOpaque:
	12789	case ZigTypeIdPromise:
12790	12790	ir_add_error(ira, target,
12791	12791	buf_sprintf("invalid export target '%s'", buf_ptr(&type_value->name)));
12792	12792	break;
12793	12793	}
12794	12794	} break;
12795		case TypeTableEntryIdVoid:
12796		case TypeTableEntryIdBool:
12797		case TypeTableEntryIdInt:
12798		case TypeTableEntryIdFloat:
12799		case TypeTableEntryIdPointer:
12800		case TypeTableEntryIdArray:
12801		case TypeTableEntryIdComptimeFloat:
12802		case TypeTableEntryIdComptimeInt:
12803		case TypeTableEntryIdUndefined:
12804		case TypeTableEntryIdNull:
12805		case TypeTableEntryIdOptional:
12806		case TypeTableEntryIdErrorUnion:
12807		case TypeTableEntryIdErrorSet:
	12795	case ZigTypeIdVoid:
	12796	case ZigTypeIdBool:
	12797	case ZigTypeIdInt:
	12798	case ZigTypeIdFloat:
	12799	case ZigTypeIdPointer:
	12800	case ZigTypeIdArray:
	12801	case ZigTypeIdComptimeFloat:
	12802	case ZigTypeIdComptimeInt:
	12803	case ZigTypeIdUndefined:
	12804	case ZigTypeIdNull:
	12805	case ZigTypeIdOptional:
	12806	case ZigTypeIdErrorUnion:
	12807	case ZigTypeIdErrorSet:
12808	12808	zig_panic("TODO export const value of type %s", buf_ptr(&target->value.type->name));
12809		case TypeTableEntryIdNamespace:
12810		case TypeTableEntryIdBlock:
12811		case TypeTableEntryIdBoundFn:
12812		case TypeTableEntryIdArgTuple:
12813		case TypeTableEntryIdOpaque:
12814		case TypeTableEntryIdPromise:
	12809	case ZigTypeIdNamespace:
	12810	case ZigTypeIdBlock:
	12811	case ZigTypeIdBoundFn:
	12812	case ZigTypeIdArgTuple:
	12813	case ZigTypeIdOpaque:
	12814	case ZigTypeIdPromise:
12815	12815	ir_add_error(ira, target,
12816	12816	buf_sprintf("invalid export target type '%s'", buf_ptr(&target->value.type->name)));
12817	12817	break;
...	...	@@ -12863,7 +12863,7 @@ static ZigType ir_analyze_instruction_error_union(IrAnalyze ira,
12863	12863	if (type_is_invalid(payload_type))
12864	12864	return ira->codegen->builtin_types.entry_invalid;
12865	12865
12866		if (err_set_type->id != TypeTableEntryIdErrorSet) {
	12866	if (err_set_type->id != ZigTypeIdErrorSet) {
12867	12867	ir_add_error(ira, instruction->err_set->other,
12868	12868	buf_sprintf("expected error set type, found type '%s'",
12869	12869	buf_ptr(&err_set_type->name)));
...	...	@@ -12918,7 +12918,7 @@ static IrInstruction ir_analyze_async_call(IrAnalyze ira, IrInstructionCall *c
12918	12918	{
12919	12919	Buf *alloc_field_name = buf_create_from_str(ASYNC_ALLOC_FIELD_NAME);
12920	12920	//Buf *free_field_name = buf_create_from_str("freeFn");
12921		assert(async_allocator_inst->value.type->id == TypeTableEntryIdPointer);
	12921	assert(async_allocator_inst->value.type->id == ZigTypeIdPointer);
12922	12922	ZigType *container_type = async_allocator_inst->value.type->data.pointer.child_type;
12923	12923	IrInstruction *field_ptr_inst = ir_analyze_container_field_ptr(ira, alloc_field_name, &call_instruction->base,
12924	12924	async_allocator_inst, container_type);
...	...	@@ -12926,17 +12926,17 @@ static IrInstruction ir_analyze_async_call(IrAnalyze ira, IrInstructionCall *c
12926	12926	return ira->codegen->invalid_instruction;
12927	12927	}
12928	12928	ZigType *ptr_to_alloc_fn_type = field_ptr_inst->value.type;
12929		assert(ptr_to_alloc_fn_type->id == TypeTableEntryIdPointer);
	12929	assert(ptr_to_alloc_fn_type->id == ZigTypeIdPointer);
12930	12930
12931	12931	ZigType *alloc_fn_type = ptr_to_alloc_fn_type->data.pointer.child_type;
12932		if (alloc_fn_type->id != TypeTableEntryIdFn) {
	12932	if (alloc_fn_type->id != ZigTypeIdFn) {
12933	12933	ir_add_error(ira, &call_instruction->base,
12934	12934	buf_sprintf("expected allocation function, found '%s'", buf_ptr(&alloc_fn_type->name)));
12935	12935	return ira->codegen->invalid_instruction;
12936	12936	}
12937	12937
12938	12938	ZigType *alloc_fn_return_type = alloc_fn_type->data.fn.fn_type_id.return_type;
12939		if (alloc_fn_return_type->id != TypeTableEntryIdErrorUnion) {
	12939	if (alloc_fn_return_type->id != ZigTypeIdErrorUnion) {
12940	12940	ir_add_error(ira, fn_ref,
12941	12941	buf_sprintf("expected allocation function to return error union, but it returns '%s'", buf_ptr(&alloc_fn_return_type->name)));
12942	12942	return ira->codegen->invalid_instruction;
...	...	@@ -13015,7 +13015,7 @@ static bool ir_analyze_fn_call_generic_arg(IrAnalyze ira, AstNode fn_proto_nod
13015	13015	}
13016	13016
13017	13017	bool comptime_arg = param_decl_node->data.param_decl.is_inline \|\|
13018		casted_arg->value.type->id == TypeTableEntryIdComptimeInt \|\| casted_arg->value.type->id == TypeTableEntryIdComptimeFloat;
	13018	casted_arg->value.type->id == ZigTypeIdComptimeInt \|\| casted_arg->value.type->id == ZigTypeIdComptimeFloat;
13019	13019
13020	13020	ConstExprValue *arg_val;
13021	13021
...	...	@@ -13041,8 +13041,8 @@ static bool ir_analyze_fn_call_generic_arg(IrAnalyze ira, AstNode fn_proto_nod
13041	13041	var->shadowable = !comptime_arg;
13042	13042
13043	13043	*next_proto_i += 1;
13044		} else if (casted_arg->value.type->id == TypeTableEntryIdComptimeInt \|\|
13045		casted_arg->value.type->id == TypeTableEntryIdComptimeFloat)
	13044	} else if (casted_arg->value.type->id == ZigTypeIdComptimeInt \|\|
	13045	casted_arg->value.type->id == ZigTypeIdComptimeFloat)
13046	13046	{
13047	13047	ir_add_error(ira, casted_arg,
13048	13048	buf_sprintf("compiler bug: integer and float literals in var args function must be casted. https://github.com/ziglang/zig/issues/557"));
...	...	@@ -13177,7 +13177,7 @@ static ZigType ir_analyze_fn_call(IrAnalyze ira, IrInstructionCall *call_instr
13177	13177	size_t call_param_count = call_instruction->arg_count + first_arg_1_or_0;
13178	13178	for (size_t i = 0; i < call_instruction->arg_count; i += 1) {
13179	13179	ConstExprValue *arg_tuple_value = &call_instruction->args[i]->other->value;
13180		if (arg_tuple_value->type->id == TypeTableEntryIdArgTuple) {
	13180	if (arg_tuple_value->type->id == ZigTypeIdArgTuple) {
13181	13181	call_param_count -= 1;
13182	13182	call_param_count += arg_tuple_value->data.x_arg_tuple.end_index -
13183	13183	arg_tuple_value->data.x_arg_tuple.start_index;
...	...	@@ -13245,14 +13245,14 @@ static ZigType ir_analyze_fn_call(IrAnalyze ira, IrInstructionCall *call_instr
13245	13245
13246	13246	size_t next_proto_i = 0;
13247	13247	if (first_arg_ptr) {
13248		assert(first_arg_ptr->value.type->id == TypeTableEntryIdPointer);
	13248	assert(first_arg_ptr->value.type->id == ZigTypeIdPointer);
13249	13249
13250	13250	bool first_arg_known_bare = false;
13251	13251	if (fn_type_id->next_param_index >= 1) {
13252	13252	ZigType *param_type = fn_type_id->param_info[next_proto_i].type;
13253	13253	if (type_is_invalid(param_type))
13254	13254	return ira->codegen->builtin_types.entry_invalid;
13255		first_arg_known_bare = param_type->id != TypeTableEntryIdPointer;
	13255	first_arg_known_bare = param_type->id != ZigTypeIdPointer;
13256	13256	}
13257	13257
13258	13258	IrInstruction *first_arg;
...	...	@@ -13314,7 +13314,7 @@ static ZigType ir_analyze_fn_call(IrAnalyze ira, IrInstructionCall *call_instr
13314	13314
13315	13315	if (inferred_err_set_type != nullptr) {
13316	13316	inferred_err_set_type->data.error_set.infer_fn = nullptr;
13317		if (result->value.type->id == TypeTableEntryIdErrorUnion) {
	13317	if (result->value.type->id == ZigTypeIdErrorUnion) {
13318	13318	if (result->value.data.x_err_union.err != nullptr) {
13319	13319	inferred_err_set_type->data.error_set.err_count = 1;
13320	13320	inferred_err_set_type->data.error_set.errors = allocate<ErrorTableEntry *>(1);
...	...	@@ -13323,7 +13323,7 @@ static ZigType ir_analyze_fn_call(IrAnalyze ira, IrInstructionCall *call_instr
13323	13323	ZigType *fn_inferred_err_set_type = result->value.type->data.error_union.err_set_type;
13324	13324	inferred_err_set_type->data.error_set.err_count = fn_inferred_err_set_type->data.error_set.err_count;
13325	13325	inferred_err_set_type->data.error_set.errors = fn_inferred_err_set_type->data.error_set.errors;
13326		} else if (result->value.type->id == TypeTableEntryIdErrorSet) {
	13326	} else if (result->value.type->id == ZigTypeIdErrorSet) {
13327	13327	inferred_err_set_type->data.error_set.err_count = result->value.type->data.error_set.err_count;
13328	13328	inferred_err_set_type->data.error_set.errors = result->value.type->data.error_set.errors;
13329	13329	}
...	...	@@ -13371,7 +13371,7 @@ static ZigType ir_analyze_fn_call(IrAnalyze ira, IrInstructionCall *call_instr
13371	13371	if (type_is_invalid(arg->value.type))
13372	13372	return ira->codegen->builtin_types.entry_invalid;
13373	13373
13374		if (arg->value.type->id == TypeTableEntryIdArgTuple) {
	13374	if (arg->value.type->id == ZigTypeIdArgTuple) {
13375	13375	new_fn_arg_count += arg->value.data.x_arg_tuple.end_index - arg->value.data.x_arg_tuple.start_index;
13376	13376	} else {
13377	13377	new_fn_arg_count += 1;
...	...	@@ -13401,14 +13401,14 @@ static ZigType ir_analyze_fn_call(IrAnalyze ira, IrInstructionCall *call_instr
13401	13401	size_t next_proto_i = 0;
13402	13402
13403	13403	if (first_arg_ptr) {
13404		assert(first_arg_ptr->value.type->id == TypeTableEntryIdPointer);
	13404	assert(first_arg_ptr->value.type->id == ZigTypeIdPointer);
13405	13405
13406	13406	bool first_arg_known_bare = false;
13407	13407	if (fn_type_id->next_param_index >= 1) {
13408	13408	ZigType *param_type = fn_type_id->param_info[next_proto_i].type;
13409	13409	if (type_is_invalid(param_type))
13410	13410	return ira->codegen->builtin_types.entry_invalid;
13411		first_arg_known_bare = param_type->id != TypeTableEntryIdPointer;
	13411	first_arg_known_bare = param_type->id != ZigTypeIdPointer;
13412	13412	}
13413	13413
13414	13414	IrInstruction *first_arg;
...	...	@@ -13437,7 +13437,7 @@ static ZigType ir_analyze_fn_call(IrAnalyze ira, IrInstructionCall *call_instr
13437	13437	if (type_is_invalid(arg->value.type))
13438	13438	return ira->codegen->builtin_types.entry_invalid;
13439	13439
13440		if (arg->value.type->id == TypeTableEntryIdArgTuple) {
	13440	if (arg->value.type->id == ZigTypeIdArgTuple) {
13441	13441	for (size_t arg_tuple_i = arg->value.data.x_arg_tuple.start_index;
13442	13442	arg_tuple_i < arg->value.data.x_arg_tuple.end_index; arg_tuple_i += 1)
13443	13443	{
...	...	@@ -13616,14 +13616,14 @@ static ZigType ir_analyze_fn_call(IrAnalyze ira, IrInstructionCall *call_instr
13616	13616	IrInstruction *casted_args = allocate<IrInstruction >(call_param_count);
13617	13617	size_t next_arg_index = 0;
13618	13618	if (first_arg_ptr) {
13619		assert(first_arg_ptr->value.type->id == TypeTableEntryIdPointer);
	13619	assert(first_arg_ptr->value.type->id == ZigTypeIdPointer);
13620	13620
13621	13621	ZigType *param_type = fn_type_id->param_info[next_arg_index].type;
13622	13622	if (type_is_invalid(param_type))
13623	13623	return ira->codegen->builtin_types.entry_invalid;
13624	13624
13625	13625	IrInstruction *first_arg;
13626		if (param_type->id == TypeTableEntryIdPointer &&
	13626	if (param_type->id == ZigTypeIdPointer &&
13627	13627	handle_is_ptr(first_arg_ptr->value.type->data.pointer.child_type))
13628	13628	{
13629	13629	first_arg = first_arg_ptr;
...	...	@@ -13712,7 +13712,7 @@ static ZigType ir_analyze_instruction_call(IrAnalyze ira, IrInstructionCall *c
13712	13712	ir_should_inline(ira->new_irb.exec, call_instruction->base.scope);
13713	13713
13714	13714	if (is_comptime \|\| instr_is_comptime(fn_ref)) {
13715		if (fn_ref->value.type->id == TypeTableEntryIdMetaType) {
	13715	if (fn_ref->value.type->id == ZigTypeIdMetaType) {
13716	13716	ZigType *dest_type = ir_resolve_type(ira, fn_ref);
13717	13717	if (type_is_invalid(dest_type))
13718	13718	return ira->codegen->builtin_types.entry_invalid;
...	...	@@ -13733,13 +13733,13 @@ static ZigType ir_analyze_instruction_call(IrAnalyze ira, IrInstructionCall *c
13733	13733
13734	13734	ir_link_new_instruction(cast_instruction, &call_instruction->base);
13735	13735	return ir_finish_anal(ira, cast_instruction->value.type);
13736		} else if (fn_ref->value.type->id == TypeTableEntryIdFn) {
	13736	} else if (fn_ref->value.type->id == ZigTypeIdFn) {
13737	13737	ZigFn *fn_table_entry = ir_resolve_fn(ira, fn_ref);
13738	13738	if (fn_table_entry == nullptr)
13739	13739	return ira->codegen->builtin_types.entry_invalid;
13740	13740	return ir_analyze_fn_call(ira, call_instruction, fn_table_entry, fn_table_entry->type_entry,
13741	13741	fn_ref, nullptr, is_comptime, call_instruction->fn_inline);
13742		} else if (fn_ref->value.type->id == TypeTableEntryIdBoundFn) {
	13742	} else if (fn_ref->value.type->id == ZigTypeIdBoundFn) {
13743	13743	assert(fn_ref->value.special == ConstValSpecialStatic);
13744	13744	ZigFn *fn_table_entry = fn_ref->value.data.x_bound_fn.fn;
13745	13745	IrInstruction *first_arg_ptr = fn_ref->value.data.x_bound_fn.first_arg;
...	...	@@ -13752,7 +13752,7 @@ static ZigType ir_analyze_instruction_call(IrAnalyze ira, IrInstructionCall *c
13752	13752	}
13753	13753	}
13754	13754
13755		if (fn_ref->value.type->id == TypeTableEntryIdFn) {
	13755	if (fn_ref->value.type->id == ZigTypeIdFn) {
13756	13756	return ir_analyze_fn_call(ira, call_instruction, nullptr, fn_ref->value.type,
13757	13757	fn_ref, nullptr, false, FnInlineAuto);
13758	13758	} else {
...	...	@@ -13801,7 +13801,7 @@ static ZigType ir_analyze_dereference(IrAnalyze ira, IrInstructionUnOp *un_op_
13801	13801	ZigType *child_type;
13802	13802	if (type_is_invalid(ptr_type)) {
13803	13803	return ira->codegen->builtin_types.entry_invalid;
13804		} else if (ptr_type->id == TypeTableEntryIdPointer) {
	13804	} else if (ptr_type->id == ZigTypeIdPointer) {
13805	13805	if (ptr_type->data.pointer.ptr_len == PtrLenUnknown) {
13806	13806	ir_add_error_node(ira, un_op_instruction->base.source_node,
13807	13807	buf_sprintf("index syntax required for unknown-length pointer type '%s'",
...	...	@@ -13845,38 +13845,38 @@ static ZigType ir_analyze_maybe(IrAnalyze ira, IrInstructionUnOp *un_op_instru
13845	13845	return ira->codegen->builtin_types.entry_invalid;
13846	13846
13847	13847	switch (type_entry->id) {
13848		case TypeTableEntryIdInvalid:
	13848	case ZigTypeIdInvalid:
13849	13849	zig_unreachable();
13850		case TypeTableEntryIdMetaType:
13851		case TypeTableEntryIdVoid:
13852		case TypeTableEntryIdBool:
13853		case TypeTableEntryIdInt:
13854		case TypeTableEntryIdFloat:
13855		case TypeTableEntryIdPointer:
13856		case TypeTableEntryIdArray:
13857		case TypeTableEntryIdStruct:
13858		case TypeTableEntryIdComptimeFloat:
13859		case TypeTableEntryIdComptimeInt:
13860		case TypeTableEntryIdUndefined:
13861		case TypeTableEntryIdNull:
13862		case TypeTableEntryIdOptional:
13863		case TypeTableEntryIdErrorUnion:
13864		case TypeTableEntryIdErrorSet:
13865		case TypeTableEntryIdEnum:
13866		case TypeTableEntryIdUnion:
13867		case TypeTableEntryIdFn:
13868		case TypeTableEntryIdNamespace:
13869		case TypeTableEntryIdBlock:
13870		case TypeTableEntryIdBoundFn:
13871		case TypeTableEntryIdArgTuple:
13872		case TypeTableEntryIdPromise:
	13850	case ZigTypeIdMetaType:
	13851	case ZigTypeIdVoid:
	13852	case ZigTypeIdBool:
	13853	case ZigTypeIdInt:
	13854	case ZigTypeIdFloat:
	13855	case ZigTypeIdPointer:
	13856	case ZigTypeIdArray:
	13857	case ZigTypeIdStruct:
	13858	case ZigTypeIdComptimeFloat:
	13859	case ZigTypeIdComptimeInt:
	13860	case ZigTypeIdUndefined:
	13861	case ZigTypeIdNull:
	13862	case ZigTypeIdOptional:
	13863	case ZigTypeIdErrorUnion:
	13864	case ZigTypeIdErrorSet:
	13865	case ZigTypeIdEnum:
	13866	case ZigTypeIdUnion:
	13867	case ZigTypeIdFn:
	13868	case ZigTypeIdNamespace:
	13869	case ZigTypeIdBlock:
	13870	case ZigTypeIdBoundFn:
	13871	case ZigTypeIdArgTuple:
	13872	case ZigTypeIdPromise:
13873	13873	{
13874	13874	ConstExprValue *out_val = ir_build_const_from(ira, &un_op_instruction->base);
13875	13875	out_val->data.x_type = get_optional_type(ira->codegen, type_entry);
13876	13876	return ira->codegen->builtin_types.entry_type;
13877	13877	}
13878		case TypeTableEntryIdUnreachable:
13879		case TypeTableEntryIdOpaque:
	13878	case ZigTypeIdUnreachable:
	13879	case ZigTypeIdOpaque:
13880	13880	ir_add_error_node(ira, un_op_instruction->base.source_node,
13881	13881	buf_sprintf("type '%s' not optional", buf_ptr(&type_entry->name)));
13882	13882	return ira->codegen->builtin_types.entry_invalid;
...	...	@@ -13892,10 +13892,10 @@ static ZigType ir_analyze_negation(IrAnalyze ira, IrInstructionUnOp *un_op_ins
13892	13892
13893	13893	bool is_wrap_op = (un_op_instruction->op_id == IrUnOpNegationWrap);
13894	13894
13895		bool is_float = (expr_type->id == TypeTableEntryIdFloat \|\| expr_type->id == TypeTableEntryIdComptimeFloat);
	13895	bool is_float = (expr_type->id == ZigTypeIdFloat \|\| expr_type->id == ZigTypeIdComptimeFloat);
13896	13896
13897		if ((expr_type->id == TypeTableEntryIdInt && expr_type->data.integral.is_signed) \|\|
13898		expr_type->id == TypeTableEntryIdComptimeInt \|\| (is_float && !is_wrap_op))
	13897	if ((expr_type->id == ZigTypeIdInt && expr_type->data.integral.is_signed) \|\|
	13898	expr_type->id == ZigTypeIdComptimeInt \|\| (is_float && !is_wrap_op))
13899	13899	{
13900	13900	if (instr_is_comptime(value)) {
13901	13901	ConstExprValue *target_const_val = ir_resolve_const(ira, value, UndefBad);
...	...	@@ -13911,7 +13911,7 @@ static ZigType ir_analyze_negation(IrAnalyze ira, IrInstructionUnOp *un_op_ins
13911	13911	} else {
13912	13912	bigint_negate(&out_val->data.x_bigint, &target_const_val->data.x_bigint);
13913	13913	}
13914		if (is_wrap_op \|\| is_float \|\| expr_type->id == TypeTableEntryIdComptimeInt) {
	13914	if (is_wrap_op \|\| is_float \|\| expr_type->id == ZigTypeIdComptimeInt) {
13915	13915	return expr_type;
13916	13916	}
13917	13917
...	...	@@ -13937,7 +13937,7 @@ static ZigType ir_analyze_bin_not(IrAnalyze ira, IrInstructionUnOp *instructio
13937	13937	if (type_is_invalid(expr_type))
13938	13938	return ira->codegen->builtin_types.entry_invalid;
13939	13939
13940		if (expr_type->id == TypeTableEntryIdInt) {
	13940	if (expr_type->id == ZigTypeIdInt) {
13941	13941	if (instr_is_comptime(value)) {
13942	13942	ConstExprValue *target_const_val = ir_resolve_const(ira, value, UndefBad);
13943	13943	if (target_const_val == nullptr)
...	...	@@ -14082,7 +14082,7 @@ static ZigType ir_analyze_instruction_phi(IrAnalyze ira, IrInstructionPhi *phi
14082	14082	IrInstruction *old_value = phi_instruction->incoming_values[i];
14083	14083	assert(old_value);
14084	14084	IrInstruction *new_value = old_value->other;
14085		if (!new_value \|\| new_value->value.type->id == TypeTableEntryIdUnreachable \|\| predecessor->other == nullptr)
	14085	if (!new_value \|\| new_value->value.type->id == ZigTypeIdUnreachable \|\| predecessor->other == nullptr)
14086	14086	continue;
14087	14087
14088	14088	if (type_is_invalid(new_value->value.type))
...	...	@@ -14110,17 +14110,17 @@ static ZigType ir_analyze_instruction_phi(IrAnalyze ira, IrInstructionPhi *phi
14110	14110	if (type_is_invalid(resolved_type))
14111	14111	return resolved_type;
14112	14112
14113		if (resolved_type->id == TypeTableEntryIdComptimeFloat \|\|
14114		resolved_type->id == TypeTableEntryIdComptimeInt \|\|
14115		resolved_type->id == TypeTableEntryIdNull \|\|
14116		resolved_type->id == TypeTableEntryIdUndefined)
	14113	if (resolved_type->id == ZigTypeIdComptimeFloat \|\|
	14114	resolved_type->id == ZigTypeIdComptimeInt \|\|
	14115	resolved_type->id == ZigTypeIdNull \|\|
	14116	resolved_type->id == ZigTypeIdUndefined)
14117	14117	{
14118	14118	ir_add_error_node(ira, phi_instruction->base.source_node,
14119	14119	buf_sprintf("unable to infer expression type"));
14120	14120	return ira->codegen->builtin_types.entry_invalid;
14121	14121	}
14122	14122
14123		bool all_stack_ptrs = (resolved_type->id == TypeTableEntryIdPointer);
	14123	bool all_stack_ptrs = (resolved_type->id == ZigTypeIdPointer);
14124	14124
14125	14125	// cast all values to the resolved type. however we can't put cast instructions in front of the phi instruction.
14126	14126	// so we go back and insert the casts as the last instruction in the corresponding predecessor blocks, and
...	...	@@ -14171,7 +14171,7 @@ static ZigType ir_analyze_instruction_var_ptr(IrAnalyze ira, IrInstructionVarP
14171	14171	}
14172	14172
14173	14173	static ZigType adjust_ptr_align(CodeGen g, ZigType *ptr_type, uint32_t new_align) {
14174		assert(ptr_type->id == TypeTableEntryIdPointer);
	14174	assert(ptr_type->id == ZigTypeIdPointer);
14175	14175	return get_pointer_to_type_extra(g,
14176	14176	ptr_type->data.pointer.child_type,
14177	14177	ptr_type->data.pointer.is_const, ptr_type->data.pointer.is_volatile,
...	...	@@ -14188,7 +14188,7 @@ static ZigType adjust_slice_align(CodeGen g, ZigType *slice_type, uint32_t new
14188	14188	}
14189	14189
14190	14190	static ZigType adjust_ptr_len(CodeGen g, ZigType *ptr_type, PtrLen ptr_len) {
14191		assert(ptr_type->id == TypeTableEntryIdPointer);
	14191	assert(ptr_type->id == ZigTypeIdPointer);
14192	14192	return get_pointer_to_type_extra(g,
14193	14193	ptr_type->data.pointer.child_type,
14194	14194	ptr_type->data.pointer.is_const, ptr_type->data.pointer.is_volatile,
...	...	@@ -14210,7 +14210,7 @@ static ZigType ir_analyze_instruction_elem_ptr(IrAnalyze ira, IrInstructionEle
14210	14210	return ira->codegen->builtin_types.entry_invalid;
14211	14211
14212	14212	ZigType *ptr_type = orig_array_ptr_val->type;
14213		assert(ptr_type->id == TypeTableEntryIdPointer);
	14213	assert(ptr_type->id == ZigTypeIdPointer);
14214	14214
14215	14215	ZigType *array_type = ptr_type->data.pointer.child_type;
14216	14216
...	...	@@ -14220,12 +14220,12 @@ static ZigType ir_analyze_instruction_elem_ptr(IrAnalyze ira, IrInstructionEle
14220	14220
14221	14221	if (type_is_invalid(array_type)) {
14222	14222	return array_type;
14223		} else if (array_type->id == TypeTableEntryIdArray \|\|
14224		(array_type->id == TypeTableEntryIdPointer &&
	14223	} else if (array_type->id == ZigTypeIdArray \|\|
	14224	(array_type->id == ZigTypeIdPointer &&
14225	14225	array_type->data.pointer.ptr_len == PtrLenSingle &&
14226		array_type->data.pointer.child_type->id == TypeTableEntryIdArray))
	14226	array_type->data.pointer.child_type->id == ZigTypeIdArray))
14227	14227	{
14228		if (array_type->id == TypeTableEntryIdPointer) {
	14228	if (array_type->id == ZigTypeIdPointer) {
14229	14229	array_type = array_type->data.pointer.child_type;
14230	14230	ptr_type = ptr_type->data.pointer.child_type;
14231	14231	if (orig_array_ptr_val->special != ConstValSpecialRuntime) {
...	...	@@ -14259,7 +14259,7 @@ static ZigType ir_analyze_instruction_elem_ptr(IrAnalyze ira, IrInstructionEle
14259	14259	elem_ptr_instruction->ptr_len,
14260	14260	1, (uint32_t)bit_offset, (uint32_t)bit_width);
14261	14261	}
14262		} else if (array_type->id == TypeTableEntryIdPointer) {
	14262	} else if (array_type->id == ZigTypeIdPointer) {
14263	14263	if (array_type->data.pointer.ptr_len == PtrLenSingle) {
14264	14264	ir_add_error_node(ira, elem_ptr_instruction->base.source_node,
14265	14265	buf_sprintf("index of single-item pointer"));
...	...	@@ -14269,7 +14269,7 @@ static ZigType ir_analyze_instruction_elem_ptr(IrAnalyze ira, IrInstructionEle
14269	14269	} else if (is_slice(array_type)) {
14270	14270	return_type = adjust_ptr_len(ira->codegen, array_type->data.structure.fields[slice_ptr_index].type_entry,
14271	14271	elem_ptr_instruction->ptr_len);
14272		} else if (array_type->id == TypeTableEntryIdArgTuple) {
	14272	} else if (array_type->id == ZigTypeIdArgTuple) {
14273	14273	ConstExprValue *ptr_val = ir_resolve_const(ira, array_ptr, UndefBad);
14274	14274	if (!ptr_val)
14275	14275	return ira->codegen->builtin_types.entry_invalid;
...	...	@@ -14320,7 +14320,7 @@ static ZigType ir_analyze_instruction_elem_ptr(IrAnalyze ira, IrInstructionEle
14320	14320	uint64_t ptr_align = return_type->data.pointer.alignment;
14321	14321	if (instr_is_comptime(casted_elem_index)) {
14322	14322	uint64_t index = bigint_as_unsigned(&casted_elem_index->value.data.x_bigint);
14323		if (array_type->id == TypeTableEntryIdArray) {
	14323	if (array_type->id == ZigTypeIdArray) {
14324	14324	uint64_t array_len = array_type->data.array.len;
14325	14325	if (index >= array_len) {
14326	14326	ir_add_error_node(ira, elem_ptr_instruction->base.source_node,
...	...	@@ -14353,7 +14353,7 @@ static ZigType ir_analyze_instruction_elem_ptr(IrAnalyze ira, IrInstructionEle
14353	14353
14354	14354	if (orig_array_ptr_val->special != ConstValSpecialRuntime &&
14355	14355	(orig_array_ptr_val->data.x_ptr.mut != ConstPtrMutRuntimeVar \|\|
14356		array_type->id == TypeTableEntryIdArray))
	14356	array_type->id == ZigTypeIdArray))
14357	14357	{
14358	14358	ConstExprValue *array_ptr_val = ir_const_ptr_pointee(ira, orig_array_ptr_val,
14359	14359	elem_ptr_instruction->base.source_node);
...	...	@@ -14361,10 +14361,10 @@ static ZigType ir_analyze_instruction_elem_ptr(IrAnalyze ira, IrInstructionEle
14361	14361	return ira->codegen->builtin_types.entry_invalid;
14362	14362
14363	14363	if (array_ptr_val->special != ConstValSpecialRuntime &&
14364		(array_type->id != TypeTableEntryIdPointer \|\|
	14364	(array_type->id != ZigTypeIdPointer \|\|
14365	14365	array_ptr_val->data.x_ptr.special != ConstPtrSpecialHardCodedAddr))
14366	14366	{
14367		if (array_type->id == TypeTableEntryIdPointer) {
	14367	if (array_type->id == ZigTypeIdPointer) {
14368	14368	ConstExprValue *out_val = ir_build_const_from(ira, &elem_ptr_instruction->base);
14369	14369	out_val->data.x_ptr.mut = array_ptr_val->data.x_ptr.mut;
14370	14370	size_t new_index;
...	...	@@ -14461,7 +14461,7 @@ static ZigType ir_analyze_instruction_elem_ptr(IrAnalyze ira, IrInstructionEle
14461	14461	zig_panic("TODO elem ptr on a slice that was ptrcast from a function");
14462	14462	}
14463	14463	return return_type;
14464		} else if (array_type->id == TypeTableEntryIdArray) {
	14464	} else if (array_type->id == ZigTypeIdArray) {
14465	14465	ConstExprValue *out_val = ir_build_const_from(ira, &elem_ptr_instruction->base);
14466	14466	out_val->data.x_ptr.special = ConstPtrSpecialBaseArray;
14467	14467	out_val->data.x_ptr.mut = orig_array_ptr_val->data.x_ptr.mut;
...	...	@@ -14521,11 +14521,11 @@ static IrInstruction ir_analyze_container_member_access_inner(IrAnalyze ira,
14521	14521	const char *prefix_name;
14522	14522	if (is_slice(bare_struct_type)) {
14523	14523	prefix_name = "";
14524		} else if (bare_struct_type->id == TypeTableEntryIdStruct) {
	14524	} else if (bare_struct_type->id == ZigTypeIdStruct) {
14525	14525	prefix_name = "struct ";
14526		} else if (bare_struct_type->id == TypeTableEntryIdEnum) {
	14526	} else if (bare_struct_type->id == ZigTypeIdEnum) {
14527	14527	prefix_name = "enum ";
14528		} else if (bare_struct_type->id == TypeTableEntryIdUnion) {
	14528	} else if (bare_struct_type->id == ZigTypeIdUnion) {
14529	14529	prefix_name = "union ";
14530	14530	} else {
14531	14531	prefix_name = "";
...	...	@@ -14544,10 +14544,10 @@ static IrInstruction ir_analyze_container_field_ptr(IrAnalyze ira, Buf *field_
14544	14544	if ((err = ensure_complete_type(ira->codegen, bare_type)))
14545	14545	return ira->codegen->invalid_instruction;
14546	14546
14547		assert(container_ptr->value.type->id == TypeTableEntryIdPointer);
	14547	assert(container_ptr->value.type->id == ZigTypeIdPointer);
14548	14548	bool is_const = container_ptr->value.type->data.pointer.is_const;
14549	14549	bool is_volatile = container_ptr->value.type->data.pointer.is_volatile;
14550		if (bare_type->id == TypeTableEntryIdStruct) {
	14550	if (bare_type->id == ZigTypeIdStruct) {
14551	14551	TypeStructField *field = find_struct_type_field(bare_type, field_name);
14552	14552	if (field) {
14553	14553	bool is_packed = (bare_type->data.structure.layout == ContainerLayoutPacked);
...	...	@@ -14594,10 +14594,10 @@ static IrInstruction ir_analyze_container_field_ptr(IrAnalyze ira, Buf *field_
14594	14594	return ir_analyze_container_member_access_inner(ira, bare_type, field_name,
14595	14595	source_instr, container_ptr, container_type);
14596	14596	}
14597		} else if (bare_type->id == TypeTableEntryIdEnum) {
	14597	} else if (bare_type->id == ZigTypeIdEnum) {
14598	14598	return ir_analyze_container_member_access_inner(ira, bare_type, field_name,
14599	14599	source_instr, container_ptr, container_type);
14600		} else if (bare_type->id == TypeTableEntryIdUnion) {
	14600	} else if (bare_type->id == ZigTypeIdUnion) {
14601	14601	TypeUnionField *field = find_union_type_field(bare_type, field_name);
14602	14602	if (field) {
14603	14603	if (instr_is_comptime(container_ptr)) {
...	...	@@ -14626,7 +14626,7 @@ static IrInstruction ir_analyze_container_field_ptr(IrAnalyze ira, Buf *field_
14626	14626	ConstExprValue *payload_val = union_val->data.x_union.payload;
14627	14627
14628	14628	ZigType *field_type = field->type_entry;
14629		if (field_type->id == TypeTableEntryIdVoid) {
	14629	if (field_type->id == ZigTypeIdVoid) {
14630	14630	assert(payload_val == nullptr);
14631	14631	payload_val = create_const_vals(1);
14632	14632	payload_val->special = ConstValSpecialStatic;
...	...	@@ -14732,7 +14732,7 @@ static ZigType ir_analyze_decl_ref(IrAnalyze ira, IrInstruction *source_instru
14732	14732	}
14733	14733
14734	14734	static ErrorTableEntry find_err_table_entry(ZigType err_set_type, Buf *field_name) {
14735		assert(err_set_type->id == TypeTableEntryIdErrorSet);
	14735	assert(err_set_type->id == ZigTypeIdErrorSet);
14736	14736	for (uint32_t i = 0; i < err_set_type->data.error_set.err_count; i += 1) {
14737	14737	ErrorTableEntry *err_table_entry = err_set_type->data.error_set.errors[i];
14738	14738	if (buf_eql_buf(&err_table_entry->name, field_name)) {
...	...	@@ -14749,7 +14749,7 @@ static ZigType ir_analyze_instruction_field_ptr(IrAnalyze ira, IrInstructionFi
14749	14749	return ira->codegen->builtin_types.entry_invalid;
14750	14750
14751	14751	ZigType *container_type = container_ptr->value.type->data.pointer.child_type;
14752		assert(container_ptr->value.type->id == TypeTableEntryIdPointer);
	14752	assert(container_ptr->value.type->id == ZigTypeIdPointer);
14753	14753
14754	14754	Buf *field_name = field_ptr_instruction->field_name_buffer;
14755	14755	if (!field_name) {
...	...	@@ -14765,8 +14765,8 @@ static ZigType ir_analyze_instruction_field_ptr(IrAnalyze ira, IrInstructionFi
14765	14765	if (type_is_invalid(container_type)) {
14766	14766	return container_type;
14767	14767	} else if (is_container_ref(container_type)) {
14768		assert(container_ptr->value.type->id == TypeTableEntryIdPointer);
14769		if (container_type->id == TypeTableEntryIdPointer) {
	14768	assert(container_ptr->value.type->id == ZigTypeIdPointer);
	14769	if (container_type->id == ZigTypeIdPointer) {
14770	14770	ZigType *bare_type = container_ref_type(container_type);
14771	14771	IrInstruction *container_child = ir_get_deref(ira, &field_ptr_instruction->base, container_ptr);
14772	14772	IrInstruction *result = ir_analyze_container_field_ptr(ira, field_name, &field_ptr_instruction->base, container_child, bare_type);
...	...	@@ -14780,7 +14780,7 @@ static ZigType ir_analyze_instruction_field_ptr(IrAnalyze ira, IrInstructionFi
14780	14780	} else if (is_array_ref(container_type)) {
14781	14781	if (buf_eql_str(field_name, "len")) {
14782	14782	ConstExprValue *len_val = create_const_vals(1);
14783		if (container_type->id == TypeTableEntryIdPointer) {
	14783	if (container_type->id == ZigTypeIdPointer) {
14784	14784	init_const_usize(ira->codegen, len_val, container_type->data.pointer.child_type->data.array.len);
14785	14785	} else {
14786	14786	init_const_usize(ira->codegen, len_val, container_type->data.array.len);
...	...	@@ -14797,12 +14797,12 @@ static ZigType ir_analyze_instruction_field_ptr(IrAnalyze ira, IrInstructionFi
14797	14797	buf_ptr(&container_type->name)));
14798	14798	return ira->codegen->builtin_types.entry_invalid;
14799	14799	}
14800		} else if (container_type->id == TypeTableEntryIdArgTuple) {
	14800	} else if (container_type->id == ZigTypeIdArgTuple) {
14801	14801	ConstExprValue *container_ptr_val = ir_resolve_const(ira, container_ptr, UndefBad);
14802	14802	if (!container_ptr_val)
14803	14803	return ira->codegen->builtin_types.entry_invalid;
14804	14804
14805		assert(container_ptr->value.type->id == TypeTableEntryIdPointer);
	14805	assert(container_ptr->value.type->id == ZigTypeIdPointer);
14806	14806	ConstExprValue *child_val = ir_const_ptr_pointee(ira, container_ptr_val, source_node);
14807	14807	if (child_val == nullptr)
14808	14808	return ira->codegen->builtin_types.entry_invalid;
...	...	@@ -14823,12 +14823,12 @@ static ZigType ir_analyze_instruction_field_ptr(IrAnalyze ira, IrInstructionFi
14823	14823	buf_ptr(&container_type->name)));
14824	14824	return ira->codegen->builtin_types.entry_invalid;
14825	14825	}
14826		} else if (container_type->id == TypeTableEntryIdMetaType) {
	14826	} else if (container_type->id == ZigTypeIdMetaType) {
14827	14827	ConstExprValue *container_ptr_val = ir_resolve_const(ira, container_ptr, UndefBad);
14828	14828	if (!container_ptr_val)
14829	14829	return ira->codegen->builtin_types.entry_invalid;
14830	14830
14831		assert(container_ptr->value.type->id == TypeTableEntryIdPointer);
	14831	assert(container_ptr->value.type->id == ZigTypeIdPointer);
14832	14832	ConstExprValue *child_val = ir_const_ptr_pointee(ira, container_ptr_val, source_node);
14833	14833	if (child_val == nullptr)
14834	14834	return ira->codegen->builtin_types.entry_invalid;
...	...	@@ -14841,14 +14841,14 @@ static ZigType ir_analyze_instruction_field_ptr(IrAnalyze ira, IrInstructionFi
14841	14841	bool ptr_is_const = true;
14842	14842	bool ptr_is_volatile = false;
14843	14843	TypeStructField *ptr_field = &child_type->data.structure.fields[slice_ptr_index];
14844		assert(ptr_field->type_entry->id == TypeTableEntryIdPointer);
	14844	assert(ptr_field->type_entry->id == ZigTypeIdPointer);
14845	14845	ZigType *child_type = ptr_field->type_entry->data.pointer.child_type;
14846	14846	return ir_analyze_const_ptr(ira, &field_ptr_instruction->base,
14847	14847	create_const_type(ira->codegen, child_type),
14848	14848	ira->codegen->builtin_types.entry_type,
14849	14849	ConstPtrMutComptimeConst, ptr_is_const, ptr_is_volatile);
14850	14850	}
14851		if (child_type->id == TypeTableEntryIdEnum) {
	14851	if (child_type->id == ZigTypeIdEnum) {
14852	14852	if ((err = ensure_complete_type(ira->codegen, child_type)))
14853	14853	return ira->codegen->builtin_types.entry_invalid;
14854	14854
...	...	@@ -14869,7 +14869,7 @@ static ZigType ir_analyze_instruction_field_ptr(IrAnalyze ira, IrInstructionFi
14869	14869	return ir_analyze_decl_ref(ira, &field_ptr_instruction->base, tld);
14870	14870	}
14871	14871	}
14872		if (child_type->id == TypeTableEntryIdUnion &&
	14872	if (child_type->id == ZigTypeIdUnion &&
14873	14873	(child_type->data.unionation.decl_node->data.container_decl.init_arg_expr != nullptr \|\|
14874	14874	child_type->data.unionation.decl_node->data.container_decl.auto_enum))
14875	14875	{
...	...	@@ -14889,7 +14889,7 @@ static ZigType ir_analyze_instruction_field_ptr(IrAnalyze ira, IrInstructionFi
14889	14889	buf_sprintf("container '%s' has no member called '%s'",
14890	14890	buf_ptr(&child_type->name), buf_ptr(field_name)));
14891	14891	return ira->codegen->builtin_types.entry_invalid;
14892		} else if (child_type->id == TypeTableEntryIdErrorSet) {
	14892	} else if (child_type->id == ZigTypeIdErrorSet) {
14893	14893	ErrorTableEntry *err_entry;
14894	14894	ZigType *err_set_type;
14895	14895	if (type_is_global_error_set(child_type)) {
...	...	@@ -14935,7 +14935,7 @@ static ZigType ir_analyze_instruction_field_ptr(IrAnalyze ira, IrInstructionFi
14935	14935	bool ptr_is_volatile = false;
14936	14936	return ir_analyze_const_ptr(ira, &field_ptr_instruction->base, const_val,
14937	14937	err_set_type, ConstPtrMutComptimeConst, ptr_is_const, ptr_is_volatile);
14938		} else if (child_type->id == TypeTableEntryIdInt) {
	14938	} else if (child_type->id == ZigTypeIdInt) {
14939	14939	if (buf_eql_str(field_name, "bit_count")) {
14940	14940	bool ptr_is_const = true;
14941	14941	bool ptr_is_volatile = false;
...	...	@@ -14957,7 +14957,7 @@ static ZigType ir_analyze_instruction_field_ptr(IrAnalyze ira, IrInstructionFi
14957	14957	buf_ptr(&child_type->name), buf_ptr(field_name)));
14958	14958	return ira->codegen->builtin_types.entry_invalid;
14959	14959	}
14960		} else if (child_type->id == TypeTableEntryIdFloat) {
	14960	} else if (child_type->id == ZigTypeIdFloat) {
14961	14961	if (buf_eql_str(field_name, "bit_count")) {
14962	14962	bool ptr_is_const = true;
14963	14963	bool ptr_is_volatile = false;
...	...	@@ -14972,7 +14972,7 @@ static ZigType ir_analyze_instruction_field_ptr(IrAnalyze ira, IrInstructionFi
14972	14972	buf_ptr(&child_type->name), buf_ptr(field_name)));
14973	14973	return ira->codegen->builtin_types.entry_invalid;
14974	14974	}
14975		} else if (child_type->id == TypeTableEntryIdPointer) {
	14975	} else if (child_type->id == ZigTypeIdPointer) {
14976	14976	if (buf_eql_str(field_name, "Child")) {
14977	14977	bool ptr_is_const = true;
14978	14978	bool ptr_is_volatile = false;
...	...	@@ -14994,7 +14994,7 @@ static ZigType ir_analyze_instruction_field_ptr(IrAnalyze ira, IrInstructionFi
14994	14994	buf_ptr(&child_type->name), buf_ptr(field_name)));
14995	14995	return ira->codegen->builtin_types.entry_invalid;
14996	14996	}
14997		} else if (child_type->id == TypeTableEntryIdArray) {
	14997	} else if (child_type->id == ZigTypeIdArray) {
14998	14998	if (buf_eql_str(field_name, "Child")) {
14999	14999	bool ptr_is_const = true;
15000	15000	bool ptr_is_volatile = false;
...	...	@@ -15016,7 +15016,7 @@ static ZigType ir_analyze_instruction_field_ptr(IrAnalyze ira, IrInstructionFi
15016	15016	buf_ptr(&child_type->name), buf_ptr(field_name)));
15017	15017	return ira->codegen->builtin_types.entry_invalid;
15018	15018	}
15019		} else if (child_type->id == TypeTableEntryIdErrorUnion) {
	15019	} else if (child_type->id == ZigTypeIdErrorUnion) {
15020	15020	if (buf_eql_str(field_name, "Payload")) {
15021	15021	bool ptr_is_const = true;
15022	15022	bool ptr_is_volatile = false;
...	...	@@ -15037,7 +15037,7 @@ static ZigType ir_analyze_instruction_field_ptr(IrAnalyze ira, IrInstructionFi
15037	15037	buf_ptr(&child_type->name), buf_ptr(field_name)));
15038	15038	return ira->codegen->builtin_types.entry_invalid;
15039	15039	}
15040		} else if (child_type->id == TypeTableEntryIdOptional) {
	15040	} else if (child_type->id == ZigTypeIdOptional) {
15041	15041	if (buf_eql_str(field_name, "Child")) {
15042	15042	bool ptr_is_const = true;
15043	15043	bool ptr_is_volatile = false;
...	...	@@ -15051,7 +15051,7 @@ static ZigType ir_analyze_instruction_field_ptr(IrAnalyze ira, IrInstructionFi
15051	15051	buf_ptr(&child_type->name), buf_ptr(field_name)));
15052	15052	return ira->codegen->builtin_types.entry_invalid;
15053	15053	}
15054		} else if (child_type->id == TypeTableEntryIdFn) {
	15054	} else if (child_type->id == ZigTypeIdFn) {
15055	15055	if (buf_eql_str(field_name, "ReturnType")) {
15056	15056	if (child_type->data.fn.fn_type_id.return_type == nullptr) {
15057	15057	// Return type can only ever be null, if the function is generic
...	...	@@ -15093,8 +15093,8 @@ static ZigType ir_analyze_instruction_field_ptr(IrAnalyze ira, IrInstructionFi
15093	15093	buf_sprintf("type '%s' does not support field access", buf_ptr(&child_type->name)));
15094	15094	return ira->codegen->builtin_types.entry_invalid;
15095	15095	}
15096		} else if (container_type->id == TypeTableEntryIdNamespace) {
15097		assert(container_ptr->value.type->id == TypeTableEntryIdPointer);
	15096	} else if (container_type->id == ZigTypeIdNamespace) {
	15097	assert(container_ptr->value.type->id == ZigTypeIdPointer);
15098	15098	ConstExprValue *container_ptr_val = ir_resolve_const(ira, container_ptr, UndefBad);
15099	15099	if (!container_ptr_val)
15100	15100	return ira->codegen->builtin_types.entry_invalid;
...	...	@@ -15151,7 +15151,7 @@ static ZigType ir_analyze_instruction_store_ptr(IrAnalyze ira, IrInstructionSt
15151	15151	if (type_is_invalid(value->value.type))
15152	15152	return value->value.type;
15153	15153
15154		if (ptr->value.type->id != TypeTableEntryIdPointer) {
	15154	if (ptr->value.type->id != ZigTypeIdPointer) {
15155	15155	ir_add_error(ira, ptr,
15156	15156	buf_sprintf("attempt to dereference non pointer type '%s'", buf_ptr(&ptr->value.type->name)));
15157	15157	return ira->codegen->builtin_types.entry_invalid;
...	...	@@ -15208,33 +15208,33 @@ static ZigType ir_analyze_instruction_typeof(IrAnalyze ira, IrInstructionTypeO
15208	15208	if (type_is_invalid(type_entry))
15209	15209	return ira->codegen->builtin_types.entry_invalid;
15210	15210	switch (type_entry->id) {
15211		case TypeTableEntryIdInvalid:
	15211	case ZigTypeIdInvalid:
15212	15212	zig_unreachable(); // handled above
15213		case TypeTableEntryIdComptimeFloat:
15214		case TypeTableEntryIdComptimeInt:
15215		case TypeTableEntryIdUndefined:
15216		case TypeTableEntryIdNull:
15217		case TypeTableEntryIdNamespace:
15218		case TypeTableEntryIdBlock:
15219		case TypeTableEntryIdBoundFn:
15220		case TypeTableEntryIdMetaType:
15221		case TypeTableEntryIdVoid:
15222		case TypeTableEntryIdBool:
15223		case TypeTableEntryIdUnreachable:
15224		case TypeTableEntryIdInt:
15225		case TypeTableEntryIdFloat:
15226		case TypeTableEntryIdPointer:
15227		case TypeTableEntryIdArray:
15228		case TypeTableEntryIdStruct:
15229		case TypeTableEntryIdOptional:
15230		case TypeTableEntryIdErrorUnion:
15231		case TypeTableEntryIdErrorSet:
15232		case TypeTableEntryIdEnum:
15233		case TypeTableEntryIdUnion:
15234		case TypeTableEntryIdFn:
15235		case TypeTableEntryIdArgTuple:
15236		case TypeTableEntryIdOpaque:
15237		case TypeTableEntryIdPromise:
	15213	case ZigTypeIdComptimeFloat:
	15214	case ZigTypeIdComptimeInt:
	15215	case ZigTypeIdUndefined:
	15216	case ZigTypeIdNull:
	15217	case ZigTypeIdNamespace:
	15218	case ZigTypeIdBlock:
	15219	case ZigTypeIdBoundFn:
	15220	case ZigTypeIdMetaType:
	15221	case ZigTypeIdVoid:
	15222	case ZigTypeIdBool:
	15223	case ZigTypeIdUnreachable:
	15224	case ZigTypeIdInt:
	15225	case ZigTypeIdFloat:
	15226	case ZigTypeIdPointer:
	15227	case ZigTypeIdArray:
	15228	case ZigTypeIdStruct:
	15229	case ZigTypeIdOptional:
	15230	case ZigTypeIdErrorUnion:
	15231	case ZigTypeIdErrorSet:
	15232	case ZigTypeIdEnum:
	15233	case ZigTypeIdUnion:
	15234	case ZigTypeIdFn:
	15235	case ZigTypeIdArgTuple:
	15236	case ZigTypeIdOpaque:
	15237	case ZigTypeIdPromise:
15238	15238	{
15239	15239	ConstExprValue *out_val = ir_build_const_from(ira, &typeof_instruction->base);
15240	15240	out_val->data.x_type = type_entry;
...	...	@@ -15255,11 +15255,11 @@ static ZigType ir_analyze_instruction_to_ptr_type(IrAnalyze ira,
15255	15255	return type_entry;
15256	15256
15257	15257	ZigType *ptr_type;
15258		if (type_entry->id == TypeTableEntryIdArray) {
	15258	if (type_entry->id == ZigTypeIdArray) {
15259	15259	ptr_type = get_pointer_to_type(ira->codegen, type_entry->data.array.child_type, false);
15260	15260	} else if (is_slice(type_entry)) {
15261	15261	ptr_type = adjust_ptr_len(ira->codegen, type_entry->data.structure.fields[0].type_entry, PtrLenSingle);
15262		} else if (type_entry->id == TypeTableEntryIdArgTuple) {
	15262	} else if (type_entry->id == ZigTypeIdArgTuple) {
15263	15263	ConstExprValue *arg_tuple_val = ir_resolve_const(ira, value, UndefBad);
15264	15264	if (!arg_tuple_val)
15265	15265	return ira->codegen->builtin_types.entry_invalid;
...	...	@@ -15283,7 +15283,7 @@ static ZigType ir_analyze_instruction_ptr_type_child(IrAnalyze ira,
15283	15283	if (type_is_invalid(type_entry))
15284	15284	return type_entry;
15285	15285
15286		if (type_entry->id != TypeTableEntryIdPointer) {
	15286	if (type_entry->id != ZigTypeIdPointer) {
15287	15287	ir_add_error_node(ira, ptr_type_child_instruction->base.source_node,
15288	15288	buf_sprintf("expected pointer type, found '%s'", buf_ptr(&type_entry->name)));
15289	15289	return ira->codegen->builtin_types.entry_invalid;
...	...	@@ -15400,24 +15400,24 @@ static ZigType ir_analyze_instruction_set_float_mode(IrAnalyze ira,
15400	15400
15401	15401	bool *fast_math_on_ptr;
15402	15402	AstNode **fast_math_set_node_ptr;
15403		if (target_type->id == TypeTableEntryIdBlock) {
	15403	if (target_type->id == ZigTypeIdBlock) {
15404	15404	ScopeBlock block_scope = (ScopeBlock )target_val->data.x_block;
15405	15405	fast_math_on_ptr = &block_scope->fast_math_on;
15406	15406	fast_math_set_node_ptr = &block_scope->fast_math_set_node;
15407		} else if (target_type->id == TypeTableEntryIdFn) {
	15407	} else if (target_type->id == ZigTypeIdFn) {
15408	15408	assert(target_val->data.x_ptr.special == ConstPtrSpecialFunction);
15409	15409	ZigFn *target_fn = target_val->data.x_ptr.data.fn.fn_entry;
15410	15410	assert(target_fn->def_scope);
15411	15411	fast_math_on_ptr = &target_fn->def_scope->fast_math_on;
15412	15412	fast_math_set_node_ptr = &target_fn->def_scope->fast_math_set_node;
15413		} else if (target_type->id == TypeTableEntryIdMetaType) {
	15413	} else if (target_type->id == ZigTypeIdMetaType) {
15414	15414	ScopeDecls *decls_scope;
15415	15415	ZigType *type_arg = target_val->data.x_type;
15416		if (type_arg->id == TypeTableEntryIdStruct) {
	15416	if (type_arg->id == ZigTypeIdStruct) {
15417	15417	decls_scope = type_arg->data.structure.decls_scope;
15418		} else if (type_arg->id == TypeTableEntryIdEnum) {
	15418	} else if (type_arg->id == ZigTypeIdEnum) {
15419	15419	decls_scope = type_arg->data.enumeration.decls_scope;
15420		} else if (type_arg->id == TypeTableEntryIdUnion) {
	15420	} else if (type_arg->id == ZigTypeIdUnion) {
15421	15421	decls_scope = type_arg->data.unionation.decls_scope;
15422	15422	} else {
15423	15423	ir_add_error_node(ira, target_instruction->source_node,
...	...	@@ -15476,36 +15476,36 @@ static ZigType ir_analyze_instruction_slice_type(IrAnalyze ira,
15476	15476	bool is_volatile = slice_type_instruction->is_volatile;
15477	15477
15478	15478	switch (child_type->id) {
15479		case TypeTableEntryIdInvalid: // handled above
	15479	case ZigTypeIdInvalid: // handled above
15480	15480	zig_unreachable();
15481		case TypeTableEntryIdUnreachable:
15482		case TypeTableEntryIdUndefined:
15483		case TypeTableEntryIdNull:
15484		case TypeTableEntryIdBlock:
15485		case TypeTableEntryIdArgTuple:
15486		case TypeTableEntryIdOpaque:
	15481	case ZigTypeIdUnreachable:
	15482	case ZigTypeIdUndefined:
	15483	case ZigTypeIdNull:
	15484	case ZigTypeIdBlock:
	15485	case ZigTypeIdArgTuple:
	15486	case ZigTypeIdOpaque:
15487	15487	ir_add_error_node(ira, slice_type_instruction->base.source_node,
15488	15488	buf_sprintf("slice of type '%s' not allowed", buf_ptr(&child_type->name)));
15489	15489	return ira->codegen->builtin_types.entry_invalid;
15490		case TypeTableEntryIdMetaType:
15491		case TypeTableEntryIdVoid:
15492		case TypeTableEntryIdBool:
15493		case TypeTableEntryIdInt:
15494		case TypeTableEntryIdFloat:
15495		case TypeTableEntryIdPointer:
15496		case TypeTableEntryIdArray:
15497		case TypeTableEntryIdStruct:
15498		case TypeTableEntryIdComptimeFloat:
15499		case TypeTableEntryIdComptimeInt:
15500		case TypeTableEntryIdOptional:
15501		case TypeTableEntryIdErrorUnion:
15502		case TypeTableEntryIdErrorSet:
15503		case TypeTableEntryIdEnum:
15504		case TypeTableEntryIdUnion:
15505		case TypeTableEntryIdFn:
15506		case TypeTableEntryIdNamespace:
15507		case TypeTableEntryIdBoundFn:
15508		case TypeTableEntryIdPromise:
	15490	case ZigTypeIdMetaType:
	15491	case ZigTypeIdVoid:
	15492	case ZigTypeIdBool:
	15493	case ZigTypeIdInt:
	15494	case ZigTypeIdFloat:
	15495	case ZigTypeIdPointer:
	15496	case ZigTypeIdArray:
	15497	case ZigTypeIdStruct:
	15498	case ZigTypeIdComptimeFloat:
	15499	case ZigTypeIdComptimeInt:
	15500	case ZigTypeIdOptional:
	15501	case ZigTypeIdErrorUnion:
	15502	case ZigTypeIdErrorSet:
	15503	case ZigTypeIdEnum:
	15504	case ZigTypeIdUnion:
	15505	case ZigTypeIdFn:
	15506	case ZigTypeIdNamespace:
	15507	case ZigTypeIdBoundFn:
	15508	case ZigTypeIdPromise:
15509	15509	{
15510	15510	if ((err = type_ensure_zero_bits_known(ira->codegen, child_type)))
15511	15511	return ira->codegen->builtin_types.entry_invalid;
...	...	@@ -15587,36 +15587,36 @@ static ZigType ir_analyze_instruction_array_type(IrAnalyze ira,
15587	15587	if (type_is_invalid(child_type))
15588	15588	return ira->codegen->builtin_types.entry_invalid;
15589	15589	switch (child_type->id) {
15590		case TypeTableEntryIdInvalid: // handled above
	15590	case ZigTypeIdInvalid: // handled above
15591	15591	zig_unreachable();
15592		case TypeTableEntryIdUnreachable:
15593		case TypeTableEntryIdUndefined:
15594		case TypeTableEntryIdNull:
15595		case TypeTableEntryIdBlock:
15596		case TypeTableEntryIdArgTuple:
15597		case TypeTableEntryIdOpaque:
	15592	case ZigTypeIdUnreachable:
	15593	case ZigTypeIdUndefined:
	15594	case ZigTypeIdNull:
	15595	case ZigTypeIdBlock:
	15596	case ZigTypeIdArgTuple:
	15597	case ZigTypeIdOpaque:
15598	15598	ir_add_error_node(ira, array_type_instruction->base.source_node,
15599	15599	buf_sprintf("array of type '%s' not allowed", buf_ptr(&child_type->name)));
15600	15600	return ira->codegen->builtin_types.entry_invalid;
15601		case TypeTableEntryIdMetaType:
15602		case TypeTableEntryIdVoid:
15603		case TypeTableEntryIdBool:
15604		case TypeTableEntryIdInt:
15605		case TypeTableEntryIdFloat:
15606		case TypeTableEntryIdPointer:
15607		case TypeTableEntryIdArray:
15608		case TypeTableEntryIdStruct:
15609		case TypeTableEntryIdComptimeFloat:
15610		case TypeTableEntryIdComptimeInt:
15611		case TypeTableEntryIdOptional:
15612		case TypeTableEntryIdErrorUnion:
15613		case TypeTableEntryIdErrorSet:
15614		case TypeTableEntryIdEnum:
15615		case TypeTableEntryIdUnion:
15616		case TypeTableEntryIdFn:
15617		case TypeTableEntryIdNamespace:
15618		case TypeTableEntryIdBoundFn:
15619		case TypeTableEntryIdPromise:
	15601	case ZigTypeIdMetaType:
	15602	case ZigTypeIdVoid:
	15603	case ZigTypeIdBool:
	15604	case ZigTypeIdInt:
	15605	case ZigTypeIdFloat:
	15606	case ZigTypeIdPointer:
	15607	case ZigTypeIdArray:
	15608	case ZigTypeIdStruct:
	15609	case ZigTypeIdComptimeFloat:
	15610	case ZigTypeIdComptimeInt:
	15611	case ZigTypeIdOptional:
	15612	case ZigTypeIdErrorUnion:
	15613	case ZigTypeIdErrorSet:
	15614	case ZigTypeIdEnum:
	15615	case ZigTypeIdUnion:
	15616	case ZigTypeIdFn:
	15617	case ZigTypeIdNamespace:
	15618	case ZigTypeIdBoundFn:
	15619	case ZigTypeIdPromise:
15620	15620	{
15621	15621	if ((err = ensure_complete_type(ira->codegen, child_type)))
15622	15622	return ira->codegen->builtin_types.entry_invalid;
...	...	@@ -15658,36 +15658,36 @@ static ZigType ir_analyze_instruction_size_of(IrAnalyze ira,
15658	15658	return ira->codegen->builtin_types.entry_invalid;
15659	15659
15660	15660	switch (type_entry->id) {
15661		case TypeTableEntryIdInvalid: // handled above
	15661	case ZigTypeIdInvalid: // handled above
15662	15662	zig_unreachable();
15663		case TypeTableEntryIdUnreachable:
15664		case TypeTableEntryIdUndefined:
15665		case TypeTableEntryIdNull:
15666		case TypeTableEntryIdBlock:
15667		case TypeTableEntryIdComptimeFloat:
15668		case TypeTableEntryIdComptimeInt:
15669		case TypeTableEntryIdBoundFn:
15670		case TypeTableEntryIdMetaType:
15671		case TypeTableEntryIdNamespace:
15672		case TypeTableEntryIdArgTuple:
15673		case TypeTableEntryIdOpaque:
	15663	case ZigTypeIdUnreachable:
	15664	case ZigTypeIdUndefined:
	15665	case ZigTypeIdNull:
	15666	case ZigTypeIdBlock:
	15667	case ZigTypeIdComptimeFloat:
	15668	case ZigTypeIdComptimeInt:
	15669	case ZigTypeIdBoundFn:
	15670	case ZigTypeIdMetaType:
	15671	case ZigTypeIdNamespace:
	15672	case ZigTypeIdArgTuple:
	15673	case ZigTypeIdOpaque:
15674	15674	ir_add_error_node(ira, size_of_instruction->base.source_node,
15675	15675	buf_sprintf("no size available for type '%s'", buf_ptr(&type_entry->name)));
15676	15676	return ira->codegen->builtin_types.entry_invalid;
15677		case TypeTableEntryIdVoid:
15678		case TypeTableEntryIdBool:
15679		case TypeTableEntryIdInt:
15680		case TypeTableEntryIdFloat:
15681		case TypeTableEntryIdPointer:
15682		case TypeTableEntryIdArray:
15683		case TypeTableEntryIdStruct:
15684		case TypeTableEntryIdOptional:
15685		case TypeTableEntryIdErrorUnion:
15686		case TypeTableEntryIdErrorSet:
15687		case TypeTableEntryIdEnum:
15688		case TypeTableEntryIdUnion:
15689		case TypeTableEntryIdFn:
15690		case TypeTableEntryIdPromise:
	15677	case ZigTypeIdVoid:
	15678	case ZigTypeIdBool:
	15679	case ZigTypeIdInt:
	15680	case ZigTypeIdFloat:
	15681	case ZigTypeIdPointer:
	15682	case ZigTypeIdArray:
	15683	case ZigTypeIdStruct:
	15684	case ZigTypeIdOptional:
	15685	case ZigTypeIdErrorUnion:
	15686	case ZigTypeIdErrorSet:
	15687	case ZigTypeIdEnum:
	15688	case ZigTypeIdUnion:
	15689	case ZigTypeIdFn:
	15690	case ZigTypeIdPromise:
15691	15691	{
15692	15692	uint64_t size_in_bytes = type_size(ira->codegen, type_entry);
15693	15693	ConstExprValue *out_val = ir_build_const_from(ira, &size_of_instruction->base);
...	...	@@ -15705,7 +15705,7 @@ static ZigType ir_analyze_instruction_test_non_null(IrAnalyze ira, IrInstructi
15705	15705
15706	15706	ZigType *type_entry = value->value.type;
15707	15707
15708		if (type_entry->id == TypeTableEntryIdOptional) {
	15708	if (type_entry->id == ZigTypeIdOptional) {
15709	15709	if (instr_is_comptime(value)) {
15710	15710	ConstExprValue *maybe_val = ir_resolve_const(ira, value, UndefBad);
15711	15711	if (!maybe_val)
...	...	@@ -15718,7 +15718,7 @@ static ZigType ir_analyze_instruction_test_non_null(IrAnalyze ira, IrInstructi
15718	15718
15719	15719	ir_build_test_nonnull_from(&ira->new_irb, &instruction->base, value);
15720	15720	return ira->codegen->builtin_types.entry_bool;
15721		} else if (type_entry->id == TypeTableEntryIdNull) {
	15721	} else if (type_entry->id == ZigTypeIdNull) {
15722	15722	ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
15723	15723	out_val->data.x_bool = false;
15724	15724	return ira->codegen->builtin_types.entry_bool;
...	...	@@ -15737,12 +15737,12 @@ static ZigType ir_analyze_instruction_unwrap_maybe(IrAnalyze ira,
15737	15737	return ira->codegen->builtin_types.entry_invalid;
15738	15738
15739	15739	ZigType *ptr_type = value->value.type;
15740		assert(ptr_type->id == TypeTableEntryIdPointer);
	15740	assert(ptr_type->id == ZigTypeIdPointer);
15741	15741
15742	15742	ZigType *type_entry = ptr_type->data.pointer.child_type;
15743	15743	if (type_is_invalid(type_entry)) {
15744	15744	return ira->codegen->builtin_types.entry_invalid;
15745		} else if (type_entry->id != TypeTableEntryIdOptional) {
	15745	} else if (type_entry->id != ZigTypeIdOptional) {
15746	15746	ir_add_error_node(ira, unwrap_maybe_instruction->value->source_node,
15747	15747	buf_sprintf("expected optional type, found '%s'", buf_ptr(&type_entry->name)));
15748	15748	return ira->codegen->builtin_types.entry_invalid;
...	...	@@ -15787,7 +15787,7 @@ static ZigType ir_analyze_instruction_ctz(IrAnalyze ira, IrInstructionCtz *ctz
15787	15787	IrInstruction *value = ctz_instruction->value->other;
15788	15788	if (type_is_invalid(value->value.type)) {
15789	15789	return ira->codegen->builtin_types.entry_invalid;
15790		} else if (value->value.type->id == TypeTableEntryIdInt) {
	15790	} else if (value->value.type->id == ZigTypeIdInt) {
15791	15791	ZigType *return_type = get_smallest_unsigned_int_type(ira->codegen,
15792	15792	value->value.type->data.integral.bit_count);
15793	15793	if (value->value.special != ConstValSpecialRuntime) {
...	...	@@ -15811,7 +15811,7 @@ static ZigType ir_analyze_instruction_clz(IrAnalyze ira, IrInstructionClz *clz
15811	15811	IrInstruction *value = clz_instruction->value->other;
15812	15812	if (type_is_invalid(value->value.type)) {
15813	15813	return ira->codegen->builtin_types.entry_invalid;
15814		} else if (value->value.type->id == TypeTableEntryIdInt) {
	15814	} else if (value->value.type->id == ZigTypeIdInt) {
15815	15815	ZigType *return_type = get_smallest_unsigned_int_type(ira->codegen,
15816	15816	value->value.type->data.integral.bit_count);
15817	15817	if (value->value.special != ConstValSpecialRuntime) {
...	...	@@ -15836,7 +15836,7 @@ static ZigType ir_analyze_instruction_pop_count(IrAnalyze ira, IrInstructionPo
15836	15836	if (type_is_invalid(value->value.type))
15837	15837	return ira->codegen->builtin_types.entry_invalid;
15838	15838
15839		if (value->value.type->id != TypeTableEntryIdInt && value->value.type->id != TypeTableEntryIdComptimeInt) {
	15839	if (value->value.type->id != ZigTypeIdInt && value->value.type->id != ZigTypeIdComptimeInt) {
15840	15840	ir_add_error(ira, value,
15841	15841	buf_sprintf("expected integer type, found '%s'", buf_ptr(&value->value.type->name)));
15842	15842	return ira->codegen->builtin_types.entry_invalid;
...	...	@@ -15852,7 +15852,7 @@ static ZigType ir_analyze_instruction_pop_count(IrAnalyze ira, IrInstructionPo
15852	15852	bigint_init_unsigned(&out_val->data.x_bigint, result);
15853	15853	return ira->codegen->builtin_types.entry_num_lit_int;
15854	15854	}
15855		if (value->value.type->id == TypeTableEntryIdComptimeInt) {
	15855	if (value->value.type->id == ZigTypeIdComptimeInt) {
15856	15856	Buf *val_buf = buf_alloc();
15857	15857	bigint_append_buf(val_buf, &val->data.x_bigint, 10);
15858	15858	ir_add_error(ira, &instruction->base,
...	...	@@ -15877,11 +15877,11 @@ static IrInstruction ir_analyze_union_tag(IrAnalyze ira, IrInstruction *source
15877	15877	if (type_is_invalid(value->value.type))
15878	15878	return ira->codegen->invalid_instruction;
15879	15879
15880		if (value->value.type->id == TypeTableEntryIdEnum) {
	15880	if (value->value.type->id == ZigTypeIdEnum) {
15881	15881	return value;
15882	15882	}
15883	15883
15884		if (value->value.type->id != TypeTableEntryIdUnion) {
	15884	if (value->value.type->id != ZigTypeIdUnion) {
15885	15885	ir_add_error(ira, value,
15886	15886	buf_sprintf("expected enum or union type, found '%s'", buf_ptr(&value->value.type->name)));
15887	15887	return ira->codegen->invalid_instruction;
...	...	@@ -15896,7 +15896,7 @@ static IrInstruction ir_analyze_union_tag(IrAnalyze ira, IrInstruction *source
15896	15896	}
15897	15897
15898	15898	ZigType *tag_type = value->value.type->data.unionation.tag_type;
15899		assert(tag_type->id == TypeTableEntryIdEnum);
	15899	assert(tag_type->id == ZigTypeIdEnum);
15900	15900
15901	15901	if (instr_is_comptime(value)) {
15902	15902	ConstExprValue *val = ir_resolve_const(ira, value, UndefBad);
...	...	@@ -15948,7 +15948,7 @@ static ZigType ir_analyze_instruction_switch_br(IrAnalyze ira,
15948	15948	if (type_is_invalid(case_value->value.type))
15949	15949	return ir_unreach_error(ira);
15950	15950
15951		if (case_value->value.type->id == TypeTableEntryIdEnum) {
	15951	if (case_value->value.type->id == ZigTypeIdEnum) {
15952	15952	case_value = ir_analyze_union_tag(ira, &switch_br_instruction->base, case_value);
15953	15953	if (type_is_invalid(case_value->value.type))
15954	15954	return ir_unreach_error(ira);
...	...	@@ -15995,7 +15995,7 @@ static ZigType ir_analyze_instruction_switch_br(IrAnalyze ira,
15995	15995	if (type_is_invalid(new_value->value.type))
15996	15996	continue;
15997	15997
15998		if (new_value->value.type->id == TypeTableEntryIdEnum) {
	15998	if (new_value->value.type->id == ZigTypeIdEnum) {
15999	15999	new_value = ir_analyze_union_tag(ira, &switch_br_instruction->base, new_value);
16000	16000	if (type_is_invalid(new_value->value.type))
16001	16001	continue;
...	...	@@ -16032,17 +16032,17 @@ static ZigType ir_analyze_instruction_switch_target(IrAnalyze ira,
16032	16032	if (type_is_invalid(target_value_ptr->value.type))
16033	16033	return ira->codegen->builtin_types.entry_invalid;
16034	16034
16035		if (target_value_ptr->value.type->id == TypeTableEntryIdMetaType) {
	16035	if (target_value_ptr->value.type->id == ZigTypeIdMetaType) {
16036	16036	assert(instr_is_comptime(target_value_ptr));
16037	16037	ZigType *ptr_type = target_value_ptr->value.data.x_type;
16038		assert(ptr_type->id == TypeTableEntryIdPointer);
	16038	assert(ptr_type->id == ZigTypeIdPointer);
16039	16039	ConstExprValue *out_val = ir_build_const_from(ira, &switch_target_instruction->base);
16040	16040	out_val->type = ira->codegen->builtin_types.entry_type;
16041	16041	out_val->data.x_type = ptr_type->data.pointer.child_type;
16042	16042	return out_val->type;
16043	16043	}
16044	16044
16045		if (target_value_ptr->value.type->id != TypeTableEntryIdPointer) {
	16045	if (target_value_ptr->value.type->id != ZigTypeIdPointer) {
16046	16046	ir_add_error(ira, target_value_ptr, buf_sprintf("invalid deref on switch target"));
16047	16047	return ira->codegen->builtin_types.entry_invalid;
16048	16048	}
...	...	@@ -16061,20 +16061,20 @@ static ZigType ir_analyze_instruction_switch_target(IrAnalyze ira,
16061	16061	return ira->codegen->builtin_types.entry_invalid;
16062	16062
16063	16063	switch (target_type->id) {
16064		case TypeTableEntryIdInvalid:
	16064	case ZigTypeIdInvalid:
16065	16065	zig_unreachable();
16066		case TypeTableEntryIdMetaType:
16067		case TypeTableEntryIdVoid:
16068		case TypeTableEntryIdBool:
16069		case TypeTableEntryIdInt:
16070		case TypeTableEntryIdFloat:
16071		case TypeTableEntryIdComptimeFloat:
16072		case TypeTableEntryIdComptimeInt:
16073		case TypeTableEntryIdPointer:
16074		case TypeTableEntryIdPromise:
16075		case TypeTableEntryIdFn:
16076		case TypeTableEntryIdNamespace:
16077		case TypeTableEntryIdErrorSet:
	16066	case ZigTypeIdMetaType:
	16067	case ZigTypeIdVoid:
	16068	case ZigTypeIdBool:
	16069	case ZigTypeIdInt:
	16070	case ZigTypeIdFloat:
	16071	case ZigTypeIdComptimeFloat:
	16072	case ZigTypeIdComptimeInt:
	16073	case ZigTypeIdPointer:
	16074	case ZigTypeIdPromise:
	16075	case ZigTypeIdFn:
	16076	case ZigTypeIdNamespace:
	16077	case ZigTypeIdErrorSet:
16078	16078	if (pointee_val) {
16079	16079	ConstExprValue *out_val = ir_build_const_from(ira, &switch_target_instruction->base);
16080	16080	copy_const_val(out_val, pointee_val, true);
...	...	@@ -16084,7 +16084,7 @@ static ZigType ir_analyze_instruction_switch_target(IrAnalyze ira,
16084	16084
16085	16085	ir_build_load_ptr_from(&ira->new_irb, &switch_target_instruction->base, target_value_ptr);
16086	16086	return target_type;
16087		case TypeTableEntryIdUnion: {
	16087	case ZigTypeIdUnion: {
16088	16088	AstNode *decl_node = target_type->data.unionation.decl_node;
16089	16089	if (!decl_node->data.container_decl.auto_enum &&
16090	16090	decl_node->data.container_decl.init_arg_expr == nullptr)
...	...	@@ -16097,7 +16097,7 @@ static ZigType ir_analyze_instruction_switch_target(IrAnalyze ira,
16097	16097	}
16098	16098	ZigType *tag_type = target_type->data.unionation.tag_type;
16099	16099	assert(tag_type != nullptr);
16100		assert(tag_type->id == TypeTableEntryIdEnum);
	16100	assert(tag_type->id == ZigTypeIdEnum);
16101	16101	if (pointee_val) {
16102	16102	ConstExprValue *out_val = ir_build_const_from(ira, &switch_target_instruction->base);
16103	16103	bigint_init_bigint(&out_val->data.x_enum_tag, &pointee_val->data.x_union.tag);
...	...	@@ -16120,7 +16120,7 @@ static ZigType ir_analyze_instruction_switch_target(IrAnalyze ira,
16120	16120	ir_link_new_instruction(union_tag_inst, &switch_target_instruction->base);
16121	16121	return tag_type;
16122	16122	}
16123		case TypeTableEntryIdEnum: {
	16123	case ZigTypeIdEnum: {
16124	16124	if ((err = type_ensure_zero_bits_known(ira->codegen, target_type)))
16125	16125	return ira->codegen->builtin_types.entry_invalid;
16126	16126	if (target_type->data.enumeration.src_field_count < 2) {
...	...	@@ -16142,17 +16142,17 @@ static ZigType ir_analyze_instruction_switch_target(IrAnalyze ira,
16142	16142	ir_link_new_instruction(enum_value, &switch_target_instruction->base);
16143	16143	return target_type;
16144	16144	}
16145		case TypeTableEntryIdErrorUnion:
16146		case TypeTableEntryIdUnreachable:
16147		case TypeTableEntryIdArray:
16148		case TypeTableEntryIdStruct:
16149		case TypeTableEntryIdUndefined:
16150		case TypeTableEntryIdNull:
16151		case TypeTableEntryIdOptional:
16152		case TypeTableEntryIdBlock:
16153		case TypeTableEntryIdBoundFn:
16154		case TypeTableEntryIdArgTuple:
16155		case TypeTableEntryIdOpaque:
	16145	case ZigTypeIdErrorUnion:
	16146	case ZigTypeIdUnreachable:
	16147	case ZigTypeIdArray:
	16148	case ZigTypeIdStruct:
	16149	case ZigTypeIdUndefined:
	16150	case ZigTypeIdNull:
	16151	case ZigTypeIdOptional:
	16152	case ZigTypeIdBlock:
	16153	case ZigTypeIdBoundFn:
	16154	case ZigTypeIdArgTuple:
	16155	case ZigTypeIdOpaque:
16156	16156	ir_add_error(ira, &switch_target_instruction->base,
16157	16157	buf_sprintf("invalid switch target type '%s'", buf_ptr(&target_type->name)));
16158	16158	return ira->codegen->builtin_types.entry_invalid;
...	...	@@ -16169,14 +16169,14 @@ static ZigType ir_analyze_instruction_switch_var(IrAnalyze ira, IrInstructionS
16169	16169	if (type_is_invalid(prong_value->value.type))
16170	16170	return ira->codegen->builtin_types.entry_invalid;
16171	16171
16172		assert(target_value_ptr->value.type->id == TypeTableEntryIdPointer);
	16172	assert(target_value_ptr->value.type->id == ZigTypeIdPointer);
16173	16173	ZigType *target_type = target_value_ptr->value.type->data.pointer.child_type;
16174		if (target_type->id == TypeTableEntryIdUnion) {
	16174	if (target_type->id == ZigTypeIdUnion) {
16175	16175	ConstExprValue *prong_val = ir_resolve_const(ira, prong_value, UndefBad);
16176	16176	if (!prong_val)
16177	16177	return ira->codegen->builtin_types.entry_invalid;
16178	16178
16179		assert(prong_value->value.type->id == TypeTableEntryIdEnum);
	16179	assert(prong_value->value.type->id == ZigTypeIdEnum);
16180	16180	TypeUnionField *field = find_union_field_by_tag(target_type, &prong_val->data.x_enum_tag);
16181	16181
16182	16182	if (instr_is_comptime(target_value_ptr)) {
...	...	@@ -16285,7 +16285,7 @@ static ZigType ir_analyze_instruction_array_len(IrAnalyze ira,
16285	16285	ZigType *type_entry = array_value->value.type;
16286	16286	if (type_is_invalid(type_entry)) {
16287	16287	return ira->codegen->builtin_types.entry_invalid;
16288		} else if (type_entry->id == TypeTableEntryIdArray) {
	16288	} else if (type_entry->id == ZigTypeIdArray) {
16289	16289	return ir_analyze_const_usize(ira, &array_len_instruction->base,
16290	16290	type_entry->data.array.len);
16291	16291	} else if (is_slice(type_entry)) {
...	...	@@ -16318,7 +16318,7 @@ static ZigType ir_analyze_container_init_fields_union(IrAnalyze ira, IrInstruc
16318	16318	ZigType container_type, size_t instr_field_count, IrInstructionContainerInitFieldsField fields)
16319	16319	{
16320	16320	Error err;
16321		assert(container_type->id == TypeTableEntryIdUnion);
	16321	assert(container_type->id == ZigTypeIdUnion);
16322	16322
16323	16323	if ((err = ensure_complete_type(ira->codegen, container_type)))
16324	16324	return ira->codegen->builtin_types.entry_invalid;
...	...	@@ -16384,10 +16384,10 @@ static ZigType ir_analyze_container_init_fields(IrAnalyze ira, IrInstruction *
16384	16384	ZigType container_type, size_t instr_field_count, IrInstructionContainerInitFieldsField fields)
16385	16385	{
16386	16386	Error err;
16387		if (container_type->id == TypeTableEntryIdUnion) {
	16387	if (container_type->id == ZigTypeIdUnion) {
16388	16388	return ir_analyze_container_init_fields_union(ira, instruction, container_type, instr_field_count, fields);
16389	16389	}
16390		if (container_type->id != TypeTableEntryIdStruct \|\| is_slice(container_type)) {
	16390	if (container_type->id != ZigTypeIdStruct \|\| is_slice(container_type)) {
16391	16391	ir_add_error(ira, instruction,
16392	16392	buf_sprintf("type '%s' does not support struct initialization syntax",
16393	16393	buf_ptr(&container_type->name)));
...	...	@@ -16508,18 +16508,18 @@ static ZigType ir_analyze_instruction_container_init_list(IrAnalyze ira,
16508	16508	return ira->codegen->builtin_types.entry_invalid;
16509	16509
16510	16510	size_t elem_count = instruction->item_count;
16511		if (container_type_value->value.type->id == TypeTableEntryIdMetaType) {
	16511	if (container_type_value->value.type->id == ZigTypeIdMetaType) {
16512	16512	ZigType *container_type = ir_resolve_type(ira, container_type_value);
16513	16513	if (type_is_invalid(container_type))
16514	16514	return ira->codegen->builtin_types.entry_invalid;
16515	16515
16516		if (container_type->id == TypeTableEntryIdStruct && !is_slice(container_type) && elem_count == 0) {
	16516	if (container_type->id == ZigTypeIdStruct && !is_slice(container_type) && elem_count == 0) {
16517	16517	return ir_analyze_container_init_fields(ira, &instruction->base, container_type,
16518	16518	0, nullptr);
16519		} else if (is_slice(container_type) \|\| container_type->id == TypeTableEntryIdArray) {
	16519	} else if (is_slice(container_type) \|\| container_type->id == ZigTypeIdArray) {
16520	16520	// array is same as slice init but we make a compile error if the length is wrong
16521	16521	ZigType *child_type;
16522		if (container_type->id == TypeTableEntryIdArray) {
	16522	if (container_type->id == ZigTypeIdArray) {
16523	16523	child_type = container_type->data.array.child_type;
16524	16524	if (container_type->data.array.len != elem_count) {
16525	16525	ZigType *literal_type = get_array_type(ira->codegen, child_type, elem_count);
...	...	@@ -16531,7 +16531,7 @@ static ZigType ir_analyze_instruction_container_init_list(IrAnalyze ira,
16531	16531	}
16532	16532	} else {
16533	16533	ZigType *pointer_type = container_type->data.structure.fields[slice_ptr_index].type_entry;
16534		assert(pointer_type->id == TypeTableEntryIdPointer);
	16534	assert(pointer_type->id == ZigTypeIdPointer);
16535	16535	child_type = pointer_type->data.pointer.child_type;
16536	16536	}
16537	16537
...	...	@@ -16598,7 +16598,7 @@ static ZigType ir_analyze_instruction_container_init_list(IrAnalyze ira,
16598	16598	container_type_value, elem_count, new_items);
16599	16599	ir_add_alloca(ira, new_instruction, fixed_size_array_type);
16600	16600	return fixed_size_array_type;
16601		} else if (container_type->id == TypeTableEntryIdVoid) {
	16601	} else if (container_type->id == ZigTypeIdVoid) {
16602	16602	if (elem_count != 0) {
16603	16603	ir_add_error_node(ira, instruction->base.source_node,
16604	16604	buf_sprintf("void expression expects no arguments"));
...	...	@@ -16635,43 +16635,43 @@ static ZigType ir_analyze_min_max(IrAnalyze ira, IrInstruction *source_instruc
16635	16635	if (type_is_invalid(target_type))
16636	16636	return ira->codegen->builtin_types.entry_invalid;
16637	16637	switch (target_type->id) {
16638		case TypeTableEntryIdInvalid:
	16638	case ZigTypeIdInvalid:
16639	16639	zig_unreachable();
16640		case TypeTableEntryIdInt:
	16640	case ZigTypeIdInt:
16641	16641	{
16642	16642	ConstExprValue *out_val = ir_build_const_from(ira, source_instruction);
16643	16643	eval_min_max_value(ira->codegen, target_type, out_val, is_max);
16644	16644	return ira->codegen->builtin_types.entry_num_lit_int;
16645	16645	}
16646		case TypeTableEntryIdBool:
16647		case TypeTableEntryIdVoid:
	16646	case ZigTypeIdBool:
	16647	case ZigTypeIdVoid:
16648	16648	{
16649	16649	ConstExprValue *out_val = ir_build_const_from(ira, source_instruction);
16650	16650	eval_min_max_value(ira->codegen, target_type, out_val, is_max);
16651	16651	return target_type;
16652	16652	}
16653		case TypeTableEntryIdEnum:
16654		case TypeTableEntryIdFloat:
16655		case TypeTableEntryIdMetaType:
16656		case TypeTableEntryIdUnreachable:
16657		case TypeTableEntryIdPointer:
16658		case TypeTableEntryIdPromise:
16659		case TypeTableEntryIdArray:
16660		case TypeTableEntryIdStruct:
16661		case TypeTableEntryIdComptimeFloat:
16662		case TypeTableEntryIdComptimeInt:
16663		case TypeTableEntryIdUndefined:
16664		case TypeTableEntryIdNull:
16665		case TypeTableEntryIdOptional:
16666		case TypeTableEntryIdErrorUnion:
16667		case TypeTableEntryIdErrorSet:
16668		case TypeTableEntryIdUnion:
16669		case TypeTableEntryIdFn:
16670		case TypeTableEntryIdNamespace:
16671		case TypeTableEntryIdBlock:
16672		case TypeTableEntryIdBoundFn:
16673		case TypeTableEntryIdArgTuple:
16674		case TypeTableEntryIdOpaque:
	16653	case ZigTypeIdEnum:
	16654	case ZigTypeIdFloat:
	16655	case ZigTypeIdMetaType:
	16656	case ZigTypeIdUnreachable:
	16657	case ZigTypeIdPointer:
	16658	case ZigTypeIdPromise:
	16659	case ZigTypeIdArray:
	16660	case ZigTypeIdStruct:
	16661	case ZigTypeIdComptimeFloat:
	16662	case ZigTypeIdComptimeInt:
	16663	case ZigTypeIdUndefined:
	16664	case ZigTypeIdNull:
	16665	case ZigTypeIdOptional:
	16666	case ZigTypeIdErrorUnion:
	16667	case ZigTypeIdErrorSet:
	16668	case ZigTypeIdUnion:
	16669	case ZigTypeIdFn:
	16670	case ZigTypeIdNamespace:
	16671	case ZigTypeIdBlock:
	16672	case ZigTypeIdBoundFn:
	16673	case ZigTypeIdArgTuple:
	16674	case ZigTypeIdOpaque:
16675	16675	{
16676	16676	const char *err_format = is_max ?
16677	16677	"no max value available for type '%s'" :
...	...	@@ -16774,7 +16774,7 @@ static ZigType ir_analyze_instruction_enum_tag_name(IrAnalyze ira, IrInstructi
16774	16774	if (type_is_invalid(target->value.type))
16775	16775	return ira->codegen->builtin_types.entry_invalid;
16776	16776
16777		assert(target->value.type->id == TypeTableEntryIdEnum);
	16777	assert(target->value.type->id == ZigTypeIdEnum);
16778	16778
16779	16779	if (instr_is_comptime(target)) {
16780	16780	if ((err = type_ensure_zero_bits_known(ira->codegen, target->value.type)))
...	...	@@ -16816,7 +16816,7 @@ static ZigType ir_analyze_instruction_field_parent_ptr(IrAnalyze ira,
16816	16816	if (type_is_invalid(field_ptr->value.type))
16817	16817	return ira->codegen->builtin_types.entry_invalid;
16818	16818
16819		if (container_type->id != TypeTableEntryIdStruct) {
	16819	if (container_type->id != ZigTypeIdStruct) {
16820	16820	ir_add_error(ira, type_value,
16821	16821	buf_sprintf("expected struct type, found '%s'", buf_ptr(&container_type->name)));
16822	16822	return ira->codegen->builtin_types.entry_invalid;
...	...	@@ -16833,7 +16833,7 @@ static ZigType ir_analyze_instruction_field_parent_ptr(IrAnalyze ira,
16833	16833	return ira->codegen->builtin_types.entry_invalid;
16834	16834	}
16835	16835
16836		if (field_ptr->value.type->id != TypeTableEntryIdPointer) {
	16836	if (field_ptr->value.type->id != ZigTypeIdPointer) {
16837	16837	ir_add_error(ira, field_ptr,
16838	16838	buf_sprintf("expected pointer, found '%s'", buf_ptr(&field_ptr->value.type->name)));
16839	16839	return ira->codegen->builtin_types.entry_invalid;
...	...	@@ -16908,7 +16908,7 @@ static ZigType ir_analyze_instruction_offset_of(IrAnalyze ira,
16908	16908	if (!field_name)
16909	16909	return ira->codegen->builtin_types.entry_invalid;
16910	16910
16911		if (container_type->id != TypeTableEntryIdStruct) {
	16911	if (container_type->id != ZigTypeIdStruct) {
16912	16912	ir_add_error(ira, type_value,
16913	16913	buf_sprintf("expected struct type, found '%s'", buf_ptr(&container_type->name)));
16914	16914	return ira->codegen->builtin_types.entry_invalid;
...	...	@@ -16951,11 +16951,11 @@ static ZigType ir_type_info_get_type(IrAnalyze ira, const char *type_name, Zig
16951	16951	static ZigType *type_info_type = nullptr;
16952	16952	if (type_info_var == nullptr) {
16953	16953	type_info_var = get_builtin_value(ira->codegen, "TypeInfo");
16954		assert(type_info_var->type->id == TypeTableEntryIdMetaType);
	16954	assert(type_info_var->type->id == ZigTypeIdMetaType);
16955	16955
16956	16956	assertNoError(ensure_complete_type(ira->codegen, type_info_var->data.x_type));
16957	16957	type_info_type = type_info_var->data.x_type;
16958		assert(type_info_type->id == TypeTableEntryIdUnion);
	16958	assert(type_info_type->id == ZigTypeIdUnion);
16959	16959	}
16960	16960
16961	16961	if (type_name == nullptr && root == nullptr)
...	...	@@ -16980,7 +16980,7 @@ static ZigType ir_type_info_get_type(IrAnalyze ira, const char *type_name, Zig
16980	16980
16981	16981	if ((err = ensure_complete_type(ira->codegen, var->value->type)))
16982	16982	return ira->codegen->builtin_types.entry_invalid;
16983		assert(var->value->type->id == TypeTableEntryIdMetaType);
	16983	assert(var->value->type->id == ZigTypeIdMetaType);
16984	16984	return var->value->data.x_type;
16985	16985	}
16986	16986
...	...	@@ -17078,7 +17078,7 @@ static Error ir_make_type_info_defs(IrAnalyze ira, ConstExprValue out_val, Sco
17078	17078	if ((err = ensure_complete_type(ira->codegen, var->value->type)))
17079	17079	return ErrorSemanticAnalyzeFail;
17080	17080
17081		if (var->value->type->id == TypeTableEntryIdMetaType)
	17081	if (var->value->type->id == ZigTypeIdMetaType)
17082	17082	{
17083	17083	// We have a variable of type 'type', so it's actually a type definition.
17084	17084	// 0: Data.Type: type
...	...	@@ -17238,7 +17238,7 @@ static ConstExprValue create_ptr_like_type_info(IrAnalyze ira, ZigType *ptr_ty
17238	17238	if (is_slice(ptr_type_entry)) {
17239	17239	attrs_type = ptr_type_entry->data.structure.fields[slice_ptr_index].type_entry;
17240	17240	size_enum_index = 2;
17241		} else if (ptr_type_entry->id == TypeTableEntryIdPointer) {
	17241	} else if (ptr_type_entry->id == ZigTypeIdPointer) {
17242	17242	attrs_type = ptr_type_entry;
17243	17243	size_enum_index = (ptr_type_entry->data.pointer.ptr_len == PtrLenSingle) ? 0 : 1;
17244	17244	} else {
...	...	@@ -17320,20 +17320,20 @@ static Error ir_make_type_info_value(IrAnalyze ira, ZigType type_entry, ConstE
17320	17320	ConstExprValue *result = nullptr;
17321	17321	switch (type_entry->id)
17322	17322	{
17323		case TypeTableEntryIdInvalid:
	17323	case ZigTypeIdInvalid:
17324	17324	zig_unreachable();
17325		case TypeTableEntryIdMetaType:
17326		case TypeTableEntryIdVoid:
17327		case TypeTableEntryIdBool:
17328		case TypeTableEntryIdUnreachable:
17329		case TypeTableEntryIdComptimeFloat:
17330		case TypeTableEntryIdComptimeInt:
17331		case TypeTableEntryIdUndefined:
17332		case TypeTableEntryIdNull:
17333		case TypeTableEntryIdNamespace:
17334		case TypeTableEntryIdBlock:
17335		case TypeTableEntryIdArgTuple:
17336		case TypeTableEntryIdOpaque:
	17325	case ZigTypeIdMetaType:
	17326	case ZigTypeIdVoid:
	17327	case ZigTypeIdBool:
	17328	case ZigTypeIdUnreachable:
	17329	case ZigTypeIdComptimeFloat:
	17330	case ZigTypeIdComptimeInt:
	17331	case ZigTypeIdUndefined:
	17332	case ZigTypeIdNull:
	17333	case ZigTypeIdNamespace:
	17334	case ZigTypeIdBlock:
	17335	case ZigTypeIdArgTuple:
	17336	case ZigTypeIdOpaque:
17337	17337	*out = nullptr;
17338	17338	return ErrorNone;
17339	17339	default:
...	...	@@ -17347,7 +17347,7 @@ static Error ir_make_type_info_value(IrAnalyze ira, ZigType type_entry, ConstE
17347	17347
17348	17348	// Fallthrough if we don't find one.
17349	17349	}
17350		case TypeTableEntryIdInt:
	17350	case ZigTypeIdInt:
17351	17351	{
17352	17352	result = create_const_vals(1);
17353	17353	result->special = ConstValSpecialStatic;
...	...	@@ -17369,7 +17369,7 @@ static Error ir_make_type_info_value(IrAnalyze ira, ZigType type_entry, ConstE
17369	17369
17370	17370	break;
17371	17371	}
17372		case TypeTableEntryIdFloat:
	17372	case ZigTypeIdFloat:
17373	17373	{
17374	17374	result = create_const_vals(1);
17375	17375	result->special = ConstValSpecialStatic;
...	...	@@ -17386,12 +17386,12 @@ static Error ir_make_type_info_value(IrAnalyze ira, ZigType type_entry, ConstE
17386	17386
17387	17387	break;
17388	17388	}
17389		case TypeTableEntryIdPointer:
	17389	case ZigTypeIdPointer:
17390	17390	{
17391	17391	result = create_ptr_like_type_info(ira, type_entry);
17392	17392	break;
17393	17393	}
17394		case TypeTableEntryIdArray:
	17394	case ZigTypeIdArray:
17395	17395	{
17396	17396	result = create_const_vals(1);
17397	17397	result->special = ConstValSpecialStatic;
...	...	@@ -17413,7 +17413,7 @@ static Error ir_make_type_info_value(IrAnalyze ira, ZigType type_entry, ConstE
17413	17413
17414	17414	break;
17415	17415	}
17416		case TypeTableEntryIdOptional:
	17416	case ZigTypeIdOptional:
17417	17417	{
17418	17418	result = create_const_vals(1);
17419	17419	result->special = ConstValSpecialStatic;
...	...	@@ -17430,7 +17430,7 @@ static Error ir_make_type_info_value(IrAnalyze ira, ZigType type_entry, ConstE
17430	17430
17431	17431	break;
17432	17432	}
17433		case TypeTableEntryIdPromise:
	17433	case ZigTypeIdPromise:
17434	17434	{
17435	17435	result = create_const_vals(1);
17436	17436	result->special = ConstValSpecialStatic;
...	...	@@ -17456,7 +17456,7 @@ static Error ir_make_type_info_value(IrAnalyze ira, ZigType type_entry, ConstE
17456	17456
17457	17457	break;
17458	17458	}
17459		case TypeTableEntryIdEnum:
	17459	case ZigTypeIdEnum:
17460	17460	{
17461	17461	result = create_const_vals(1);
17462	17462	result->special = ConstValSpecialStatic;
...	...	@@ -17506,7 +17506,7 @@ static Error ir_make_type_info_value(IrAnalyze ira, ZigType type_entry, ConstE
17506	17506
17507	17507	break;
17508	17508	}
17509		case TypeTableEntryIdErrorSet:
	17509	case ZigTypeIdErrorSet:
17510	17510	{
17511	17511	result = create_const_vals(1);
17512	17512	result->special = ConstValSpecialStatic;
...	...	@@ -17555,7 +17555,7 @@ static Error ir_make_type_info_value(IrAnalyze ira, ZigType type_entry, ConstE
17555	17555
17556	17556	break;
17557	17557	}
17558		case TypeTableEntryIdErrorUnion:
	17558	case ZigTypeIdErrorUnion:
17559	17559	{
17560	17560	result = create_const_vals(1);
17561	17561	result->special = ConstValSpecialStatic;
...	...	@@ -17578,7 +17578,7 @@ static Error ir_make_type_info_value(IrAnalyze ira, ZigType type_entry, ConstE
17578	17578
17579	17579	break;
17580	17580	}
17581		case TypeTableEntryIdUnion:
	17581	case ZigTypeIdUnion:
17582	17582	{
17583	17583	result = create_const_vals(1);
17584	17584	result->special = ConstValSpecialStatic;
...	...	@@ -17663,7 +17663,7 @@ static Error ir_make_type_info_value(IrAnalyze ira, ZigType type_entry, ConstE
17663	17663
17664	17664	break;
17665	17665	}
17666		case TypeTableEntryIdStruct:
	17666	case ZigTypeIdStruct:
17667	17667	{
17668	17668	if (type_entry->data.structure.is_slice) {
17669	17669	result = create_ptr_like_type_info(ira, type_entry);
...	...	@@ -17737,7 +17737,7 @@ static Error ir_make_type_info_value(IrAnalyze ira, ZigType type_entry, ConstE
17737	17737
17738	17738	break;
17739	17739	}
17740		case TypeTableEntryIdFn:
	17740	case ZigTypeIdFn:
17741	17741	{
17742	17742	result = create_const_vals(1);
17743	17743	result->special = ConstValSpecialStatic;
...	...	@@ -17842,10 +17842,10 @@ static Error ir_make_type_info_value(IrAnalyze ira, ZigType type_entry, ConstE
17842	17842
17843	17843	break;
17844	17844	}
17845		case TypeTableEntryIdBoundFn:
	17845	case ZigTypeIdBoundFn:
17846	17846	{
17847	17847	ZigType *fn_type = type_entry->data.bound_fn.fn_type;
17848		assert(fn_type->id == TypeTableEntryIdFn);
	17848	assert(fn_type->id == ZigTypeIdFn);
17849	17849	if ((err = ir_make_type_info_value(ira, fn_type, &result)))
17850	17850	return err;
17851	17851
...	...	@@ -17880,7 +17880,7 @@ static ZigType ir_analyze_instruction_type_info(IrAnalyze ira,
17880	17880	out_val->data.x_union.payload = payload;
17881	17881
17882	17882	if (payload != nullptr) {
17883		assert(payload->type->id == TypeTableEntryIdStruct);
	17883	assert(payload->type->id == ZigTypeIdStruct);
17884	17884	payload->data.x_struct.parent.id = ConstParentIdUnion;
17885	17885	payload->data.x_struct.parent.data.p_union.union_val = out_val;
17886	17886	}
...	...	@@ -17897,7 +17897,7 @@ static ZigType ir_analyze_instruction_type_id(IrAnalyze ira,
17897	17897	return ira->codegen->builtin_types.entry_invalid;
17898	17898
17899	17899	ConstExprValue *var_value = get_builtin_value(ira->codegen, "TypeId");
17900		assert(var_value->type->id == TypeTableEntryIdMetaType);
	17900	assert(var_value->type->id == ZigTypeIdMetaType);
17901	17901	ZigType *result_type = var_value->data.x_type;
17902	17902
17903	17903	ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
...	...	@@ -18206,8 +18206,8 @@ static ZigType ir_analyze_instruction_truncate(IrAnalyze ira, IrInstructionTru
18206	18206	if (type_is_invalid(dest_type))
18207	18207	return ira->codegen->builtin_types.entry_invalid;
18208	18208
18209		if (dest_type->id != TypeTableEntryIdInt &&
18210		dest_type->id != TypeTableEntryIdComptimeInt)
	18209	if (dest_type->id != ZigTypeIdInt &&
	18210	dest_type->id != ZigTypeIdComptimeInt)
18211	18211	{
18212	18212	ir_add_error(ira, dest_type_value, buf_sprintf("expected integer type, found '%s'", buf_ptr(&dest_type->name)));
18213	18213	return ira->codegen->builtin_types.entry_invalid;
...	...	@@ -18218,8 +18218,8 @@ static ZigType ir_analyze_instruction_truncate(IrAnalyze ira, IrInstructionTru
18218	18218	if (type_is_invalid(src_type))
18219	18219	return ira->codegen->builtin_types.entry_invalid;
18220	18220
18221		if (src_type->id != TypeTableEntryIdInt &&
18222		src_type->id != TypeTableEntryIdComptimeInt)
	18221	if (src_type->id != ZigTypeIdInt &&
	18222	src_type->id != ZigTypeIdComptimeInt)
18223	18223	{
18224	18224	ir_add_error(ira, target, buf_sprintf("expected integer type, found '%s'", buf_ptr(&src_type->name)));
18225	18225	return ira->codegen->builtin_types.entry_invalid;
...	...	@@ -18253,7 +18253,7 @@ static ZigType ir_analyze_instruction_int_cast(IrAnalyze ira, IrInstructionInt
18253	18253	if (type_is_invalid(dest_type))
18254	18254	return ira->codegen->builtin_types.entry_invalid;
18255	18255
18256		if (dest_type->id != TypeTableEntryIdInt) {
	18256	if (dest_type->id != ZigTypeIdInt) {
18257	18257	ir_add_error(ira, instruction->dest_type, buf_sprintf("expected integer type, found '%s'", buf_ptr(&dest_type->name)));
18258	18258	return ira->codegen->builtin_types.entry_invalid;
18259	18259	}
...	...	@@ -18262,7 +18262,7 @@ static ZigType ir_analyze_instruction_int_cast(IrAnalyze ira, IrInstructionInt
18262	18262	if (type_is_invalid(target->value.type))
18263	18263	return ira->codegen->builtin_types.entry_invalid;
18264	18264
18265		if (target->value.type->id == TypeTableEntryIdComptimeInt) {
	18265	if (target->value.type->id == ZigTypeIdComptimeInt) {
18266	18266	if (ir_num_lit_fits_in_other_type(ira, target, dest_type, true)) {
18267	18267	IrInstruction *result = ir_resolve_cast(ira, &instruction->base, target, dest_type,
18268	18268	CastOpNumLitToConcrete, false);
...	...	@@ -18275,7 +18275,7 @@ static ZigType ir_analyze_instruction_int_cast(IrAnalyze ira, IrInstructionInt
18275	18275	}
18276	18276	}
18277	18277
18278		if (target->value.type->id != TypeTableEntryIdInt) {
	18278	if (target->value.type->id != ZigTypeIdInt) {
18279	18279	ir_add_error(ira, instruction->target, buf_sprintf("expected integer type, found '%s'",
18280	18280	buf_ptr(&target->value.type->name)));
18281	18281	return ira->codegen->builtin_types.entry_invalid;
...	...	@@ -18294,7 +18294,7 @@ static ZigType ir_analyze_instruction_float_cast(IrAnalyze ira, IrInstructionF
18294	18294	if (type_is_invalid(dest_type))
18295	18295	return ira->codegen->builtin_types.entry_invalid;
18296	18296
18297		if (dest_type->id != TypeTableEntryIdFloat) {
	18297	if (dest_type->id != ZigTypeIdFloat) {
18298	18298	ir_add_error(ira, instruction->dest_type,
18299	18299	buf_sprintf("expected float type, found '%s'", buf_ptr(&dest_type->name)));
18300	18300	return ira->codegen->builtin_types.entry_invalid;
...	...	@@ -18304,12 +18304,12 @@ static ZigType ir_analyze_instruction_float_cast(IrAnalyze ira, IrInstructionF
18304	18304	if (type_is_invalid(target->value.type))
18305	18305	return ira->codegen->builtin_types.entry_invalid;
18306	18306
18307		if (target->value.type->id == TypeTableEntryIdComptimeInt \|\|
18308		target->value.type->id == TypeTableEntryIdComptimeFloat)
	18307	if (target->value.type->id == ZigTypeIdComptimeInt \|\|
	18308	target->value.type->id == ZigTypeIdComptimeFloat)
18309	18309	{
18310	18310	if (ir_num_lit_fits_in_other_type(ira, target, dest_type, true)) {
18311	18311	CastOp op;
18312		if (target->value.type->id == TypeTableEntryIdComptimeInt) {
	18312	if (target->value.type->id == ZigTypeIdComptimeInt) {
18313	18313	op = CastOpIntToFloat;
18314	18314	} else {
18315	18315	op = CastOpNumLitToConcrete;
...	...	@@ -18324,7 +18324,7 @@ static ZigType ir_analyze_instruction_float_cast(IrAnalyze ira, IrInstructionF
18324	18324	}
18325	18325	}
18326	18326
18327		if (target->value.type->id != TypeTableEntryIdFloat) {
	18327	if (target->value.type->id != ZigTypeIdFloat) {
18328	18328	ir_add_error(ira, instruction->target, buf_sprintf("expected float type, found '%s'",
18329	18329	buf_ptr(&target->value.type->name)));
18330	18330	return ira->codegen->builtin_types.entry_invalid;
...	...	@@ -18342,7 +18342,7 @@ static ZigType ir_analyze_instruction_err_set_cast(IrAnalyze ira, IrInstructio
18342	18342	if (type_is_invalid(dest_type))
18343	18343	return ira->codegen->builtin_types.entry_invalid;
18344	18344
18345		if (dest_type->id != TypeTableEntryIdErrorSet) {
	18345	if (dest_type->id != ZigTypeIdErrorSet) {
18346	18346	ir_add_error(ira, instruction->dest_type,
18347	18347	buf_sprintf("expected error set type, found '%s'", buf_ptr(&dest_type->name)));
18348	18348	return ira->codegen->builtin_types.entry_invalid;
...	...	@@ -18352,7 +18352,7 @@ static ZigType ir_analyze_instruction_err_set_cast(IrAnalyze ira, IrInstructio
18352	18352	if (type_is_invalid(target->value.type))
18353	18353	return ira->codegen->builtin_types.entry_invalid;
18354	18354
18355		if (target->value.type->id != TypeTableEntryIdErrorSet) {
	18355	if (target->value.type->id != ZigTypeIdErrorSet) {
18356	18356	ir_add_error(ira, instruction->target,
18357	18357	buf_sprintf("expected error set type, found '%s'", buf_ptr(&target->value.type->name)));
18358	18358	return ira->codegen->builtin_types.entry_invalid;
...	...	@@ -18377,7 +18377,7 @@ static ZigType ir_analyze_instruction_from_bytes(IrAnalyze ira, IrInstructionF
18377	18377	bool src_ptr_const;
18378	18378	bool src_ptr_volatile;
18379	18379	uint32_t src_ptr_align;
18380		if (target->value.type->id == TypeTableEntryIdPointer) {
	18380	if (target->value.type->id == ZigTypeIdPointer) {
18381	18381	src_ptr_const = target->value.type->data.pointer.is_const;
18382	18382	src_ptr_volatile = target->value.type->data.pointer.is_volatile;
18383	18383	src_ptr_align = target->value.type->data.pointer.alignment;
...	...	@@ -18477,7 +18477,7 @@ static ZigType ir_analyze_instruction_int_to_float(IrAnalyze ira, IrInstructio
18477	18477	if (type_is_invalid(target->value.type))
18478	18478	return ira->codegen->builtin_types.entry_invalid;
18479	18479
18480		if (target->value.type->id != TypeTableEntryIdInt && target->value.type->id != TypeTableEntryIdComptimeInt) {
	18480	if (target->value.type->id != ZigTypeIdInt && target->value.type->id != ZigTypeIdComptimeInt) {
18481	18481	ir_add_error(ira, instruction->target, buf_sprintf("expected int type, found '%s'",
18482	18482	buf_ptr(&target->value.type->name)));
18483	18483	return ira->codegen->builtin_types.entry_invalid;
...	...	@@ -18497,7 +18497,7 @@ static ZigType ir_analyze_instruction_float_to_int(IrAnalyze ira, IrInstructio
18497	18497	if (type_is_invalid(target->value.type))
18498	18498	return ira->codegen->builtin_types.entry_invalid;
18499	18499
18500		if (target->value.type->id == TypeTableEntryIdComptimeInt) {
	18500	if (target->value.type->id == ZigTypeIdComptimeInt) {
18501	18501	IrInstruction *casted_value = ir_implicit_cast(ira, target, dest_type);
18502	18502	if (type_is_invalid(casted_value->value.type))
18503	18503	return ira->codegen->builtin_types.entry_invalid;
...	...	@@ -18505,7 +18505,7 @@ static ZigType ir_analyze_instruction_float_to_int(IrAnalyze ira, IrInstructio
18505	18505	return casted_value->value.type;
18506	18506	}
18507	18507
18508		if (target->value.type->id != TypeTableEntryIdFloat && target->value.type->id != TypeTableEntryIdComptimeFloat) {
	18508	if (target->value.type->id != ZigTypeIdFloat && target->value.type->id != ZigTypeIdComptimeFloat) {
18509	18509	ir_add_error(ira, instruction->target, buf_sprintf("expected float type, found '%s'",
18510	18510	buf_ptr(&target->value.type->name)));
18511	18511	return ira->codegen->builtin_types.entry_invalid;
...	...	@@ -18522,7 +18522,7 @@ static ZigType ir_analyze_instruction_err_to_int(IrAnalyze ira, IrInstructionE
18522	18522	return ira->codegen->builtin_types.entry_invalid;
18523	18523
18524	18524	IrInstruction *casted_target;
18525		if (target->value.type->id == TypeTableEntryIdErrorSet) {
	18525	if (target->value.type->id == ZigTypeIdErrorSet) {
18526	18526	casted_target = target;
18527	18527	} else {
18528	18528	casted_target = ir_implicit_cast(ira, target, ira->codegen->builtin_types.entry_global_error_set);
...	...	@@ -18554,7 +18554,7 @@ static ZigType ir_analyze_instruction_bool_to_int(IrAnalyze ira, IrInstruction
18554	18554	if (type_is_invalid(target->value.type))
18555	18555	return ira->codegen->builtin_types.entry_invalid;
18556	18556
18557		if (target->value.type->id != TypeTableEntryIdBool) {
	18557	if (target->value.type->id != ZigTypeIdBool) {
18558	18558	ir_add_error(ira, instruction->target, buf_sprintf("expected bool, found '%s'",
18559	18559	buf_ptr(&target->value.type->name)));
18560	18560	return ira->codegen->builtin_types.entry_invalid;
...	...	@@ -18631,12 +18631,12 @@ static ZigType ir_analyze_instruction_memset(IrAnalyze ira, IrInstructionMemse
18631	18631	return ira->codegen->builtin_types.entry_invalid;
18632	18632
18633	18633	ZigType *dest_uncasted_type = dest_ptr->value.type;
18634		bool dest_is_volatile = (dest_uncasted_type->id == TypeTableEntryIdPointer) &&
	18634	bool dest_is_volatile = (dest_uncasted_type->id == ZigTypeIdPointer) &&
18635	18635	dest_uncasted_type->data.pointer.is_volatile;
18636	18636
18637	18637	ZigType *usize = ira->codegen->builtin_types.entry_usize;
18638	18638	ZigType *u8 = ira->codegen->builtin_types.entry_u8;
18639		uint32_t dest_align = (dest_uncasted_type->id == TypeTableEntryIdPointer) ?
	18639	uint32_t dest_align = (dest_uncasted_type->id == ZigTypeIdPointer) ?
18640	18640	dest_uncasted_type->data.pointer.alignment : get_abi_alignment(ira->codegen, u8);
18641	18641	ZigType *u8_ptr = get_pointer_to_type_extra(ira->codegen, u8, false, dest_is_volatile,
18642	18642	PtrLenUnknown, dest_align, 0, 0);
...	...	@@ -18725,13 +18725,13 @@ static ZigType ir_analyze_instruction_memcpy(IrAnalyze ira, IrInstructionMemcp
18725	18725	ZigType *u8 = ira->codegen->builtin_types.entry_u8;
18726	18726	ZigType *dest_uncasted_type = dest_ptr->value.type;
18727	18727	ZigType *src_uncasted_type = src_ptr->value.type;
18728		bool dest_is_volatile = (dest_uncasted_type->id == TypeTableEntryIdPointer) &&
	18728	bool dest_is_volatile = (dest_uncasted_type->id == ZigTypeIdPointer) &&
18729	18729	dest_uncasted_type->data.pointer.is_volatile;
18730		bool src_is_volatile = (src_uncasted_type->id == TypeTableEntryIdPointer) &&
	18730	bool src_is_volatile = (src_uncasted_type->id == ZigTypeIdPointer) &&
18731	18731	src_uncasted_type->data.pointer.is_volatile;
18732		uint32_t dest_align = (dest_uncasted_type->id == TypeTableEntryIdPointer) ?
	18732	uint32_t dest_align = (dest_uncasted_type->id == ZigTypeIdPointer) ?
18733	18733	dest_uncasted_type->data.pointer.alignment : get_abi_alignment(ira->codegen, u8);
18734		uint32_t src_align = (src_uncasted_type->id == TypeTableEntryIdPointer) ?
	18734	uint32_t src_align = (src_uncasted_type->id == ZigTypeIdPointer) ?
18735	18735	src_uncasted_type->data.pointer.alignment : get_abi_alignment(ira->codegen, u8);
18736	18736
18737	18737	ZigType *usize = ira->codegen->builtin_types.entry_usize;
...	...	@@ -18850,7 +18850,7 @@ static ZigType ir_analyze_instruction_slice(IrAnalyze ira, IrInstructionSlice
18850	18850	return ira->codegen->builtin_types.entry_invalid;
18851	18851
18852	18852	ZigType *ptr_type = ptr_ptr->value.type;
18853		assert(ptr_type->id == TypeTableEntryIdPointer);
	18853	assert(ptr_type->id == ZigTypeIdPointer);
18854	18854	ZigType *array_type = ptr_type->data.pointer.child_type;
18855	18855
18856	18856	IrInstruction *start = instruction->start->other;
...	...	@@ -18876,7 +18876,7 @@ static ZigType ir_analyze_instruction_slice(IrAnalyze ira, IrInstructionSlice
18876	18876
18877	18877	ZigType *return_type;
18878	18878
18879		if (array_type->id == TypeTableEntryIdArray) {
	18879	if (array_type->id == ZigTypeIdArray) {
18880	18880	uint32_t byte_alignment = ptr_type->data.pointer.alignment;
18881	18881	if (array_type->data.array.len == 0 && byte_alignment == 0) {
18882	18882	byte_alignment = get_abi_alignment(ira->codegen, array_type->data.array.child_type);
...	...	@@ -18889,10 +18889,10 @@ static ZigType ir_analyze_instruction_slice(IrAnalyze ira, IrInstructionSlice
18889	18889	PtrLenUnknown,
18890	18890	byte_alignment, 0, 0);
18891	18891	return_type = get_slice_type(ira->codegen, slice_ptr_type);
18892		} else if (array_type->id == TypeTableEntryIdPointer) {
	18892	} else if (array_type->id == ZigTypeIdPointer) {
18893	18893	if (array_type->data.pointer.ptr_len == PtrLenSingle) {
18894	18894	ZigType *main_type = array_type->data.pointer.child_type;
18895		if (main_type->id == TypeTableEntryIdArray) {
	18895	if (main_type->id == ZigTypeIdArray) {
18896	18896	ZigType *slice_ptr_type = get_pointer_to_type_extra(ira->codegen,
18897	18897	main_type->data.pointer.child_type,
18898	18898	array_type->data.pointer.is_const, array_type->data.pointer.is_volatile,
...	...	@@ -18932,12 +18932,12 @@ static ZigType ir_analyze_instruction_slice(IrAnalyze ira, IrInstructionSlice
18932	18932	size_t abs_offset;
18933	18933	size_t rel_end;
18934	18934	bool ptr_is_undef = false;
18935		if (array_type->id == TypeTableEntryIdArray \|\|
18936		(array_type->id == TypeTableEntryIdPointer && array_type->data.pointer.ptr_len == PtrLenSingle))
	18935	if (array_type->id == ZigTypeIdArray \|\|
	18936	(array_type->id == ZigTypeIdPointer && array_type->data.pointer.ptr_len == PtrLenSingle))
18937	18937	{
18938		if (array_type->id == TypeTableEntryIdPointer) {
	18938	if (array_type->id == ZigTypeIdPointer) {
18939	18939	ZigType *child_array_type = array_type->data.pointer.child_type;
18940		assert(child_array_type->id == TypeTableEntryIdArray);
	18940	assert(child_array_type->id == ZigTypeIdArray);
18941	18941	parent_ptr = ir_const_ptr_pointee(ira, &ptr_ptr->value, instruction->base.source_node);
18942	18942	if (parent_ptr == nullptr)
18943	18943	return ira->codegen->builtin_types.entry_invalid;
...	...	@@ -18956,7 +18956,7 @@ static ZigType ir_analyze_instruction_slice(IrAnalyze ira, IrInstructionSlice
18956	18956	parent_ptr = nullptr;
18957	18957	abs_offset = 0;
18958	18958	}
18959		} else if (array_type->id == TypeTableEntryIdPointer) {
	18959	} else if (array_type->id == ZigTypeIdPointer) {
18960	18960	assert(array_type->data.pointer.ptr_len == PtrLenUnknown);
18961	18961	parent_ptr = ir_const_ptr_pointee(ira, &ptr_ptr->value, instruction->base.source_node);
18962	18962	if (parent_ptr == nullptr)
...	...	@@ -19063,11 +19063,11 @@ static ZigType ir_analyze_instruction_slice(IrAnalyze ira, IrInstructionSlice
19063	19063	size_t index = abs_offset + start_scalar;
19064	19064	bool is_const = slice_is_const(return_type);
19065	19065	init_const_ptr_array(ira->codegen, ptr_val, array_val, index, is_const, PtrLenUnknown);
19066		if (array_type->id == TypeTableEntryIdArray) {
	19066	if (array_type->id == ZigTypeIdArray) {
19067	19067	ptr_val->data.x_ptr.mut = ptr_ptr->value.data.x_ptr.mut;
19068	19068	} else if (is_slice(array_type)) {
19069	19069	ptr_val->data.x_ptr.mut = parent_ptr->data.x_ptr.mut;
19070		} else if (array_type->id == TypeTableEntryIdPointer) {
	19070	} else if (array_type->id == ZigTypeIdPointer) {
19071	19071	ptr_val->data.x_ptr.mut = parent_ptr->data.x_ptr.mut;
19072	19072	}
19073	19073	} else if (ptr_is_undef) {
...	...	@@ -19122,13 +19122,13 @@ static ZigType ir_analyze_instruction_member_count(IrAnalyze ira, IrInstructio
19122	19122	uint64_t result;
19123	19123	if (type_is_invalid(container_type)) {
19124	19124	return ira->codegen->builtin_types.entry_invalid;
19125		} else if (container_type->id == TypeTableEntryIdEnum) {
	19125	} else if (container_type->id == ZigTypeIdEnum) {
19126	19126	result = container_type->data.enumeration.src_field_count;
19127		} else if (container_type->id == TypeTableEntryIdStruct) {
	19127	} else if (container_type->id == ZigTypeIdStruct) {
19128	19128	result = container_type->data.structure.src_field_count;
19129		} else if (container_type->id == TypeTableEntryIdUnion) {
	19129	} else if (container_type->id == ZigTypeIdUnion) {
19130	19130	result = container_type->data.unionation.src_field_count;
19131		} else if (container_type->id == TypeTableEntryIdErrorSet) {
	19131	} else if (container_type->id == ZigTypeIdErrorSet) {
19132	19132	if (!resolve_inferred_error_set(ira->codegen, container_type, instruction->base.source_node)) {
19133	19133	return ira->codegen->builtin_types.entry_invalid;
19134	19134	}
...	...	@@ -19163,7 +19163,7 @@ static ZigType ir_analyze_instruction_member_type(IrAnalyze ira, IrInstruction
19163	19163	if (!ir_resolve_usize(ira, index_value, &member_index))
19164	19164	return ira->codegen->builtin_types.entry_invalid;
19165	19165
19166		if (container_type->id == TypeTableEntryIdStruct) {
	19166	if (container_type->id == ZigTypeIdStruct) {
19167	19167	if (member_index >= container_type->data.structure.src_field_count) {
19168	19168	ir_add_error(ira, index_value,
19169	19169	buf_sprintf("member index %" ZIG_PRI_u64 " out of bounds; '%s' has %" PRIu32 " members",
...	...	@@ -19175,7 +19175,7 @@ static ZigType ir_analyze_instruction_member_type(IrAnalyze ira, IrInstruction
19175	19175	ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
19176	19176	out_val->data.x_type = field->type_entry;
19177	19177	return ira->codegen->builtin_types.entry_type;
19178		} else if (container_type->id == TypeTableEntryIdUnion) {
	19178	} else if (container_type->id == ZigTypeIdUnion) {
19179	19179	if (member_index >= container_type->data.unionation.src_field_count) {
19180	19180	ir_add_error(ira, index_value,
19181	19181	buf_sprintf("member index %" ZIG_PRI_u64 " out of bounds; '%s' has %" PRIu32 " members",
...	...	@@ -19209,7 +19209,7 @@ static ZigType ir_analyze_instruction_member_name(IrAnalyze ira, IrInstruction
19209	19209	if (!ir_resolve_usize(ira, index_value, &member_index))
19210	19210	return ira->codegen->builtin_types.entry_invalid;
19211	19211
19212		if (container_type->id == TypeTableEntryIdStruct) {
	19212	if (container_type->id == ZigTypeIdStruct) {
19213	19213	if (member_index >= container_type->data.structure.src_field_count) {
19214	19214	ir_add_error(ira, index_value,
19215	19215	buf_sprintf("member index %" ZIG_PRI_u64 " out of bounds; '%s' has %" PRIu32 " members",
...	...	@@ -19221,7 +19221,7 @@ static ZigType ir_analyze_instruction_member_name(IrAnalyze ira, IrInstruction
19221	19221	ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
19222	19222	init_const_str_lit(ira->codegen, out_val, field->name);
19223	19223	return out_val->type;
19224		} else if (container_type->id == TypeTableEntryIdEnum) {
	19224	} else if (container_type->id == ZigTypeIdEnum) {
19225	19225	if (member_index >= container_type->data.enumeration.src_field_count) {
19226	19226	ir_add_error(ira, index_value,
19227	19227	buf_sprintf("member index %" ZIG_PRI_u64 " out of bounds; '%s' has %" PRIu32 " members",
...	...	@@ -19233,7 +19233,7 @@ static ZigType ir_analyze_instruction_member_name(IrAnalyze ira, IrInstruction
19233	19233	ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
19234	19234	init_const_str_lit(ira->codegen, out_val, field->name);
19235	19235	return out_val->type;
19236		} else if (container_type->id == TypeTableEntryIdUnion) {
	19236	} else if (container_type->id == ZigTypeIdUnion) {
19237	19237	if (member_index >= container_type->data.unionation.src_field_count) {
19238	19238	ir_add_error(ira, index_value,
19239	19239	buf_sprintf("member index %" ZIG_PRI_u64 " out of bounds; '%s' has %" PRIu32 " members",
...	...	@@ -19292,36 +19292,36 @@ static ZigType ir_analyze_instruction_align_of(IrAnalyze ira, IrInstructionAli
19292	19292	return ira->codegen->builtin_types.entry_invalid;
19293	19293
19294	19294	switch (type_entry->id) {
19295		case TypeTableEntryIdInvalid:
	19295	case ZigTypeIdInvalid:
19296	19296	zig_unreachable();
19297		case TypeTableEntryIdMetaType:
19298		case TypeTableEntryIdUnreachable:
19299		case TypeTableEntryIdComptimeFloat:
19300		case TypeTableEntryIdComptimeInt:
19301		case TypeTableEntryIdUndefined:
19302		case TypeTableEntryIdNull:
19303		case TypeTableEntryIdNamespace:
19304		case TypeTableEntryIdBlock:
19305		case TypeTableEntryIdBoundFn:
19306		case TypeTableEntryIdArgTuple:
19307		case TypeTableEntryIdVoid:
19308		case TypeTableEntryIdOpaque:
	19297	case ZigTypeIdMetaType:
	19298	case ZigTypeIdUnreachable:
	19299	case ZigTypeIdComptimeFloat:
	19300	case ZigTypeIdComptimeInt:
	19301	case ZigTypeIdUndefined:
	19302	case ZigTypeIdNull:
	19303	case ZigTypeIdNamespace:
	19304	case ZigTypeIdBlock:
	19305	case ZigTypeIdBoundFn:
	19306	case ZigTypeIdArgTuple:
	19307	case ZigTypeIdVoid:
	19308	case ZigTypeIdOpaque:
19309	19309	ir_add_error(ira, instruction->type_value,
19310	19310	buf_sprintf("no align available for type '%s'", buf_ptr(&type_entry->name)));
19311	19311	return ira->codegen->builtin_types.entry_invalid;
19312		case TypeTableEntryIdBool:
19313		case TypeTableEntryIdInt:
19314		case TypeTableEntryIdFloat:
19315		case TypeTableEntryIdPointer:
19316		case TypeTableEntryIdPromise:
19317		case TypeTableEntryIdArray:
19318		case TypeTableEntryIdStruct:
19319		case TypeTableEntryIdOptional:
19320		case TypeTableEntryIdErrorUnion:
19321		case TypeTableEntryIdErrorSet:
19322		case TypeTableEntryIdEnum:
19323		case TypeTableEntryIdUnion:
19324		case TypeTableEntryIdFn:
	19312	case ZigTypeIdBool:
	19313	case ZigTypeIdInt:
	19314	case ZigTypeIdFloat:
	19315	case ZigTypeIdPointer:
	19316	case ZigTypeIdPromise:
	19317	case ZigTypeIdArray:
	19318	case ZigTypeIdStruct:
	19319	case ZigTypeIdOptional:
	19320	case ZigTypeIdErrorUnion:
	19321	case ZigTypeIdErrorSet:
	19322	case ZigTypeIdEnum:
	19323	case ZigTypeIdUnion:
	19324	case ZigTypeIdFn:
19325	19325	{
19326	19326	uint64_t align_in_bytes = get_abi_alignment(ira->codegen, type_entry);
19327	19327	ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
...	...	@@ -19341,7 +19341,7 @@ static ZigType ir_analyze_instruction_overflow_op(IrAnalyze ira, IrInstruction
19341	19341	if (type_is_invalid(dest_type))
19342	19342	return ira->codegen->builtin_types.entry_invalid;
19343	19343
19344		if (dest_type->id != TypeTableEntryIdInt) {
	19344	if (dest_type->id != ZigTypeIdInt) {
19345	19345	ir_add_error(ira, type_value,
19346	19346	buf_sprintf("expected integer type, found '%s'", buf_ptr(&dest_type->name)));
19347	19347	return ira->codegen->builtin_types.entry_invalid;
...	...	@@ -19375,7 +19375,7 @@ static ZigType ir_analyze_instruction_overflow_op(IrAnalyze ira, IrInstruction
19375	19375	return ira->codegen->builtin_types.entry_invalid;
19376	19376
19377	19377	ZigType *expected_ptr_type;
19378		if (result_ptr->value.type->id == TypeTableEntryIdPointer) {
	19378	if (result_ptr->value.type->id == ZigTypeIdPointer) {
19379	19379	expected_ptr_type = get_pointer_to_type_extra(ira->codegen, dest_type,
19380	19380	false, result_ptr->value.type->data.pointer.is_volatile,
19381	19381	PtrLenSingle,
...	...	@@ -19439,7 +19439,7 @@ static ZigType ir_analyze_instruction_test_err(IrAnalyze ira, IrInstructionTes
19439	19439	ZigType *type_entry = value->value.type;
19440	19440	if (type_is_invalid(type_entry)) {
19441	19441	return ira->codegen->builtin_types.entry_invalid;
19442		} else if (type_entry->id == TypeTableEntryIdErrorUnion) {
	19442	} else if (type_entry->id == ZigTypeIdErrorUnion) {
19443	19443	if (instr_is_comptime(value)) {
19444	19444	ConstExprValue *err_union_val = ir_resolve_const(ira, value, UndefBad);
19445	19445	if (!err_union_val)
...	...	@@ -19467,7 +19467,7 @@ static ZigType ir_analyze_instruction_test_err(IrAnalyze ira, IrInstructionTes
19467	19467
19468	19468	ir_build_test_err_from(&ira->new_irb, &instruction->base, value);
19469	19469	return ira->codegen->builtin_types.entry_bool;
19470		} else if (type_entry->id == TypeTableEntryIdErrorSet) {
	19470	} else if (type_entry->id == ZigTypeIdErrorSet) {
19471	19471	ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
19472	19472	out_val->data.x_bool = true;
19473	19473	return ira->codegen->builtin_types.entry_bool;
...	...	@@ -19487,12 +19487,12 @@ static ZigType ir_analyze_instruction_unwrap_err_code(IrAnalyze ira,
19487	19487	ZigType *ptr_type = value->value.type;
19488	19488
19489	19489	// This will be a pointer type because unwrap err payload IR instruction operates on a pointer to a thing.
19490		assert(ptr_type->id == TypeTableEntryIdPointer);
	19490	assert(ptr_type->id == ZigTypeIdPointer);
19491	19491
19492	19492	ZigType *type_entry = ptr_type->data.pointer.child_type;
19493	19493	if (type_is_invalid(type_entry)) {
19494	19494	return ira->codegen->builtin_types.entry_invalid;
19495		} else if (type_entry->id == TypeTableEntryIdErrorUnion) {
	19495	} else if (type_entry->id == ZigTypeIdErrorUnion) {
19496	19496	if (instr_is_comptime(value)) {
19497	19497	ConstExprValue *ptr_val = ir_resolve_const(ira, value, UndefBad);
19498	19498	if (!ptr_val)
...	...	@@ -19529,12 +19529,12 @@ static ZigType ir_analyze_instruction_unwrap_err_payload(IrAnalyze ira,
19529	19529	ZigType *ptr_type = value->value.type;
19530	19530
19531	19531	// This will be a pointer type because unwrap err payload IR instruction operates on a pointer to a thing.
19532		assert(ptr_type->id == TypeTableEntryIdPointer);
	19532	assert(ptr_type->id == ZigTypeIdPointer);
19533	19533
19534	19534	ZigType *type_entry = ptr_type->data.pointer.child_type;
19535	19535	if (type_is_invalid(type_entry)) {
19536	19536	return ira->codegen->builtin_types.entry_invalid;
19537		} else if (type_entry->id == TypeTableEntryIdErrorUnion) {
	19537	} else if (type_entry->id == ZigTypeIdErrorUnion) {
19538	19538	ZigType *payload_type = type_entry->data.error_union.payload_type;
19539	19539	if (type_is_invalid(payload_type)) {
19540	19540	return ira->codegen->builtin_types.entry_invalid;
...	...	@@ -19633,7 +19633,7 @@ static ZigType ir_analyze_instruction_fn_proto(IrAnalyze ira, IrInstructionFnP
19633	19633	fn_type_id.return_type = ir_resolve_type(ira, return_type_value);
19634	19634	if (type_is_invalid(fn_type_id.return_type))
19635	19635	return ira->codegen->builtin_types.entry_invalid;
19636		if (fn_type_id.return_type->id == TypeTableEntryIdOpaque) {
	19636	if (fn_type_id.return_type->id == ZigTypeIdOpaque) {
19637	19637	ir_add_error(ira, instruction->return_type,
19638	19638	buf_sprintf("return type cannot be opaque"));
19639	19639	return ira->codegen->builtin_types.entry_invalid;
...	...	@@ -19674,7 +19674,7 @@ static ZigType ir_analyze_instruction_check_switch_prongs(IrAnalyze ira,
19674	19674	if (type_is_invalid(switch_type))
19675	19675	return ira->codegen->builtin_types.entry_invalid;
19676	19676
19677		if (switch_type->id == TypeTableEntryIdEnum) {
	19677	if (switch_type->id == ZigTypeIdEnum) {
19678	19678	HashMap<BigInt, AstNode *, bigint_hash, bigint_eql> field_prev_uses = {};
19679	19679	field_prev_uses.init(switch_type->data.enumeration.src_field_count);
19680	19680
...	...	@@ -19689,7 +19689,7 @@ static ZigType ir_analyze_instruction_check_switch_prongs(IrAnalyze ira,
19689	19689	if (type_is_invalid(end_value->value.type))
19690	19690	return ira->codegen->builtin_types.entry_invalid;
19691	19691
19692		if (start_value->value.type->id != TypeTableEntryIdEnum) {
	19692	if (start_value->value.type->id != ZigTypeIdEnum) {
19693	19693	ir_add_error(ira, range->start, buf_sprintf("not an enum type"));
19694	19694	return ira->codegen->builtin_types.entry_invalid;
19695	19695	}
...	...	@@ -19697,7 +19697,7 @@ static ZigType ir_analyze_instruction_check_switch_prongs(IrAnalyze ira,
19697	19697	BigInt start_index;
19698	19698	bigint_init_bigint(&start_index, &start_value->value.data.x_enum_tag);
19699	19699
19700		assert(end_value->value.type->id == TypeTableEntryIdEnum);
	19700	assert(end_value->value.type->id == ZigTypeIdEnum);
19701	19701	BigInt end_index;
19702	19702	bigint_init_bigint(&end_index, &end_value->value.data.x_enum_tag);
19703	19703
...	...	@@ -19733,7 +19733,7 @@ static ZigType ir_analyze_instruction_check_switch_prongs(IrAnalyze ira,
19733	19733	}
19734	19734	}
19735	19735	}
19736		} else if (switch_type->id == TypeTableEntryIdErrorSet) {
	19736	} else if (switch_type->id == ZigTypeIdErrorSet) {
19737	19737	if (!resolve_inferred_error_set(ira->codegen, switch_type, target_value->source_node)) {
19738	19738	return ira->codegen->builtin_types.entry_invalid;
19739	19739	}
...	...	@@ -19751,10 +19751,10 @@ static ZigType ir_analyze_instruction_check_switch_prongs(IrAnalyze ira,
19751	19751	if (type_is_invalid(end_value->value.type))
19752	19752	return ira->codegen->builtin_types.entry_invalid;
19753	19753
19754		assert(start_value->value.type->id == TypeTableEntryIdErrorSet);
	19754	assert(start_value->value.type->id == ZigTypeIdErrorSet);
19755	19755	uint32_t start_index = start_value->value.data.x_err_set->value;
19756	19756
19757		assert(end_value->value.type->id == TypeTableEntryIdErrorSet);
	19757	assert(end_value->value.type->id == ZigTypeIdErrorSet);
19758	19758	uint32_t end_index = end_value->value.data.x_err_set->value;
19759	19759
19760	19760	if (start_index != end_index) {
...	...	@@ -19790,7 +19790,7 @@ static ZigType ir_analyze_instruction_check_switch_prongs(IrAnalyze ira,
19790	19790	}
19791	19791
19792	19792	free(field_prev_uses);
19793		} else if (switch_type->id == TypeTableEntryIdInt) {
	19793	} else if (switch_type->id == ZigTypeIdInt) {
19794	19794	RangeSet rs = {0};
19795	19795	for (size_t range_i = 0; range_i < instruction->range_count; range_i += 1) {
19796	19796	IrInstructionCheckSwitchProngsRange *range = &instruction->ranges[range_i];
...	...	@@ -19817,8 +19817,8 @@ static ZigType ir_analyze_instruction_check_switch_prongs(IrAnalyze ira,
19817	19817	if (!end_val)
19818	19818	return ira->codegen->builtin_types.entry_invalid;
19819	19819
19820		assert(start_val->type->id == TypeTableEntryIdInt \|\| start_val->type->id == TypeTableEntryIdComptimeInt);
19821		assert(end_val->type->id == TypeTableEntryIdInt \|\| end_val->type->id == TypeTableEntryIdComptimeInt);
	19820	assert(start_val->type->id == ZigTypeIdInt \|\| start_val->type->id == ZigTypeIdComptimeInt);
	19821	assert(end_val->type->id == ZigTypeIdInt \|\| end_val->type->id == ZigTypeIdComptimeInt);
19822	19822	AstNode *prev_node = rangeset_add_range(&rs, &start_val->data.x_bigint, &end_val->data.x_bigint,
19823	19823	start_value->source_node);
19824	19824	if (prev_node != nullptr) {
...	...	@@ -19854,7 +19854,7 @@ static ZigType ir_analyze_instruction_check_statement_is_void(IrAnalyze ira,
19854	19854	if (type_is_invalid(statement_type))
19855	19855	return ira->codegen->builtin_types.entry_invalid;
19856	19856
19857		if (statement_type->id != TypeTableEntryIdVoid) {
	19857	if (statement_type->id != ZigTypeIdVoid) {
19858	19858	ir_add_error(ira, &instruction->base, buf_sprintf("expression value is ignored"));
19859	19859	}
19860	19860
...	...	@@ -19892,24 +19892,24 @@ static IrInstruction ir_align_cast(IrAnalyze ira, IrInstruction *target, uint3
19892	19892	ZigType *result_type;
19893	19893	uint32_t old_align_bytes;
19894	19894
19895		if (target_type->id == TypeTableEntryIdPointer) {
	19895	if (target_type->id == ZigTypeIdPointer) {
19896	19896	result_type = adjust_ptr_align(ira->codegen, target_type, align_bytes);
19897	19897	old_align_bytes = target_type->data.pointer.alignment;
19898		} else if (target_type->id == TypeTableEntryIdFn) {
	19898	} else if (target_type->id == ZigTypeIdFn) {
19899	19899	FnTypeId fn_type_id = target_type->data.fn.fn_type_id;
19900	19900	old_align_bytes = fn_type_id.alignment;
19901	19901	fn_type_id.alignment = align_bytes;
19902	19902	result_type = get_fn_type(ira->codegen, &fn_type_id);
19903		} else if (target_type->id == TypeTableEntryIdOptional &&
19904		target_type->data.maybe.child_type->id == TypeTableEntryIdPointer)
	19903	} else if (target_type->id == ZigTypeIdOptional &&
	19904	target_type->data.maybe.child_type->id == ZigTypeIdPointer)
19905	19905	{
19906	19906	ZigType *ptr_type = target_type->data.maybe.child_type;
19907	19907	old_align_bytes = ptr_type->data.pointer.alignment;
19908	19908	ZigType *better_ptr_type = adjust_ptr_align(ira->codegen, ptr_type, align_bytes);
19909	19909
19910	19910	result_type = get_optional_type(ira->codegen, better_ptr_type);
19911		} else if (target_type->id == TypeTableEntryIdOptional &&
19912		target_type->data.maybe.child_type->id == TypeTableEntryIdFn)
	19911	} else if (target_type->id == ZigTypeIdOptional &&
	19912	target_type->data.maybe.child_type->id == ZigTypeIdFn)
19913	19913	{
19914	19914	FnTypeId fn_type_id = target_type->data.maybe.child_type->data.fn.fn_type_id;
19915	19915	old_align_bytes = fn_type_id.alignment;
...	...	@@ -20033,33 +20033,33 @@ static ZigType ir_analyze_instruction_ptr_cast(IrAnalyze ira, IrInstructionPtr
20033	20033	static void buf_write_value_bytes(CodeGen codegen, uint8_t buf, ConstExprValue *val) {
20034	20034	assert(val->special == ConstValSpecialStatic);
20035	20035	switch (val->type->id) {
20036		case TypeTableEntryIdInvalid:
20037		case TypeTableEntryIdMetaType:
20038		case TypeTableEntryIdOpaque:
20039		case TypeTableEntryIdBoundFn:
20040		case TypeTableEntryIdArgTuple:
20041		case TypeTableEntryIdNamespace:
20042		case TypeTableEntryIdBlock:
20043		case TypeTableEntryIdUnreachable:
20044		case TypeTableEntryIdComptimeFloat:
20045		case TypeTableEntryIdComptimeInt:
20046		case TypeTableEntryIdUndefined:
20047		case TypeTableEntryIdNull:
20048		case TypeTableEntryIdPromise:
	20036	case ZigTypeIdInvalid:
	20037	case ZigTypeIdMetaType:
	20038	case ZigTypeIdOpaque:
	20039	case ZigTypeIdBoundFn:
	20040	case ZigTypeIdArgTuple:
	20041	case ZigTypeIdNamespace:
	20042	case ZigTypeIdBlock:
	20043	case ZigTypeIdUnreachable:
	20044	case ZigTypeIdComptimeFloat:
	20045	case ZigTypeIdComptimeInt:
	20046	case ZigTypeIdUndefined:
	20047	case ZigTypeIdNull:
	20048	case ZigTypeIdPromise:
20049	20049	zig_unreachable();
20050		case TypeTableEntryIdVoid:
	20050	case ZigTypeIdVoid:
20051	20051	return;
20052		case TypeTableEntryIdBool:
	20052	case ZigTypeIdBool:
20053	20053	buf[0] = val->data.x_bool ? 1 : 0;
20054	20054	return;
20055		case TypeTableEntryIdInt:
	20055	case ZigTypeIdInt:
20056	20056	bigint_write_twos_complement(&val->data.x_bigint, buf, val->type->data.integral.bit_count,
20057	20057	codegen->is_big_endian);
20058	20058	return;
20059		case TypeTableEntryIdFloat:
	20059	case ZigTypeIdFloat:
20060	20060	float_write_ieee597(val, buf, codegen->is_big_endian);
20061	20061	return;
20062		case TypeTableEntryIdPointer:
	20062	case ZigTypeIdPointer:
20063	20063	if (val->data.x_ptr.special == ConstPtrSpecialHardCodedAddr) {
20064	20064	BigInt bn;
20065	20065	bigint_init_unsigned(&bn, val->data.x_ptr.data.hard_coded_addr.addr);
...	...	@@ -20068,7 +20068,7 @@ static void buf_write_value_bytes(CodeGen codegen, uint8_t buf, ConstExprValue
20068	20068	} else {
20069	20069	zig_unreachable();
20070	20070	}
20071		case TypeTableEntryIdArray:
	20071	case ZigTypeIdArray:
20072	20072	{
20073	20073	size_t buf_i = 0;
20074	20074	expand_undef_array(codegen, val);
...	...	@@ -20079,19 +20079,19 @@ static void buf_write_value_bytes(CodeGen codegen, uint8_t buf, ConstExprValue
20079	20079	}
20080	20080	}
20081	20081	return;
20082		case TypeTableEntryIdStruct:
	20082	case ZigTypeIdStruct:
20083	20083	zig_panic("TODO buf_write_value_bytes struct type");
20084		case TypeTableEntryIdOptional:
	20084	case ZigTypeIdOptional:
20085	20085	zig_panic("TODO buf_write_value_bytes maybe type");
20086		case TypeTableEntryIdErrorUnion:
	20086	case ZigTypeIdErrorUnion:
20087	20087	zig_panic("TODO buf_write_value_bytes error union");
20088		case TypeTableEntryIdErrorSet:
	20088	case ZigTypeIdErrorSet:
20089	20089	zig_panic("TODO buf_write_value_bytes pure error type");
20090		case TypeTableEntryIdEnum:
	20090	case ZigTypeIdEnum:
20091	20091	zig_panic("TODO buf_write_value_bytes enum type");
20092		case TypeTableEntryIdFn:
	20092	case ZigTypeIdFn:
20093	20093	zig_panic("TODO buf_write_value_bytes fn type");
20094		case TypeTableEntryIdUnion:
	20094	case ZigTypeIdUnion:
20095	20095	zig_panic("TODO buf_write_value_bytes union type");
20096	20096	}
20097	20097	zig_unreachable();
...	...	@@ -20100,33 +20100,33 @@ static void buf_write_value_bytes(CodeGen codegen, uint8_t buf, ConstExprValue
20100	20100	static void buf_read_value_bytes(CodeGen codegen, uint8_t buf, ConstExprValue *val) {
20101	20101	assert(val->special == ConstValSpecialStatic);
20102	20102	switch (val->type->id) {
20103		case TypeTableEntryIdInvalid:
20104		case TypeTableEntryIdMetaType:
20105		case TypeTableEntryIdOpaque:
20106		case TypeTableEntryIdBoundFn:
20107		case TypeTableEntryIdArgTuple:
20108		case TypeTableEntryIdNamespace:
20109		case TypeTableEntryIdBlock:
20110		case TypeTableEntryIdUnreachable:
20111		case TypeTableEntryIdComptimeFloat:
20112		case TypeTableEntryIdComptimeInt:
20113		case TypeTableEntryIdUndefined:
20114		case TypeTableEntryIdNull:
20115		case TypeTableEntryIdPromise:
	20103	case ZigTypeIdInvalid:
	20104	case ZigTypeIdMetaType:
	20105	case ZigTypeIdOpaque:
	20106	case ZigTypeIdBoundFn:
	20107	case ZigTypeIdArgTuple:
	20108	case ZigTypeIdNamespace:
	20109	case ZigTypeIdBlock:
	20110	case ZigTypeIdUnreachable:
	20111	case ZigTypeIdComptimeFloat:
	20112	case ZigTypeIdComptimeInt:
	20113	case ZigTypeIdUndefined:
	20114	case ZigTypeIdNull:
	20115	case ZigTypeIdPromise:
20116	20116	zig_unreachable();
20117		case TypeTableEntryIdVoid:
	20117	case ZigTypeIdVoid:
20118	20118	return;
20119		case TypeTableEntryIdBool:
	20119	case ZigTypeIdBool:
20120	20120	val->data.x_bool = (buf[0] != 0);
20121	20121	return;
20122		case TypeTableEntryIdInt:
	20122	case ZigTypeIdInt:
20123	20123	bigint_read_twos_complement(&val->data.x_bigint, buf, val->type->data.integral.bit_count,
20124	20124	codegen->is_big_endian, val->type->data.integral.is_signed);
20125	20125	return;
20126		case TypeTableEntryIdFloat:
	20126	case ZigTypeIdFloat:
20127	20127	float_read_ieee597(val, buf, codegen->is_big_endian);
20128	20128	return;
20129		case TypeTableEntryIdPointer:
	20129	case ZigTypeIdPointer:
20130	20130	{
20131	20131	val->data.x_ptr.special = ConstPtrSpecialHardCodedAddr;
20132	20132	BigInt bn;
...	...	@@ -20135,21 +20135,21 @@ static void buf_read_value_bytes(CodeGen codegen, uint8_t buf, ConstExprValue
20135	20135	val->data.x_ptr.data.hard_coded_addr.addr = bigint_as_unsigned(&bn);
20136	20136	return;
20137	20137	}
20138		case TypeTableEntryIdArray:
	20138	case ZigTypeIdArray:
20139	20139	zig_panic("TODO buf_read_value_bytes array type");
20140		case TypeTableEntryIdStruct:
	20140	case ZigTypeIdStruct:
20141	20141	zig_panic("TODO buf_read_value_bytes struct type");
20142		case TypeTableEntryIdOptional:
	20142	case ZigTypeIdOptional:
20143	20143	zig_panic("TODO buf_read_value_bytes maybe type");
20144		case TypeTableEntryIdErrorUnion:
	20144	case ZigTypeIdErrorUnion:
20145	20145	zig_panic("TODO buf_read_value_bytes error union");
20146		case TypeTableEntryIdErrorSet:
	20146	case ZigTypeIdErrorSet:
20147	20147	zig_panic("TODO buf_read_value_bytes pure error type");
20148		case TypeTableEntryIdEnum:
	20148	case ZigTypeIdEnum:
20149	20149	zig_panic("TODO buf_read_value_bytes enum type");
20150		case TypeTableEntryIdFn:
	20150	case ZigTypeIdFn:
20151	20151	zig_panic("TODO buf_read_value_bytes fn type");
20152		case TypeTableEntryIdUnion:
	20152	case ZigTypeIdUnion:
20153	20153	zig_panic("TODO buf_read_value_bytes union type");
20154	20154	}
20155	20155	zig_unreachable();
...	...	@@ -20180,18 +20180,18 @@ static ZigType ir_analyze_instruction_bit_cast(IrAnalyze ira, IrInstructionBit
20180	20180	}
20181	20181
20182	20182	switch (src_type->id) {
20183		case TypeTableEntryIdInvalid:
20184		case TypeTableEntryIdMetaType:
20185		case TypeTableEntryIdOpaque:
20186		case TypeTableEntryIdBoundFn:
20187		case TypeTableEntryIdArgTuple:
20188		case TypeTableEntryIdNamespace:
20189		case TypeTableEntryIdBlock:
20190		case TypeTableEntryIdUnreachable:
20191		case TypeTableEntryIdComptimeFloat:
20192		case TypeTableEntryIdComptimeInt:
20193		case TypeTableEntryIdUndefined:
20194		case TypeTableEntryIdNull:
	20183	case ZigTypeIdInvalid:
	20184	case ZigTypeIdMetaType:
	20185	case ZigTypeIdOpaque:
	20186	case ZigTypeIdBoundFn:
	20187	case ZigTypeIdArgTuple:
	20188	case ZigTypeIdNamespace:
	20189	case ZigTypeIdBlock:
	20190	case ZigTypeIdUnreachable:
	20191	case ZigTypeIdComptimeFloat:
	20192	case ZigTypeIdComptimeInt:
	20193	case ZigTypeIdUndefined:
	20194	case ZigTypeIdNull:
20195	20195	ir_add_error(ira, dest_type_value,
20196	20196	buf_sprintf("unable to @bitCast from type '%s'", buf_ptr(&src_type->name)));
20197	20197	return ira->codegen->builtin_types.entry_invalid;
...	...	@@ -20206,18 +20206,18 @@ static ZigType ir_analyze_instruction_bit_cast(IrAnalyze ira, IrInstructionBit
20206	20206	}
20207	20207
20208	20208	switch (dest_type->id) {
20209		case TypeTableEntryIdInvalid:
20210		case TypeTableEntryIdMetaType:
20211		case TypeTableEntryIdOpaque:
20212		case TypeTableEntryIdBoundFn:
20213		case TypeTableEntryIdArgTuple:
20214		case TypeTableEntryIdNamespace:
20215		case TypeTableEntryIdBlock:
20216		case TypeTableEntryIdUnreachable:
20217		case TypeTableEntryIdComptimeFloat:
20218		case TypeTableEntryIdComptimeInt:
20219		case TypeTableEntryIdUndefined:
20220		case TypeTableEntryIdNull:
	20209	case ZigTypeIdInvalid:
	20210	case ZigTypeIdMetaType:
	20211	case ZigTypeIdOpaque:
	20212	case ZigTypeIdBoundFn:
	20213	case ZigTypeIdArgTuple:
	20214	case ZigTypeIdNamespace:
	20215	case ZigTypeIdBlock:
	20216	case ZigTypeIdUnreachable:
	20217	case ZigTypeIdComptimeFloat:
	20218	case ZigTypeIdComptimeInt:
	20219	case ZigTypeIdUndefined:
	20220	case ZigTypeIdNull:
20221	20221	ir_add_error(ira, dest_type_value,
20222	20222	buf_sprintf("unable to @bitCast to type '%s'", buf_ptr(&dest_type->name)));
20223	20223	return ira->codegen->builtin_types.entry_invalid;
...	...	@@ -20384,7 +20384,7 @@ static ZigType ir_analyze_instruction_ptr_to_int(IrAnalyze ira, IrInstructionP
20384	20384	ConstExprValue *val = ir_resolve_const(ira, target, UndefBad);
20385	20385	if (!val)
20386	20386	return ira->codegen->builtin_types.entry_invalid;
20387		if (val->type->id == TypeTableEntryIdPointer && val->data.x_ptr.special == ConstPtrSpecialHardCodedAddr) {
	20387	if (val->type->id == ZigTypeIdPointer && val->data.x_ptr.special == ConstPtrSpecialHardCodedAddr) {
20388	20388	IrInstruction *result = ir_create_const(&ira->new_irb, instruction->base.scope,
20389	20389	instruction->base.source_node, usize);
20390	20390	bigint_init_unsigned(&result->value.data.x_bigint, val->data.x_ptr.data.hard_coded_addr.addr);
...	...	@@ -20406,10 +20406,10 @@ static ZigType ir_analyze_instruction_ptr_type(IrAnalyze ira, IrInstructionPtr
20406	20406	if (type_is_invalid(child_type))
20407	20407	return ira->codegen->builtin_types.entry_invalid;
20408	20408
20409		if (child_type->id == TypeTableEntryIdUnreachable) {
	20409	if (child_type->id == ZigTypeIdUnreachable) {
20410	20410	ir_add_error(ira, &instruction->base, buf_sprintf("pointer to noreturn not allowed"));
20411	20411	return ira->codegen->builtin_types.entry_invalid;
20412		} else if (child_type->id == TypeTableEntryIdOpaque && instruction->ptr_len == PtrLenUnknown) {
	20412	} else if (child_type->id == ZigTypeIdOpaque && instruction->ptr_len == PtrLenUnknown) {
20413	20413	ir_add_error(ira, &instruction->base, buf_sprintf("unknown-length pointer to opaque"));
20414	20414	return ira->codegen->builtin_types.entry_invalid;
20415	20415	}
...	...	@@ -20510,7 +20510,7 @@ static ZigType ir_analyze_instruction_arg_type(IrAnalyze ira, IrInstructionArg
20510	20510	if (!ir_resolve_usize(ira, arg_index_inst, &arg_index))
20511	20511	return ira->codegen->builtin_types.entry_invalid;
20512	20512
20513		if (fn_type->id != TypeTableEntryIdFn) {
	20513	if (fn_type->id != ZigTypeIdFn) {
20514	20514	ir_add_error(ira, fn_type_inst, buf_sprintf("expected function, found '%s'", buf_ptr(&fn_type->name)));
20515	20515	return ira->codegen->builtin_types.entry_invalid;
20516	20516	}
...	...	@@ -20545,14 +20545,14 @@ static ZigType ir_analyze_instruction_tag_type(IrAnalyze ira, IrInstructionTag
20545	20545	if (type_is_invalid(enum_type))
20546	20546	return ira->codegen->builtin_types.entry_invalid;
20547	20547
20548		if (enum_type->id == TypeTableEntryIdEnum) {
	20548	if (enum_type->id == ZigTypeIdEnum) {
20549	20549	if ((err = ensure_complete_type(ira->codegen, enum_type)))
20550	20550	return ira->codegen->builtin_types.entry_invalid;
20551	20551
20552	20552	ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
20553	20553	out_val->data.x_type = enum_type->data.enumeration.tag_int_type;
20554	20554	return ira->codegen->builtin_types.entry_type;
20555		} else if (enum_type->id == TypeTableEntryIdUnion) {
	20555	} else if (enum_type->id == ZigTypeIdUnion) {
20556	20556	if ((err = ensure_complete_type(ira->codegen, enum_type)))
20557	20557	return ira->codegen->builtin_types.entry_invalid;
20558	20558
...	...	@@ -20734,7 +20734,7 @@ static ZigType ir_analyze_instruction_coro_promise(IrAnalyze ira, IrInstructio
20734	20734	if (type_is_invalid(coro_handle->value.type))
20735	20735	return ira->codegen->builtin_types.entry_invalid;
20736	20736
20737		if (coro_handle->value.type->id != TypeTableEntryIdPromise \|\|
	20737	if (coro_handle->value.type->id != ZigTypeIdPromise \|\|
20738	20738	coro_handle->value.type->data.promise.result_type == nullptr)
20739	20739	{
20740	20740	ir_add_error(ira, &instruction->base, buf_sprintf("expected promise->T, found '%s'",
...	...	@@ -20774,7 +20774,7 @@ static ZigType ir_resolve_atomic_operand_type(IrAnalyze ira, IrInstruction *op
20774	20774	if (type_is_invalid(operand_type))
20775	20775	return ira->codegen->builtin_types.entry_invalid;
20776	20776
20777		if (operand_type->id == TypeTableEntryIdInt) {
	20777	if (operand_type->id == ZigTypeIdInt) {
20778	20778	if (operand_type->data.integral.bit_count < 8) {
20779	20779	ir_add_error(ira, op,
20780	20780	buf_sprintf("expected integer type 8 bits or larger, found %" PRIu32 "-bit integer type",
...	...	@@ -20907,7 +20907,7 @@ static ZigType ir_analyze_instruction_promise_result_type(IrAnalyze ira, IrIns
20907	20907	if (type_is_invalid(promise_type))
20908	20908	return ira->codegen->builtin_types.entry_invalid;
20909	20909
20910		if (promise_type->id != TypeTableEntryIdPromise \|\| promise_type->data.promise.result_type == nullptr) {
	20910	if (promise_type->id != ZigTypeIdPromise \|\| promise_type->data.promise.result_type == nullptr) {
20911	20911	ir_add_error(ira, &instruction->base, buf_sprintf("expected promise->T, found '%s'",
20912	20912	buf_ptr(&promise_type->name)));
20913	20913	return ira->codegen->builtin_types.entry_invalid;
...	...	@@ -20942,9 +20942,9 @@ static ZigType ir_analyze_instruction_merge_err_ret_traces(IrAnalyze ira,
20942	20942	if (type_is_invalid(coro_promise_ptr->value.type))
20943	20943	return ira->codegen->builtin_types.entry_invalid;
20944	20944
20945		assert(coro_promise_ptr->value.type->id == TypeTableEntryIdPointer);
	20945	assert(coro_promise_ptr->value.type->id == ZigTypeIdPointer);
20946	20946	ZigType *promise_frame_type = coro_promise_ptr->value.type->data.pointer.child_type;
20947		assert(promise_frame_type->id == TypeTableEntryIdStruct);
	20947	assert(promise_frame_type->id == ZigTypeIdStruct);
20948	20948	ZigType *promise_result_type = promise_frame_type->data.structure.fields[1].type_entry;
20949	20949
20950	20950	if (!type_can_fail(promise_result_type)) {
...	...	@@ -20997,7 +20997,7 @@ static ZigType ir_analyze_instruction_sqrt(IrAnalyze ira, IrInstructionSqrt *i
20997	20997	if (type_is_invalid(op->value.type))
20998	20998	return ira->codegen->builtin_types.entry_invalid;
20999	20999
21000		bool ok_type = float_type->id == TypeTableEntryIdComptimeFloat \|\| float_type->id == TypeTableEntryIdFloat;
	21000	bool ok_type = float_type->id == ZigTypeIdComptimeFloat \|\| float_type->id == ZigTypeIdFloat;
21001	21001	if (!ok_type) {
21002	21002	ir_add_error(ira, instruction->type, buf_sprintf("@sqrt does not support type '%s'", buf_ptr(&float_type->name)));
21003	21003	return ira->codegen->builtin_types.entry_invalid;
...	...	@@ -21014,9 +21014,9 @@ static ZigType ir_analyze_instruction_sqrt(IrAnalyze ira, IrInstructionSqrt *i
21014	21014
21015	21015	ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
21016	21016
21017		if (float_type->id == TypeTableEntryIdComptimeFloat) {
	21017	if (float_type->id == ZigTypeIdComptimeFloat) {
21018	21018	bigfloat_sqrt(&out_val->data.x_bigfloat, &val->data.x_bigfloat);
21019		} else if (float_type->id == TypeTableEntryIdFloat) {
	21019	} else if (float_type->id == ZigTypeIdFloat) {
21020	21020	switch (float_type->data.floating.bit_count) {
21021	21021	case 16:
21022	21022	out_val->data.x_f16 = f16_sqrt(val->data.x_f16);
...	...	@@ -21040,7 +21040,7 @@ static ZigType ir_analyze_instruction_sqrt(IrAnalyze ira, IrInstructionSqrt *i
21040	21040	return float_type;
21041	21041	}
21042	21042
21043		assert(float_type->id == TypeTableEntryIdFloat);
	21043	assert(float_type->id == ZigTypeIdFloat);
21044	21044	if (float_type->data.floating.bit_count != 16 &&
21045	21045	float_type->data.floating.bit_count != 32 &&
21046	21046	float_type->data.floating.bit_count != 64) {
...	...	@@ -21061,7 +21061,7 @@ static ZigType ir_analyze_instruction_enum_to_int(IrAnalyze ira, IrInstruction
21061	21061	if (type_is_invalid(target->value.type))
21062	21062	return ira->codegen->builtin_types.entry_invalid;
21063	21063
21064		if (target->value.type->id != TypeTableEntryIdEnum) {
	21064	if (target->value.type->id != ZigTypeIdEnum) {
21065	21065	ir_add_error(ira, instruction->target,
21066	21066	buf_sprintf("expected enum, found type '%s'", buf_ptr(&target->value.type->name)));
21067	21067	return ira->codegen->builtin_types.entry_invalid;
...	...	@@ -21084,7 +21084,7 @@ static ZigType ir_analyze_instruction_int_to_enum(IrAnalyze ira, IrInstruction
21084	21084	if (type_is_invalid(dest_type))
21085	21085	return ira->codegen->builtin_types.entry_invalid;
21086	21086
21087		if (dest_type->id != TypeTableEntryIdEnum) {
	21087	if (dest_type->id != ZigTypeIdEnum) {
21088	21088	ir_add_error(ira, instruction->dest_type,
21089	21089	buf_sprintf("expected enum, found type '%s'", buf_ptr(&dest_type->name)));
21090	21090	return ira->codegen->builtin_types.entry_invalid;
...	...	@@ -21420,8 +21420,8 @@ static ZigType ir_analyze_instruction(IrAnalyze ira, IrInstruction *instructio
21420	21420	if (instruction->other) {
21421	21421	instruction->other->value.type = instruction_type;
21422	21422	} else {
21423		assert(instruction_type->id == TypeTableEntryIdInvalid \|\|
21424		instruction_type->id == TypeTableEntryIdUnreachable);
	21423	assert(instruction_type->id == ZigTypeIdInvalid \|\|
	21424	instruction_type->id == ZigTypeIdUnreachable);
21425	21425	instruction->other = instruction;
21426	21426	}
21427	21427
...	...	@@ -21478,7 +21478,7 @@ ZigType ir_analyze(CodeGen codegen, IrExecutable old_exec, IrExecutable new_
21478	21478	}
21479	21479
21480	21480	// unreachable instructions do their own control flow.
21481		if (return_type->id == TypeTableEntryIdUnreachable)
	21481	if (return_type->id == ZigTypeIdUnreachable)
21482	21482	continue;
21483	21483
21484	21484	ira->instruction_index += 1;