Commit db882e5d63d2840b1410a2574fd12d973b7f3ee2 | zig

author	Andrew Kelley <andrew@ziglang.org> 2018-09-05 18:33:07-04:00
committer	Andrew Kelley <andrew@ziglang.org> 2018-09-05 18:33:07-04:00
log	db882e5d63d2840b1410a2574fd12d973b7f3ee2
tree	6316a85c4da5de1fd54b380c554d65daaf4d6700
parent	a3d384e593e9128ed3b69cc77e6d6e048f0c6bb7
signature	Commit is signed but in an unrecognized format.

stage1: rename TypeTableEntry to ZigType

6 files changed, 1137 insertions(+), 1137 deletions(-)

src/all_types.hpp+87-87

...	...	@@ -24,7 +24,7 @@ struct FnTableEntry;
24	24	struct Scope;
25	25	struct ScopeBlock;
26	26	struct ScopeFnDef;
27		struct TypeTableEntry;
	27	struct ZigType;
28	28	struct VariableTableEntry;
29	29	struct ErrorTableEntry;
30	30	struct BuiltinFnEntry;
...	...	@@ -251,7 +251,7 @@ struct ConstGlobalRefs {
251	251	};
252	252
253	253	struct ConstExprValue {
254		TypeTableEntry *type;
	254	ZigType *type;
255	255	ConstValSpecial special;
256	256	ConstGlobalRefs *global_refs;
257	257
...	...	@@ -265,7 +265,7 @@ struct ConstExprValue {
265	265	float128_t x_f128;
266	266	bool x_bool;
267	267	ConstBoundFnValue x_bound_fn;
268		TypeTableEntry *x_type;
	268	ZigType *x_type;
269	269	ConstExprValue *x_optional;
270	270	ConstErrValue x_err_union;
271	271	ErrorTableEntry *x_err_set;
...	...	@@ -353,7 +353,7 @@ struct TldContainer {
353	353	Tld base;
354	354
355	355	ScopeDecls *decls_scope;
356		TypeTableEntry *type_entry;
	356	ZigType *type_entry;
357	357	};
358	358
359	359	struct TldCompTime {
...	...	@@ -370,7 +370,7 @@ struct TypeEnumField {
370	370	struct TypeUnionField {
371	371	Buf *name;
372	372	TypeEnumField *enum_field;
373		TypeTableEntry *type_entry;
	373	ZigType *type_entry;
374	374	AstNode *decl_node;
375	375	uint32_t gen_index;
376	376	};
...	...	@@ -973,7 +973,7 @@ struct AstNode {
973	973	// this struct is allocated with allocate_nonzero
974	974	struct FnTypeParamInfo {
975	975	bool is_noalias;
976		TypeTableEntry *type;
	976	ZigType *type;
977	977	};
978	978
979	979	struct GenericFnTypeId {
...	...	@@ -986,14 +986,14 @@ uint32_t generic_fn_type_id_hash(GenericFnTypeId *id);
986	986	bool generic_fn_type_id_eql(GenericFnTypeId a, GenericFnTypeId b);
987	987
988	988	struct FnTypeId {
989		TypeTableEntry *return_type;
	989	ZigType *return_type;
990	990	FnTypeParamInfo *param_info;
991	991	size_t param_count;
992	992	size_t next_param_index;
993	993	bool is_var_args;
994	994	CallingConvention cc;
995	995	uint32_t alignment;
996		TypeTableEntry *async_allocator_type;
	996	ZigType *async_allocator_type;
997	997	};
998	998
999	999	uint32_t fn_type_id_hash(FnTypeId*);
...	...	@@ -1005,14 +1005,14 @@ enum PtrLen {
1005	1005	};
1006	1006
1007	1007	struct TypeTableEntryPointer {
1008		TypeTableEntry *child_type;
	1008	ZigType *child_type;
1009	1009	PtrLen ptr_len;
1010	1010	bool is_const;
1011	1011	bool is_volatile;
1012	1012	uint32_t alignment;
1013	1013	uint32_t bit_offset;
1014	1014	uint32_t unaligned_bit_count;
1015		TypeTableEntry *slice_parent;
	1015	ZigType *slice_parent;
1016	1016	};
1017	1017
1018	1018	struct TypeTableEntryInt {
...	...	@@ -1025,13 +1025,13 @@ struct TypeTableEntryFloat {
1025	1025	};
1026	1026
1027	1027	struct TypeTableEntryArray {
1028		TypeTableEntry *child_type;
	1028	ZigType *child_type;
1029	1029	uint64_t len;
1030	1030	};
1031	1031
1032	1032	struct TypeStructField {
1033	1033	Buf *name;
1034		TypeTableEntry *type_entry;
	1034	ZigType *type_entry;
1035	1035	size_t src_index;
1036	1036	size_t gen_index;
1037	1037	// offset from the memory at gen_index
...	...	@@ -1069,12 +1069,12 @@ struct TypeTableEntryStruct {
1069	1069	};
1070	1070
1071	1071	struct TypeTableEntryOptional {
1072		TypeTableEntry *child_type;
	1072	ZigType *child_type;
1073	1073	};
1074	1074
1075	1075	struct TypeTableEntryErrorUnion {
1076		TypeTableEntry *err_set_type;
1077		TypeTableEntry *payload_type;
	1076	ZigType *err_set_type;
	1077	ZigType *payload_type;
1078	1078	};
1079	1079
1080	1080	struct TypeTableEntryErrorSet {
...	...	@@ -1089,7 +1089,7 @@ struct TypeTableEntryEnum {
1089	1089	uint32_t src_field_count;
1090	1090	TypeEnumField *fields;
1091	1091	bool is_invalid; // true if any fields are invalid
1092		TypeTableEntry *tag_int_type;
	1092	ZigType *tag_int_type;
1093	1093
1094	1094	ScopeDecls *decls_scope;
1095	1095
...	...	@@ -1107,8 +1107,8 @@ struct TypeTableEntryEnum {
1107	1107	HashMap<Buf , TypeEnumField , buf_hash, buf_eql_buf> fields_by_name;
1108	1108	};
1109	1109
1110		uint32_t type_ptr_hash(const TypeTableEntry *ptr);
1111		bool type_ptr_eql(const TypeTableEntry a, const TypeTableEntry b);
	1110	uint32_t type_ptr_hash(const ZigType *ptr);
	1111	bool type_ptr_eql(const ZigType a, const ZigType b);
1112	1112
1113	1113	struct TypeTableEntryUnion {
1114	1114	AstNode *decl_node;
...	...	@@ -1117,7 +1117,7 @@ struct TypeTableEntryUnion {
1117	1117	uint32_t gen_field_count;
1118	1118	TypeUnionField *fields;
1119	1119	bool is_invalid; // true if any fields are invalid
1120		TypeTableEntry *tag_type; // always an enum or null
	1120	ZigType *tag_type; // always an enum or null
1121	1121	LLVMTypeRef union_type_ref;
1122	1122
1123	1123	ScopeDecls *decls_scope;
...	...	@@ -1142,7 +1142,7 @@ struct TypeTableEntryUnion {
1142	1142	bool have_explicit_tag_type;
1143	1143
1144	1144	uint32_t union_size_bytes;
1145		TypeTableEntry *most_aligned_union_member;
	1145	ZigType *most_aligned_union_member;
1146	1146
1147	1147	HashMap<Buf , TypeUnionField , buf_hash, buf_eql_buf> fields_by_name;
1148	1148	};
...	...	@@ -1151,31 +1151,31 @@ struct FnGenParamInfo {
1151	1151	size_t src_index;
1152	1152	size_t gen_index;
1153	1153	bool is_byval;
1154		TypeTableEntry *type;
	1154	ZigType *type;
1155	1155	};
1156	1156
1157	1157	struct TypeTableEntryFn {
1158	1158	FnTypeId fn_type_id;
1159	1159	bool is_generic;
1160		TypeTableEntry *gen_return_type;
	1160	ZigType *gen_return_type;
1161	1161	size_t gen_param_count;
1162	1162	FnGenParamInfo *gen_param_info;
1163	1163
1164	1164	LLVMTypeRef raw_type_ref;
1165	1165
1166		TypeTableEntry *bound_fn_parent;
	1166	ZigType *bound_fn_parent;
1167	1167	};
1168	1168
1169	1169	struct TypeTableEntryBoundFn {
1170		TypeTableEntry *fn_type;
	1170	ZigType *fn_type;
1171	1171	};
1172	1172
1173	1173	struct TypeTableEntryPromise {
1174	1174	// null if `promise` instead of `promise->T`
1175		TypeTableEntry *result_type;
	1175	ZigType *result_type;
1176	1176	};
1177	1177
1178		enum TypeTableEntryId {
	1178	enum ZigTypeId {
1179	1179	TypeTableEntryIdInvalid,
1180	1180	TypeTableEntryIdMetaType,
1181	1181	TypeTableEntryIdVoid,
...	...	@@ -1204,8 +1204,8 @@ enum TypeTableEntryId {
1204	1204	TypeTableEntryIdPromise,
1205	1205	};
1206	1206
1207		struct TypeTableEntry {
1208		TypeTableEntryId id;
	1207	struct ZigType {
	1208	ZigTypeId id;
1209	1209	Buf name;
1210	1210
1211	1211	LLVMTypeRef type_ref;
...	...	@@ -1232,10 +1232,10 @@ struct TypeTableEntry {
1232	1232	} data;
1233	1233
1234	1234	// use these fields to make sure we don't duplicate type table entries for the same type
1235		TypeTableEntry *pointer_parent[2]; // [0 - mut, 1 - const]
1236		TypeTableEntry *optional_parent;
1237		TypeTableEntry *promise_parent;
1238		TypeTableEntry *promise_frame_parent;
	1235	ZigType *pointer_parent[2]; // [0 - mut, 1 - const]
	1236	ZigType *optional_parent;
	1237	ZigType *promise_parent;
	1238	ZigType *promise_frame_parent;
1239	1239	// If we generate a constant name value for this type, we memoize it here.
1240	1240	// The type of this is array
1241	1241	ConstExprValue *cached_const_name_val;
...	...	@@ -1291,11 +1291,11 @@ struct FnTableEntry {
1291	1291	Scope *child_scope; // parent is scope for last parameter
1292	1292	ScopeBlock *def_scope; // parent is child_scope
1293	1293	Buf symbol_name;
1294		TypeTableEntry *type_entry; // function type
	1294	ZigType *type_entry; // function type
1295	1295	// in the case of normal functions this is the implicit return type
1296	1296	// in the case of async functions this is the implicit return type according to the
1297	1297	// zig source code, not according to zig ir
1298		TypeTableEntry *src_implicit_return_type;
	1298	ZigType *src_implicit_return_type;
1299	1299	bool is_test;
1300	1300	FnInline fn_inline;
1301	1301	FnAnalState anal_state;
...	...	@@ -1445,11 +1445,11 @@ uint32_t fn_eval_hash(Scope*);
1445	1445	bool fn_eval_eql(Scope a, Scope b);
1446	1446
1447	1447	struct TypeId {
1448		TypeTableEntryId id;
	1448	ZigTypeId id;
1449	1449
1450	1450	union {
1451	1451	struct {
1452		TypeTableEntry *child_type;
	1452	ZigType *child_type;
1453	1453	PtrLen ptr_len;
1454	1454	bool is_const;
1455	1455	bool is_volatile;
...	...	@@ -1458,7 +1458,7 @@ struct TypeId {
1458	1458	uint32_t unaligned_bit_count;
1459	1459	} pointer;
1460	1460	struct {
1461		TypeTableEntry *child_type;
	1461	ZigType *child_type;
1462	1462	uint64_t size;
1463	1463	} array;
1464	1464	struct {
...	...	@@ -1466,8 +1466,8 @@ struct TypeId {
1466	1466	uint32_t bit_count;
1467	1467	} integer;
1468	1468	struct {
1469		TypeTableEntry *err_set_type;
1470		TypeTableEntry *payload_type;
	1469	ZigType *err_set_type;
	1470	ZigType *payload_type;
1471	1471	} error_union;
1472	1472	} data;
1473	1473	};
...	...	@@ -1563,9 +1563,9 @@ struct CodeGen {
1563	1563	// reminder: hash tables must be initialized before use
1564	1564	HashMap<Buf , ImportTableEntry , buf_hash, buf_eql_buf> import_table;
1565	1565	HashMap<Buf , BuiltinFnEntry , buf_hash, buf_eql_buf> builtin_fn_table;
1566		HashMap<Buf , TypeTableEntry , buf_hash, buf_eql_buf> primitive_type_table;
1567		HashMap<TypeId, TypeTableEntry *, type_id_hash, type_id_eql> type_table;
1568		HashMap<FnTypeId , TypeTableEntry , fn_type_id_hash, fn_type_id_eql> fn_type_table;
	1566	HashMap<Buf , ZigType , buf_hash, buf_eql_buf> primitive_type_table;
	1567	HashMap<TypeId, ZigType *, type_id_hash, type_id_eql> type_table;
	1568	HashMap<FnTypeId , ZigType , fn_type_id_hash, fn_type_id_eql> fn_type_table;
1569	1569	HashMap<Buf , ErrorTableEntry , buf_hash, buf_eql_buf> error_table;
1570	1570	HashMap<GenericFnTypeId , FnTableEntry , generic_fn_type_id_hash, generic_fn_type_id_eql> generic_table;
1571	1571	HashMap<Scope , IrInstruction , fn_eval_hash, fn_eval_eql> memoized_fn_eval_table;
...	...	@@ -1573,7 +1573,7 @@ struct CodeGen {
1573	1573	HashMap<Buf , AstNode , buf_hash, buf_eql_buf> exported_symbol_names;
1574	1574	HashMap<Buf , Tld , buf_hash, buf_eql_buf> external_prototypes;
1575	1575	HashMap<Buf , ConstExprValue , buf_hash, buf_eql_buf> string_literals_table;
1576		HashMap<const TypeTableEntry , ConstExprValue , type_ptr_hash, type_ptr_eql> type_info_cache;
	1576	HashMap<const ZigType , ConstExprValue , type_ptr_hash, type_ptr_eql> type_info_cache;
1577	1577
1578	1578
1579	1579	ZigList<ImportTableEntry *> import_queue;
...	...	@@ -1586,38 +1586,38 @@ struct CodeGen {
1586	1586	uint32_t next_unresolved_index;
1587	1587
1588	1588	struct {
1589		TypeTableEntry *entry_bool;
1590		TypeTableEntry *entry_c_int[CIntTypeCount];
1591		TypeTableEntry *entry_c_longdouble;
1592		TypeTableEntry *entry_c_void;
1593		TypeTableEntry *entry_u8;
1594		TypeTableEntry *entry_u16;
1595		TypeTableEntry *entry_u32;
1596		TypeTableEntry *entry_u29;
1597		TypeTableEntry *entry_u64;
1598		TypeTableEntry *entry_i8;
1599		TypeTableEntry *entry_i32;
1600		TypeTableEntry *entry_i64;
1601		TypeTableEntry *entry_isize;
1602		TypeTableEntry *entry_usize;
1603		TypeTableEntry *entry_f16;
1604		TypeTableEntry *entry_f32;
1605		TypeTableEntry *entry_f64;
1606		TypeTableEntry *entry_f128;
1607		TypeTableEntry *entry_void;
1608		TypeTableEntry *entry_unreachable;
1609		TypeTableEntry *entry_type;
1610		TypeTableEntry *entry_invalid;
1611		TypeTableEntry *entry_namespace;
1612		TypeTableEntry *entry_block;
1613		TypeTableEntry *entry_num_lit_int;
1614		TypeTableEntry *entry_num_lit_float;
1615		TypeTableEntry *entry_undef;
1616		TypeTableEntry *entry_null;
1617		TypeTableEntry *entry_var;
1618		TypeTableEntry *entry_global_error_set;
1619		TypeTableEntry *entry_arg_tuple;
1620		TypeTableEntry *entry_promise;
	1589	ZigType *entry_bool;
	1590	ZigType *entry_c_int[CIntTypeCount];
	1591	ZigType *entry_c_longdouble;
	1592	ZigType *entry_c_void;
	1593	ZigType *entry_u8;
	1594	ZigType *entry_u16;
	1595	ZigType *entry_u32;
	1596	ZigType *entry_u29;
	1597	ZigType *entry_u64;
	1598	ZigType *entry_i8;
	1599	ZigType *entry_i32;
	1600	ZigType *entry_i64;
	1601	ZigType *entry_isize;
	1602	ZigType *entry_usize;
	1603	ZigType *entry_f16;
	1604	ZigType *entry_f32;
	1605	ZigType *entry_f64;
	1606	ZigType *entry_f128;
	1607	ZigType *entry_void;
	1608	ZigType *entry_unreachable;
	1609	ZigType *entry_type;
	1610	ZigType *entry_invalid;
	1611	ZigType *entry_namespace;
	1612	ZigType *entry_block;
	1613	ZigType *entry_num_lit_int;
	1614	ZigType *entry_num_lit_float;
	1615	ZigType *entry_undef;
	1616	ZigType *entry_null;
	1617	ZigType *entry_var;
	1618	ZigType *entry_global_error_set;
	1619	ZigType *entry_arg_tuple;
	1620	ZigType *entry_promise;
1621	1621	} builtin_types;
1622	1622
1623	1623	EmitFileType emit_file_type;
...	...	@@ -1735,11 +1735,11 @@ struct CodeGen {
1735	1735	size_t llvm_argv_len;
1736	1736
1737	1737	ZigList<FnTableEntry *> test_fns;
1738		TypeTableEntry *test_fn_type;
	1738	ZigType *test_fn_type;
1739	1739
1740	1740	bool each_lib_rpath;
1741	1741
1742		TypeTableEntry *err_tag_type;
	1742	ZigType *err_tag_type;
1743	1743	ZigList<ZigLLVMDIEnumerator *> err_enumerators;
1744	1744	ZigList<ErrorTableEntry *> errors_by_index;
1745	1745	bool generate_error_name_table;
...	...	@@ -1769,9 +1769,9 @@ struct CodeGen {
1769	1769	ZigList<FnTableEntry *> inline_fns;
1770	1770	ZigList<AstNode *> tld_ref_source_node_stack;
1771	1771
1772		TypeTableEntry *align_amt_type;
1773		TypeTableEntry *stack_trace_type;
1774		TypeTableEntry *ptr_to_stack_trace_type;
	1772	ZigType *align_amt_type;
	1773	ZigType *stack_trace_type;
	1774	ZigType *ptr_to_stack_trace_type;
1775	1775
1776	1776	ZigList<ZigLLVMDIType **> error_di_types;
1777	1777
...	...	@@ -1818,7 +1818,7 @@ struct ErrorTableEntry {
1818	1818	Buf name;
1819	1819	uint32_t value;
1820	1820	AstNode *decl_node;
1821		TypeTableEntry *set_with_only_this_in_it;
	1821	ZigType *set_with_only_this_in_it;
1822	1822	// If we generate a constant error name value for this error, we memoize it here.
1823	1823	// The type of this is array
1824	1824	ConstExprValue *cached_error_name_val;
...	...	@@ -1862,7 +1862,7 @@ struct ScopeDecls {
1862	1862	AstNode *fast_math_set_node;
1863	1863	ImportTableEntry *import;
1864	1864	// If this is a scope from a container, this is the type entry, otherwise null
1865		TypeTableEntry *container_type;
	1865	ZigType *container_type;
1866	1866	};
1867	1867
1868	1868	// This scope comes from a block expression in user code.
...	...	@@ -2386,7 +2386,7 @@ struct IrInstructionCast {
2386	2386	IrInstruction base;
2387	2387
2388	2388	IrInstruction *value;
2389		TypeTableEntry *dest_type;
	2389	ZigType *dest_type;
2390	2390	CastOp cast_op;
2391	2391	LLVMValueRef tmp_ptr;
2392	2392	};
...	...	@@ -2423,7 +2423,7 @@ struct IrInstructionStructInitField {
2423	2423	struct IrInstructionStructInit {
2424	2424	IrInstruction base;
2425	2425
2426		TypeTableEntry *struct_type;
	2426	ZigType *struct_type;
2427	2427	size_t field_count;
2428	2428	IrInstructionStructInitField *fields;
2429	2429	LLVMValueRef tmp_ptr;
...	...	@@ -2432,7 +2432,7 @@ struct IrInstructionStructInit {
2432	2432	struct IrInstructionUnionInit {
2433	2433	IrInstruction base;
2434	2434
2435		TypeTableEntry *union_type;
	2435	ZigType *union_type;
2436	2436	TypeUnionField *field;
2437	2437	IrInstruction *init_value;
2438	2438	LLVMValueRef tmp_ptr;
...	...	@@ -2661,7 +2661,7 @@ struct IrInstructionCmpxchg {
2661	2661	IrInstruction *failure_order_value;
2662	2662
2663	2663	// if this instruction gets to runtime then we know these values:
2664		TypeTableEntry *type;
	2664	ZigType *type;
2665	2665	AtomicOrder success_order;
2666	2666	AtomicOrder failure_order;
2667	2667
...	...	@@ -2831,7 +2831,7 @@ struct IrInstructionOverflowOp {
2831	2831	IrInstruction *op2;
2832	2832	IrInstruction *result_ptr;
2833	2833
2834		TypeTableEntry *result_ptr_type;
	2834	ZigType *result_ptr_type;
2835	2835	};
2836	2836
2837	2837	struct IrInstructionAlignOf {

src/analyze.cpp+217-217

...	...	@@ -19,12 +19,12 @@
19	19
20	20	static const size_t default_backward_branch_quota = 1000;
21	21
22		static Error resolve_enum_type(CodeGen g, TypeTableEntry enum_type);
23		static Error resolve_struct_type(CodeGen g, TypeTableEntry struct_type);
	22	static Error resolve_enum_type(CodeGen g, ZigType enum_type);
	23	static Error resolve_struct_type(CodeGen g, ZigType struct_type);
24	24
25		static Error ATTRIBUTE_MUST_USE resolve_struct_zero_bits(CodeGen g, TypeTableEntry struct_type);
26		static Error ATTRIBUTE_MUST_USE resolve_enum_zero_bits(CodeGen g, TypeTableEntry enum_type);
27		static Error ATTRIBUTE_MUST_USE resolve_union_zero_bits(CodeGen g, TypeTableEntry union_type);
	25	static Error ATTRIBUTE_MUST_USE resolve_struct_zero_bits(CodeGen g, ZigType struct_type);
	26	static Error ATTRIBUTE_MUST_USE resolve_enum_zero_bits(CodeGen g, ZigType enum_type);
	27	static Error ATTRIBUTE_MUST_USE resolve_union_zero_bits(CodeGen g, ZigType union_type);
28	28	static void analyze_fn_body(CodeGen g, FnTableEntry fn_table_entry);
29	29
30	30	ErrorMsg add_node_error(CodeGen g, AstNode node, Buf msg) {
...	...	@@ -70,13 +70,13 @@ ErrorMsg add_error_note(CodeGen g, ErrorMsg parent_msg, AstNode node, Buf *m
70	70	return err;
71	71	}
72	72
73		TypeTableEntry *new_type_table_entry(TypeTableEntryId id) {
74		TypeTableEntry *entry = allocate<TypeTableEntry>(1);
	73	ZigType *new_type_table_entry(ZigTypeId id) {
	74	ZigType *entry = allocate<ZigType>(1);
75	75	entry->id = id;
76	76	return entry;
77	77	}
78	78
79		static ScopeDecls *get_container_scope_ptr(TypeTableEntry type_entry) {
	79	static ScopeDecls *get_container_scope_ptr(ZigType type_entry) {
80	80	if (type_entry->id == TypeTableEntryIdStruct) {
81	81	return &type_entry->data.structure.decls_scope;
82	82	} else if (type_entry->id == TypeTableEntryIdEnum) {
...	...	@@ -87,7 +87,7 @@ static ScopeDecls *get_container_scope_ptr(TypeTableEntry type_entry) {
87	87	zig_unreachable();
88	88	}
89	89
90		ScopeDecls get_container_scope(TypeTableEntry type_entry) {
	90	ScopeDecls get_container_scope(ZigType type_entry) {
91	91	return *get_container_scope_ptr(type_entry);
92	92	}
93	93
...	...	@@ -97,7 +97,7 @@ void init_scope(Scope dest, ScopeId id, AstNode source_node, Scope *parent) {
97	97	dest->parent = parent;
98	98	}
99	99
100		ScopeDecls create_decls_scope(AstNode node, Scope parent, TypeTableEntry container_type, ImportTableEntry *import) {
	100	ScopeDecls create_decls_scope(AstNode node, Scope parent, ZigType container_type, ImportTableEntry *import) {
101	101	assert(node == nullptr \|\| node->type == NodeTypeRoot \|\| node->type == NodeTypeContainerDecl \|\| node->type == NodeTypeFnCallExpr);
102	102	ScopeDecls *scope = allocate<ScopeDecls>(1);
103	103	init_scope(&scope->base, ScopeIdDecls, node, parent);
...	...	@@ -203,8 +203,8 @@ ImportTableEntry get_scope_import(Scope scope) {
203	203	zig_unreachable();
204	204	}
205	205
206		static TypeTableEntry new_container_type_entry(TypeTableEntryId id, AstNode source_node, Scope *parent_scope) {
207		TypeTableEntry *entry = new_type_table_entry(id);
	206	static ZigType new_container_type_entry(ZigTypeId id, AstNode source_node, Scope *parent_scope) {
	207	ZigType *entry = new_type_table_entry(id);
208	208	*get_container_scope_ptr(entry) = create_decls_scope(source_node, parent_scope, entry, get_scope_import(parent_scope));
209	209	return entry;
210	210	}
...	...	@@ -218,7 +218,7 @@ static uint8_t bits_needed_for_unsigned(uint64_t x) {
218	218	return (upper >= x) ? base : (base + 1);
219	219	}
220	220
221		AstNode type_decl_node(TypeTableEntry type_entry) {
	221	AstNode type_decl_node(ZigType type_entry) {
222	222	switch (type_entry->id) {
223	223	case TypeTableEntryIdInvalid:
224	224	zig_unreachable();
...	...	@@ -255,7 +255,7 @@ AstNode type_decl_node(TypeTableEntry type_entry) {
255	255	zig_unreachable();
256	256	}
257	257
258		bool type_is_complete(TypeTableEntry *type_entry) {
	258	bool type_is_complete(ZigType *type_entry) {
259	259	switch (type_entry->id) {
260	260	case TypeTableEntryIdInvalid:
261	261	zig_unreachable();
...	...	@@ -293,7 +293,7 @@ bool type_is_complete(TypeTableEntry *type_entry) {
293	293	zig_unreachable();
294	294	}
295	295
296		bool type_has_zero_bits_known(TypeTableEntry *type_entry) {
	296	bool type_has_zero_bits_known(ZigType *type_entry) {
297	297	switch (type_entry->id) {
298	298	case TypeTableEntryIdInvalid:
299	299	zig_unreachable();
...	...	@@ -331,7 +331,7 @@ bool type_has_zero_bits_known(TypeTableEntry *type_entry) {
331	331	}
332	332
333	333
334		uint64_t type_size(CodeGen g, TypeTableEntry type_entry) {
	334	uint64_t type_size(CodeGen g, ZigType type_entry) {
335	335	assert(type_is_complete(type_entry));
336	336
337	337	if (!type_has_bits(type_entry))
...	...	@@ -341,7 +341,7 @@ uint64_t type_size(CodeGen g, TypeTableEntry type_entry) {
341	341	uint64_t size_in_bits = type_size_bits(g, type_entry);
342	342	return (size_in_bits + 7) / 8;
343	343	} else if (type_entry->id == TypeTableEntryIdArray) {
344		TypeTableEntry *child_type = type_entry->data.array.child_type;
	344	ZigType *child_type = type_entry->data.array.child_type;
345	345	if (child_type->id == TypeTableEntryIdStruct &&
346	346	child_type->data.structure.layout == ContainerLayoutPacked)
347	347	{
...	...	@@ -353,7 +353,7 @@ uint64_t type_size(CodeGen g, TypeTableEntry type_entry) {
353	353	return LLVMStoreSizeOfType(g->target_data_ref, type_entry->type_ref);
354	354	}
355	355
356		uint64_t type_size_bits(CodeGen g, TypeTableEntry type_entry) {
	356	uint64_t type_size_bits(CodeGen g, ZigType type_entry) {
357	357	assert(type_is_complete(type_entry));
358	358
359	359	if (!type_has_bits(type_entry))
...	...	@@ -366,7 +366,7 @@ uint64_t type_size_bits(CodeGen g, TypeTableEntry type_entry) {
366	366	}
367	367	return result;
368	368	} else if (type_entry->id == TypeTableEntryIdArray) {
369		TypeTableEntry *child_type = type_entry->data.array.child_type;
	369	ZigType *child_type = type_entry->data.array.child_type;
370	370	if (child_type->id == TypeTableEntryIdStruct &&
371	371	child_type->data.structure.layout == ContainerLayoutPacked)
372	372	{
...	...	@@ -377,7 +377,7 @@ uint64_t type_size_bits(CodeGen g, TypeTableEntry type_entry) {
377	377	return LLVMSizeOfTypeInBits(g->target_data_ref, type_entry->type_ref);
378	378	}
379	379
380		Result<bool> type_is_copyable(CodeGen g, TypeTableEntry type_entry) {
	380	Result<bool> type_is_copyable(CodeGen g, ZigType type_entry) {
381	381	Error err;
382	382	if ((err = type_ensure_zero_bits_known(g, type_entry)))
383	383	return err;
...	...	@@ -394,23 +394,23 @@ Result<bool> type_is_copyable(CodeGen g, TypeTableEntry type_entry) {
394	394	return type_entry->is_copyable;
395	395	}
396	396
397		static bool is_slice(TypeTableEntry *type) {
	397	static bool is_slice(ZigType *type) {
398	398	return type->id == TypeTableEntryIdStruct && type->data.structure.is_slice;
399	399	}
400	400
401		TypeTableEntry get_smallest_unsigned_int_type(CodeGen g, uint64_t x) {
	401	ZigType get_smallest_unsigned_int_type(CodeGen g, uint64_t x) {
402	402	return get_int_type(g, false, bits_needed_for_unsigned(x));
403	403	}
404	404
405		TypeTableEntry get_promise_type(CodeGen g, TypeTableEntry *result_type) {
	405	ZigType get_promise_type(CodeGen g, ZigType *result_type) {
406	406	if (result_type != nullptr && result_type->promise_parent != nullptr) {
407	407	return result_type->promise_parent;
408	408	} else if (result_type == nullptr && g->builtin_types.entry_promise != nullptr) {
409	409	return g->builtin_types.entry_promise;
410	410	}
411	411
412		TypeTableEntry *u8_ptr_type = get_pointer_to_type(g, g->builtin_types.entry_u8, false);
413		TypeTableEntry *entry = new_type_table_entry(TypeTableEntryIdPromise);
	412	ZigType *u8_ptr_type = get_pointer_to_type(g, g->builtin_types.entry_u8, false);
	413	ZigType *entry = new_type_table_entry(TypeTableEntryIdPromise);
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;
...	...	@@ -428,14 +428,14 @@ TypeTableEntry get_promise_type(CodeGen g, TypeTableEntry *result_type) {
428	428	return entry;
429	429	}
430	430
431		TypeTableEntry get_pointer_to_type_extra(CodeGen g, TypeTableEntry *child_type, bool is_const,
	431	ZigType get_pointer_to_type_extra(CodeGen g, ZigType *child_type, bool is_const,
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	435	assert(ptr_len == PtrLenSingle \|\| child_type->id != TypeTableEntryIdOpaque);
436	436
437	437	TypeId type_id = {};
438		TypeTableEntry **parent_pointer = nullptr;
	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	441	type_id.id = TypeTableEntryIdPointer;
...	...	@@ -461,7 +461,7 @@ TypeTableEntry get_pointer_to_type_extra(CodeGen g, TypeTableEntry *child_type
461	461
462	462	assertNoError(type_ensure_zero_bits_known(g, child_type));
463	463
464		TypeTableEntry *entry = new_type_table_entry(TypeTableEntryIdPointer);
	464	ZigType *entry = new_type_table_entry(TypeTableEntryIdPointer);
465	465	entry->is_copyable = true;
466	466
467	467	const char star_str = ptr_len == PtrLenSingle ? "" : "[*]";
...	...	@@ -487,7 +487,7 @@ TypeTableEntry get_pointer_to_type_extra(CodeGen g, TypeTableEntry *child_type
487	487	if (is_const \|\| is_volatile \|\| unaligned_bit_count != 0 \|\| byte_alignment != abi_alignment \|\|
488	488	ptr_len != PtrLenSingle)
489	489	{
490		TypeTableEntry *peer_type = get_pointer_to_type(g, child_type, false);
	490	ZigType *peer_type = get_pointer_to_type(g, child_type, false);
491	491	entry->type_ref = peer_type->type_ref;
492	492	entry->di_type = peer_type->di_type;
493	493	} else {
...	...	@@ -520,18 +520,18 @@ TypeTableEntry get_pointer_to_type_extra(CodeGen g, TypeTableEntry *child_type
520	520	return entry;
521	521	}
522	522
523		TypeTableEntry get_pointer_to_type(CodeGen g, TypeTableEntry *child_type, bool is_const) {
	523	ZigType get_pointer_to_type(CodeGen g, ZigType *child_type, bool is_const) {
524	524	return get_pointer_to_type_extra(g, child_type, is_const, false, PtrLenSingle,
525	525	get_abi_alignment(g, child_type), 0, 0);
526	526	}
527	527
528		TypeTableEntry get_promise_frame_type(CodeGen g, TypeTableEntry *return_type) {
	528	ZigType get_promise_frame_type(CodeGen g, ZigType *return_type) {
529	529	if (return_type->promise_frame_parent != nullptr) {
530	530	return return_type->promise_frame_parent;
531	531	}
532	532
533		TypeTableEntry *atomic_state_type = g->builtin_types.entry_usize;
534		TypeTableEntry *result_ptr_type = get_pointer_to_type(g, return_type, false);
	533	ZigType *atomic_state_type = g->builtin_types.entry_usize;
	534	ZigType *result_ptr_type = get_pointer_to_type(g, return_type, false);
535	535
536	536	ZigList<const char *> field_names = {};
537	537	field_names.append(ATOMIC_STATE_FIELD_NAME);
...	...	@@ -543,7 +543,7 @@ TypeTableEntry get_promise_frame_type(CodeGen g, TypeTableEntry *return_type)
543	543	field_names.append(RETURN_ADDRESSES_FIELD_NAME);
544	544	}
545	545
546		ZigList<TypeTableEntry *> field_types = {};
	546	ZigList<ZigType *> field_types = {};
547	547	field_types.append(atomic_state_type);
548	548	field_types.append(return_type);
549	549	field_types.append(result_ptr_type);
...	...	@@ -555,20 +555,20 @@ TypeTableEntry get_promise_frame_type(CodeGen g, TypeTableEntry *return_type)
555	555
556	556	assert(field_names.length == field_types.length);
557	557	Buf *name = buf_sprintf("AsyncFramePromise(%s)", buf_ptr(&return_type->name));
558		TypeTableEntry *entry = get_struct_type(g, buf_ptr(name), field_names.items, field_types.items, field_names.length);
	558	ZigType *entry = get_struct_type(g, buf_ptr(name), field_names.items, field_types.items, field_names.length);
559	559
560	560	return_type->promise_frame_parent = entry;
561	561	return entry;
562	562	}
563	563
564		TypeTableEntry get_optional_type(CodeGen g, TypeTableEntry *child_type) {
	564	ZigType get_optional_type(CodeGen g, ZigType *child_type) {
565	565	if (child_type->optional_parent) {
566		TypeTableEntry *entry = child_type->optional_parent;
	566	ZigType *entry = child_type->optional_parent;
567	567	return entry;
568	568	} else {
569	569	assertNoError(ensure_complete_type(g, child_type));
570	570
571		TypeTableEntry *entry = new_type_table_entry(TypeTableEntryIdOptional);
	571	ZigType *entry = new_type_table_entry(TypeTableEntryIdOptional);
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
...	...	@@ -606,7 +606,7 @@ TypeTableEntry get_optional_type(CodeGen g, TypeTableEntry *child_type) {
606	606	uint64_t val_debug_align_in_bits = 8*LLVMABISizeOfType(g->target_data_ref, child_type->type_ref);
607	607	uint64_t val_offset_in_bits = 8*LLVMOffsetOfElement(g->target_data_ref, entry->type_ref, 0);
608	608
609		TypeTableEntry *bool_type = g->builtin_types.entry_bool;
	609	ZigType *bool_type = g->builtin_types.entry_bool;
610	610	uint64_t maybe_debug_size_in_bits = 8*LLVMStoreSizeOfType(g->target_data_ref, bool_type->type_ref);
611	611	uint64_t maybe_debug_align_in_bits = 8*LLVMABISizeOfType(g->target_data_ref, bool_type->type_ref);
612	612	uint64_t maybe_offset_in_bits = 8*LLVMOffsetOfElement(g->target_data_ref, entry->type_ref, 1);
...	...	@@ -645,7 +645,7 @@ TypeTableEntry get_optional_type(CodeGen g, TypeTableEntry *child_type) {
645	645	}
646	646	}
647	647
648		TypeTableEntry get_error_union_type(CodeGen g, TypeTableEntry err_set_type, TypeTableEntry payload_type) {
	648	ZigType get_error_union_type(CodeGen g, ZigType err_set_type, ZigType payload_type) {
649	649	assert(err_set_type->id == TypeTableEntryIdErrorSet);
650	650	assert(!type_is_invalid(payload_type));
651	651
...	...	@@ -659,7 +659,7 @@ TypeTableEntry get_error_union_type(CodeGen g, TypeTableEntry *err_set_type, T
659	659	return existing_entry->value;
660	660	}
661	661
662		TypeTableEntry *entry = new_type_table_entry(TypeTableEntryIdErrorUnion);
	662	ZigType *entry = new_type_table_entry(TypeTableEntryIdErrorUnion);
663	663	entry->is_copyable = true;
664	664	assert(payload_type->di_type);
665	665	assertNoError(ensure_complete_type(g, payload_type));
...	...	@@ -740,20 +740,20 @@ TypeTableEntry get_error_union_type(CodeGen g, TypeTableEntry *err_set_type, T
740	740	return entry;
741	741	}
742	742
743		TypeTableEntry get_array_type(CodeGen g, TypeTableEntry *child_type, uint64_t array_size) {
	743	ZigType get_array_type(CodeGen g, ZigType *child_type, uint64_t array_size) {
744	744	TypeId type_id = {};
745	745	type_id.id = TypeTableEntryIdArray;
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);
749	749	if (existing_entry) {
750		TypeTableEntry *entry = existing_entry->value;
	750	ZigType *entry = existing_entry->value;
751	751	return entry;
752	752	}
753	753
754	754	assertNoError(ensure_complete_type(g, child_type));
755	755
756		TypeTableEntry *entry = new_type_table_entry(TypeTableEntryIdArray);
	756	ZigType *entry = new_type_table_entry(TypeTableEntryIdArray);
757	757	entry->zero_bits = (array_size == 0) \|\| child_type->zero_bits;
758	758	entry->is_copyable = false;
759	759
...	...	@@ -780,7 +780,7 @@ TypeTableEntry get_array_type(CodeGen g, TypeTableEntry *child_type, uint64_t
780	780	return entry;
781	781	}
782	782
783		static void slice_type_common_init(CodeGen g, TypeTableEntry pointer_type, TypeTableEntry *entry) {
	783	static void slice_type_common_init(CodeGen g, ZigType pointer_type, ZigType *entry) {
784	784	unsigned element_count = 2;
785	785	Buf *ptr_field_name = buf_create_from_str("ptr");
786	786	Buf *len_field_name = buf_create_from_str("len");
...	...	@@ -811,16 +811,16 @@ static void slice_type_common_init(CodeGen g, TypeTableEntry pointer_type, Typ
811	811	}
812	812	}
813	813
814		TypeTableEntry get_slice_type(CodeGen g, TypeTableEntry *ptr_type) {
	814	ZigType get_slice_type(CodeGen g, ZigType *ptr_type) {
815	815	assert(ptr_type->id == TypeTableEntryIdPointer);
816	816	assert(ptr_type->data.pointer.ptr_len == PtrLenUnknown);
817	817
818		TypeTableEntry **parent_pointer = &ptr_type->data.pointer.slice_parent;
	818	ZigType **parent_pointer = &ptr_type->data.pointer.slice_parent;
819	819	if (*parent_pointer) {
820	820	return *parent_pointer;
821	821	}
822	822
823		TypeTableEntry *entry = new_type_table_entry(TypeTableEntryIdStruct);
	823	ZigType *entry = new_type_table_entry(TypeTableEntryIdStruct);
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
...	...	@@ -828,14 +828,14 @@ TypeTableEntry get_slice_type(CodeGen g, TypeTableEntry *ptr_type) {
828	828	size_t name_offset = (ptr_type->data.pointer.ptr_len == PtrLenSingle) ? 1 : 3;
829	829	buf_appendf(&entry->name, "[]%s", buf_ptr(&ptr_type->name) + name_offset);
830	830
831		TypeTableEntry *child_type = ptr_type->data.pointer.child_type;
	831	ZigType *child_type = ptr_type->data.pointer.child_type;
832	832	uint32_t abi_alignment = get_abi_alignment(g, child_type);
833	833	if (ptr_type->data.pointer.is_const \|\| ptr_type->data.pointer.is_volatile \|\|
834	834	ptr_type->data.pointer.alignment != abi_alignment)
835	835	{
836		TypeTableEntry *peer_ptr_type = get_pointer_to_type_extra(g, child_type, false, false,
	836	ZigType *peer_ptr_type = get_pointer_to_type_extra(g, child_type, false, false,
837	837	PtrLenUnknown, abi_alignment, 0, 0);
838		TypeTableEntry *peer_slice_type = get_slice_type(g, peer_ptr_type);
	838	ZigType *peer_slice_type = get_slice_type(g, peer_ptr_type);
839	839
840	840	slice_type_common_init(g, ptr_type, entry);
841	841
...	...	@@ -852,18 +852,18 @@ TypeTableEntry get_slice_type(CodeGen g, TypeTableEntry *ptr_type) {
852	852	// If the child type is []const T then we need to make sure the type ref
853	853	// and debug info is the same as if the child type were []T.
854	854	if (is_slice(child_type)) {
855		TypeTableEntry *child_ptr_type = child_type->data.structure.fields[slice_ptr_index].type_entry;
	855	ZigType *child_ptr_type = child_type->data.structure.fields[slice_ptr_index].type_entry;
856	856	assert(child_ptr_type->id == TypeTableEntryIdPointer);
857		TypeTableEntry *grand_child_type = child_ptr_type->data.pointer.child_type;
	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))
860	860	{
861		TypeTableEntry *bland_child_ptr_type = get_pointer_to_type_extra(g, grand_child_type, false, false,
	861	ZigType *bland_child_ptr_type = get_pointer_to_type_extra(g, grand_child_type, false, false,
862	862	PtrLenUnknown, get_abi_alignment(g, grand_child_type), 0, 0);
863		TypeTableEntry *bland_child_slice = get_slice_type(g, bland_child_ptr_type);
864		TypeTableEntry *peer_ptr_type = get_pointer_to_type_extra(g, bland_child_slice, false, false,
	863	ZigType *bland_child_slice = get_slice_type(g, bland_child_ptr_type);
	864	ZigType *peer_ptr_type = get_pointer_to_type_extra(g, bland_child_slice, false, false,
865	865	PtrLenUnknown, get_abi_alignment(g, bland_child_slice), 0, 0);
866		TypeTableEntry *peer_slice_type = get_slice_type(g, peer_ptr_type);
	866	ZigType *peer_slice_type = get_slice_type(g, peer_ptr_type);
867	867
868	868	entry->type_ref = peer_slice_type->type_ref;
869	869	entry->di_type = peer_slice_type->di_type;
...	...	@@ -889,7 +889,7 @@ TypeTableEntry get_slice_type(CodeGen g, TypeTableEntry *ptr_type) {
889	889	};
890	890	LLVMStructSetBody(entry->type_ref, element_types, 1, false);
891	891
892		TypeTableEntry *usize_type = g->builtin_types.entry_usize;
	892	ZigType *usize_type = g->builtin_types.entry_usize;
893	893	uint64_t len_debug_size_in_bits = 8*LLVMStoreSizeOfType(g->target_data_ref, usize_type->type_ref);
894	894	uint64_t len_debug_align_in_bits = 8*LLVMABIAlignmentOfType(g->target_data_ref, usize_type->type_ref);
895	895	uint64_t len_offset_in_bits = 8*LLVMOffsetOfElement(g->target_data_ref, entry->type_ref, 0);
...	...	@@ -928,7 +928,7 @@ TypeTableEntry get_slice_type(CodeGen g, TypeTableEntry *ptr_type) {
928	928	uint64_t ptr_debug_align_in_bits = 8*LLVMABIAlignmentOfType(g->target_data_ref, ptr_type->type_ref);
929	929	uint64_t ptr_offset_in_bits = 8*LLVMOffsetOfElement(g->target_data_ref, entry->type_ref, 0);
930	930
931		TypeTableEntry *usize_type = g->builtin_types.entry_usize;
	931	ZigType *usize_type = g->builtin_types.entry_usize;
932	932	uint64_t len_debug_size_in_bits = 8*LLVMStoreSizeOfType(g->target_data_ref, usize_type->type_ref);
933	933	uint64_t len_debug_align_in_bits = 8*LLVMABIAlignmentOfType(g->target_data_ref, usize_type->type_ref);
934	934	uint64_t len_offset_in_bits = 8*LLVMOffsetOfElement(g->target_data_ref, entry->type_ref, 1);
...	...	@@ -971,8 +971,8 @@ TypeTableEntry get_slice_type(CodeGen g, TypeTableEntry *ptr_type) {
971	971	return entry;
972	972	}
973	973
974		TypeTableEntry get_opaque_type(CodeGen g, Scope scope, AstNode source_node, const char *name) {
975		TypeTableEntry *entry = new_type_table_entry(TypeTableEntryIdOpaque);
	974	ZigType get_opaque_type(CodeGen g, Scope scope, AstNode source_node, const char *name) {
	975	ZigType *entry = new_type_table_entry(TypeTableEntryIdOpaque);
976	976
977	977	buf_init_from_str(&entry->name, name);
978	978
...	...	@@ -991,13 +991,13 @@ TypeTableEntry get_opaque_type(CodeGen g, Scope scope, AstNode source_node,
991	991	return entry;
992	992	}
993	993
994		TypeTableEntry get_bound_fn_type(CodeGen g, FnTableEntry *fn_entry) {
995		TypeTableEntry *fn_type = fn_entry->type_entry;
	994	ZigType get_bound_fn_type(CodeGen g, FnTableEntry *fn_entry) {
	995	ZigType *fn_type = fn_entry->type_entry;
996	996	assert(fn_type->id == TypeTableEntryIdFn);
997	997	if (fn_type->data.fn.bound_fn_parent)
998	998	return fn_type->data.fn.bound_fn_parent;
999	999
1000		TypeTableEntry *bound_fn_type = new_type_table_entry(TypeTableEntryIdBoundFn);
	1000	ZigType *bound_fn_type = new_type_table_entry(TypeTableEntryIdBoundFn);
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;
...	...	@@ -1051,7 +1051,7 @@ static bool calling_convention_allows_zig_types(CallingConvention cc) {
1051	1051	zig_unreachable();
1052	1052	}
1053	1053
1054		TypeTableEntry get_ptr_to_stack_trace_type(CodeGen g) {
	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	1057	assert(stack_trace_type_val->type->id == TypeTableEntryIdMetaType);
...	...	@@ -1061,7 +1061,7 @@ TypeTableEntry get_ptr_to_stack_trace_type(CodeGen g) {
1061	1061	return g->ptr_to_stack_trace_type;
1062	1062	}
1063	1063
1064		TypeTableEntry get_fn_type(CodeGen g, FnTypeId *fn_type_id) {
	1064	ZigType get_fn_type(CodeGen g, FnTypeId *fn_type_id) {
1065	1065	Error err;
1066	1066	auto table_entry = g->fn_type_table.maybe_get(fn_type_id);
1067	1067	if (table_entry) {
...	...	@@ -1075,7 +1075,7 @@ TypeTableEntry get_fn_type(CodeGen g, FnTypeId *fn_type_id) {
1075	1075	zig_panic("TODO implement inferred return types https://github.com/ziglang/zig/issues/447");
1076	1076	}
1077	1077
1078		TypeTableEntry *fn_type = new_type_table_entry(TypeTableEntryIdFn);
	1078	ZigType *fn_type = new_type_table_entry(TypeTableEntryIdFn);
1079	1079	fn_type->is_copyable = true;
1080	1080	fn_type->data.fn.fn_type_id = *fn_type_id;
1081	1081
...	...	@@ -1094,7 +1094,7 @@ TypeTableEntry get_fn_type(CodeGen g, FnTypeId *fn_type_id) {
1094	1094	for (size_t i = 0; i < fn_type_id->param_count; i += 1) {
1095	1095	FnTypeParamInfo *param_info = &fn_type_id->param_info[i];
1096	1096
1097		TypeTableEntry *param_type = param_info->type;
	1097	ZigType *param_type = param_info->type;
1098	1098	const char *comma = (i == 0) ? "" : ", ";
1099	1099	const char *noalias_str = param_info->is_noalias ? "noalias " : "";
1100	1100	buf_appendf(&fn_type->name, "%s%s%s", comma, noalias_str, buf_ptr(&param_type->name));
...	...	@@ -1131,13 +1131,13 @@ TypeTableEntry get_fn_type(CodeGen g, FnTypeId *fn_type_id) {
1131	1131	ZigLLVMDIType *param_di_types = allocate<ZigLLVMDIType>(5 + fn_type_id->param_count);
1132	1132	param_di_types[0] = fn_type_id->return_type->di_type;
1133	1133	size_t gen_param_index = 0;
1134		TypeTableEntry *gen_return_type;
	1134	ZigType *gen_return_type;
1135	1135	if (is_async) {
1136	1136	gen_return_type = get_pointer_to_type(g, g->builtin_types.entry_u8, false);
1137	1137	} else if (!type_has_bits(fn_type_id->return_type)) {
1138	1138	gen_return_type = g->builtin_types.entry_void;
1139	1139	} else if (first_arg_return) {
1140		TypeTableEntry *gen_type = get_pointer_to_type(g, fn_type_id->return_type, false);
	1140	ZigType *gen_type = get_pointer_to_type(g, fn_type_id->return_type, false);
1141	1141	gen_param_types[gen_param_index] = gen_type->type_ref;
1142	1142	gen_param_index += 1;
1143	1143	// after the gen_param_index += 1 because 0 is the return type
...	...	@@ -1149,7 +1149,7 @@ TypeTableEntry get_fn_type(CodeGen g, FnTypeId *fn_type_id) {
1149	1149	fn_type->data.fn.gen_return_type = gen_return_type;
1150	1150
1151	1151	if (prefix_arg_error_return_trace) {
1152		TypeTableEntry *gen_type = get_ptr_to_stack_trace_type(g);
	1152	ZigType *gen_type = get_ptr_to_stack_trace_type(g);
1153	1153	gen_param_types[gen_param_index] = gen_type->type_ref;
1154	1154	gen_param_index += 1;
1155	1155	// after the gen_param_index += 1 because 0 is the return type
...	...	@@ -1158,7 +1158,7 @@ TypeTableEntry get_fn_type(CodeGen g, FnTypeId *fn_type_id) {
1158	1158	if (is_async) {
1159	1159	{
1160	1160	// async allocator param
1161		TypeTableEntry *gen_type = fn_type_id->async_allocator_type;
	1161	ZigType *gen_type = fn_type_id->async_allocator_type;
1162	1162	gen_param_types[gen_param_index] = gen_type->type_ref;
1163	1163	gen_param_index += 1;
1164	1164	// after the gen_param_index += 1 because 0 is the return type
...	...	@@ -1167,7 +1167,7 @@ TypeTableEntry get_fn_type(CodeGen g, FnTypeId *fn_type_id) {
1167	1167
1168	1168	{
1169	1169	// error code pointer
1170		TypeTableEntry *gen_type = get_pointer_to_type(g, g->builtin_types.entry_global_error_set, false);
	1170	ZigType *gen_type = get_pointer_to_type(g, g->builtin_types.entry_global_error_set, false);
1171	1171	gen_param_types[gen_param_index] = gen_type->type_ref;
1172	1172	gen_param_index += 1;
1173	1173	// after the gen_param_index += 1 because 0 is the return type
...	...	@@ -1178,7 +1178,7 @@ TypeTableEntry get_fn_type(CodeGen g, FnTypeId *fn_type_id) {
1178	1178	fn_type->data.fn.gen_param_info = allocate<FnGenParamInfo>(fn_type_id->param_count);
1179	1179	for (size_t i = 0; i < fn_type_id->param_count; i += 1) {
1180	1180	FnTypeParamInfo *src_param_info = &fn_type->data.fn.fn_type_id.param_info[i];
1181		TypeTableEntry *type_entry = src_param_info->type;
	1181	ZigType *type_entry = src_param_info->type;
1182	1182	FnGenParamInfo *gen_param_info = &fn_type->data.fn.gen_param_info[i];
1183	1183
1184	1184	gen_param_info->src_index = i;
...	...	@@ -1188,7 +1188,7 @@ TypeTableEntry get_fn_type(CodeGen g, FnTypeId *fn_type_id) {
1188	1188	return g->builtin_types.entry_invalid;
1189	1189
1190	1190	if (type_has_bits(type_entry)) {
1191		TypeTableEntry *gen_type;
	1191	ZigType *gen_type;
1192	1192	if (handle_is_ptr(type_entry)) {
1193	1193	gen_type = get_pointer_to_type(g, type_entry, true);
1194	1194	gen_param_info->is_byval = true;
...	...	@@ -1219,7 +1219,7 @@ TypeTableEntry get_fn_type(CodeGen g, FnTypeId *fn_type_id) {
1219	1219	return fn_type;
1220	1220	}
1221	1221
1222		static TypeTableEntryId container_to_type(ContainerKind kind) {
	1222	static ZigTypeId container_to_type(ContainerKind kind) {
1223	1223	switch (kind) {
1224	1224	case ContainerKindStruct:
1225	1225	return TypeTableEntryIdStruct;
...	...	@@ -1231,11 +1231,11 @@ static TypeTableEntryId container_to_type(ContainerKind kind) {
1231	1231	zig_unreachable();
1232	1232	}
1233	1233
1234		TypeTableEntry get_partial_container_type(CodeGen g, Scope *scope, ContainerKind kind,
	1234	ZigType get_partial_container_type(CodeGen g, Scope *scope, ContainerKind kind,
1235	1235	AstNode decl_node, const char name, ContainerLayout layout)
1236	1236	{
1237		TypeTableEntryId type_id = container_to_type(kind);
1238		TypeTableEntry *entry = new_container_type_entry(type_id, decl_node, scope);
	1237	ZigTypeId type_id = container_to_type(kind);
	1238	ZigType *entry = new_container_type_entry(type_id, decl_node, scope);
1239	1239
1240	1240	switch (kind) {
1241	1241	case ContainerKindStruct:
...	...	@@ -1266,14 +1266,14 @@ TypeTableEntry get_partial_container_type(CodeGen g, Scope *scope, ContainerKi
1266	1266	return entry;
1267	1267	}
1268	1268
1269		static IrInstruction analyze_const_value(CodeGen g, Scope scope, AstNode node, TypeTableEntry type_entry, Buf type_name) {
	1269	static IrInstruction analyze_const_value(CodeGen g, Scope scope, AstNode node, ZigType type_entry, Buf type_name) {
1270	1270	size_t backward_branch_count = 0;
1271	1271	return ir_eval_const_value(g, scope, node, type_entry,
1272	1272	&backward_branch_count, default_backward_branch_quota,
1273	1273	nullptr, nullptr, node, type_name, nullptr);
1274	1274	}
1275	1275
1276		TypeTableEntry analyze_type_expr(CodeGen g, Scope scope, AstNode node) {
	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	1278	if (result->value.type->id == TypeTableEntryIdInvalid)
1279	1279	return g->builtin_types.entry_invalid;
...	...	@@ -1282,8 +1282,8 @@ TypeTableEntry analyze_type_expr(CodeGen g, Scope scope, AstNode node) {
1282	1282	return result->value.data.x_type;
1283	1283	}
1284	1284
1285		TypeTableEntry get_generic_fn_type(CodeGen g, FnTypeId *fn_type_id) {
1286		TypeTableEntry *fn_type = new_type_table_entry(TypeTableEntryIdFn);
	1285	ZigType get_generic_fn_type(CodeGen g, FnTypeId *fn_type_id) {
	1286	ZigType *fn_type = new_type_table_entry(TypeTableEntryIdFn);
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) {
...	...	@@ -1350,9 +1350,9 @@ static bool analyze_const_align(CodeGen g, Scope scope, AstNode *node, uint32_
1350	1350	}
1351	1351
1352	1352	static bool analyze_const_string(CodeGen g, Scope scope, AstNode node, Buf *out_buffer) {
1353		TypeTableEntry *ptr_type = get_pointer_to_type_extra(g, g->builtin_types.entry_u8, true, false,
	1353	ZigType *ptr_type = get_pointer_to_type_extra(g, g->builtin_types.entry_u8, true, false,
1354	1354	PtrLenUnknown, get_abi_alignment(g, g->builtin_types.entry_u8), 0, 0);
1355		TypeTableEntry *str_type = get_slice_type(g, ptr_type);
	1355	ZigType *str_type = get_slice_type(g, ptr_type);
1356	1356	IrInstruction *instr = analyze_const_value(g, scope, node, str_type, nullptr);
1357	1357	if (type_is_invalid(instr->value.type))
1358	1358	return false;
...	...	@@ -1382,7 +1382,7 @@ static bool analyze_const_string(CodeGen g, Scope scope, AstNode node, Buf *
1382	1382	return true;
1383	1383	}
1384	1384
1385		static bool type_allowed_in_packed_struct(TypeTableEntry *type_entry) {
	1385	static bool type_allowed_in_packed_struct(ZigType *type_entry) {
1386	1386	switch (type_entry->id) {
1387	1387	case TypeTableEntryIdInvalid:
1388	1388	zig_unreachable();
...	...	@@ -1415,7 +1415,7 @@ static bool type_allowed_in_packed_struct(TypeTableEntry *type_entry) {
1415	1415	return type_entry->data.unionation.layout == ContainerLayoutPacked;
1416	1416	case TypeTableEntryIdOptional:
1417	1417	{
1418		TypeTableEntry *child_type = type_entry->data.maybe.child_type;
	1418	ZigType *child_type = type_entry->data.maybe.child_type;
1419	1419	return type_is_codegen_pointer(child_type);
1420	1420	}
1421	1421	case TypeTableEntryIdEnum:
...	...	@@ -1424,7 +1424,7 @@ static bool type_allowed_in_packed_struct(TypeTableEntry *type_entry) {
1424	1424	zig_unreachable();
1425	1425	}
1426	1426
1427		static bool type_allowed_in_extern(CodeGen g, TypeTableEntry type_entry) {
	1427	static bool type_allowed_in_extern(CodeGen g, ZigType type_entry) {
1428	1428	switch (type_entry->id) {
1429	1429	case TypeTableEntryIdInvalid:
1430	1430	zig_unreachable();
...	...	@@ -1471,7 +1471,7 @@ static bool type_allowed_in_extern(CodeGen g, TypeTableEntry type_entry) {
1471	1471	return type_entry->data.structure.layout == ContainerLayoutExtern \|\| type_entry->data.structure.layout == ContainerLayoutPacked;
1472	1472	case TypeTableEntryIdOptional:
1473	1473	{
1474		TypeTableEntry *child_type = type_entry->data.maybe.child_type;
	1474	ZigType *child_type = type_entry->data.maybe.child_type;
1475	1475	if (child_type->id != TypeTableEntryIdPointer && child_type->id != TypeTableEntryIdFn) {
1476	1476	return false;
1477	1477	}
...	...	@@ -1485,8 +1485,8 @@ static bool type_allowed_in_extern(CodeGen g, TypeTableEntry type_entry) {
1485	1485	zig_unreachable();
1486	1486	}
1487	1487
1488		TypeTableEntry get_auto_err_set_type(CodeGen g, FnTableEntry *fn_entry) {
1489		TypeTableEntry *err_set_type = new_type_table_entry(TypeTableEntryIdErrorSet);
	1488	ZigType get_auto_err_set_type(CodeGen g, FnTableEntry *fn_entry) {
	1489	ZigType *err_set_type = new_type_table_entry(TypeTableEntryIdErrorSet);
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;
...	...	@@ -1501,7 +1501,7 @@ TypeTableEntry get_auto_err_set_type(CodeGen g, FnTableEntry *fn_entry) {
1501	1501	return err_set_type;
1502	1502	}
1503	1503
1504		static TypeTableEntry analyze_fn_type(CodeGen g, AstNode proto_node, Scope child_scope, FnTableEntry *fn_entry) {
	1504	static ZigType analyze_fn_type(CodeGen g, AstNode proto_node, Scope child_scope, FnTableEntry *fn_entry) {
1505	1505	assert(proto_node->type == NodeTypeFnProto);
1506	1506	AstNodeFnProto *fn_proto = &proto_node->data.fn_proto;
1507	1507	Error err;
...	...	@@ -1524,7 +1524,7 @@ static TypeTableEntry analyze_fn_type(CodeGen g, AstNode proto_node, Scope c
1524	1524	return g->builtin_types.entry_invalid;
1525	1525	}
1526	1526	if (param_node->data.param_decl.type != nullptr) {
1527		TypeTableEntry *type_entry = analyze_type_expr(g, child_scope, param_node->data.param_decl.type);
	1527	ZigType *type_entry = analyze_type_expr(g, child_scope, param_node->data.param_decl.type);
1528	1528	if (type_is_invalid(type_entry)) {
1529	1529	return g->builtin_types.entry_invalid;
1530	1530	}
...	...	@@ -1557,7 +1557,7 @@ static TypeTableEntry analyze_fn_type(CodeGen g, AstNode proto_node, Scope c
1557	1557	return get_generic_fn_type(g, &fn_type_id);
1558	1558	}
1559	1559
1560		TypeTableEntry *type_entry = analyze_type_expr(g, child_scope, param_node->data.param_decl.type);
	1560	ZigType *type_entry = analyze_type_expr(g, child_scope, param_node->data.param_decl.type);
1561	1561	if (type_is_invalid(type_entry)) {
1562	1562	return g->builtin_types.entry_invalid;
1563	1563	}
...	...	@@ -1645,14 +1645,14 @@ static TypeTableEntry analyze_fn_type(CodeGen g, AstNode proto_node, Scope c
1645	1645	//return get_generic_fn_type(g, &fn_type_id);
1646	1646	}
1647	1647
1648		TypeTableEntry *specified_return_type = analyze_type_expr(g, child_scope, fn_proto->return_type);
	1648	ZigType *specified_return_type = analyze_type_expr(g, child_scope, fn_proto->return_type);
1649	1649	if (type_is_invalid(specified_return_type)) {
1650	1650	fn_type_id.return_type = g->builtin_types.entry_invalid;
1651	1651	return g->builtin_types.entry_invalid;
1652	1652	}
1653	1653
1654	1654	if (fn_proto->auto_err_set) {
1655		TypeTableEntry *inferred_err_set_type = get_auto_err_set_type(g, fn_entry);
	1655	ZigType *inferred_err_set_type = get_auto_err_set_type(g, fn_entry);
1656	1656	fn_type_id.return_type = get_error_union_type(g, inferred_err_set_type, specified_return_type);
1657	1657	} else {
1658	1658	fn_type_id.return_type = specified_return_type;
...	...	@@ -1723,7 +1723,7 @@ static TypeTableEntry analyze_fn_type(CodeGen g, AstNode proto_node, Scope c
1723	1723	return get_fn_type(g, &fn_type_id);
1724	1724	}
1725	1725
1726		bool type_is_invalid(TypeTableEntry *type_entry) {
	1726	bool type_is_invalid(ZigType *type_entry) {
1727	1727	switch (type_entry->id) {
1728	1728	case TypeTableEntryIdInvalid:
1729	1729	return true;
...	...	@@ -1740,7 +1740,7 @@ bool type_is_invalid(TypeTableEntry *type_entry) {
1740	1740	}
1741	1741
1742	1742
1743		static Error resolve_enum_type(CodeGen g, TypeTableEntry enum_type) {
	1743	static Error resolve_enum_type(CodeGen g, ZigType enum_type) {
1744	1744	assert(enum_type->id == TypeTableEntryIdEnum);
1745	1745
1746	1746	if (enum_type->data.enumeration.is_invalid)
...	...	@@ -1815,7 +1815,7 @@ static Error resolve_enum_type(CodeGen g, TypeTableEntry enum_type) {
1815	1815	return ErrorNone;
1816	1816	}
1817	1817
1818		TypeTableEntry *tag_int_type = enum_type->data.enumeration.tag_int_type;
	1818	ZigType *tag_int_type = enum_type->data.enumeration.tag_int_type;
1819	1819
1820	1820	// create debug type for tag
1821	1821	uint64_t tag_debug_size_in_bits = 8*LLVMStoreSizeOfType(g->target_data_ref, tag_int_type->type_ref);
...	...	@@ -1834,10 +1834,10 @@ static Error resolve_enum_type(CodeGen g, TypeTableEntry enum_type) {
1834	1834	}
1835	1835
1836	1836
1837		TypeTableEntry get_struct_type(CodeGen g, const char type_name, const char field_names[],
1838		TypeTableEntry *field_types[], size_t field_count)
	1837	ZigType get_struct_type(CodeGen g, const char type_name, const char field_names[],
	1838	ZigType *field_types[], size_t field_count)
1839	1839	{
1840		TypeTableEntry *struct_type = new_type_table_entry(TypeTableEntryIdStruct);
	1840	ZigType *struct_type = new_type_table_entry(TypeTableEntryIdStruct);
1841	1841
1842	1842	buf_init_from_str(&struct_type->name, type_name);
1843	1843
...	...	@@ -1881,7 +1881,7 @@ TypeTableEntry get_struct_type(CodeGen g, const char type_name, const char f
1881	1881	if (type_struct_field->gen_index == SIZE_MAX) {
1882	1882	continue;
1883	1883	}
1884		TypeTableEntry *field_type = type_struct_field->type_entry;
	1884	ZigType *field_type = type_struct_field->type_entry;
1885	1885	uint64_t debug_size_in_bits = 8*LLVMStoreSizeOfType(g->target_data_ref, field_type->type_ref);
1886	1886	uint64_t debug_align_in_bits = 8*LLVMABIAlignmentOfType(g->target_data_ref, field_type->type_ref);
1887	1887	uint64_t debug_offset_in_bits = 8*LLVMOffsetOfElement(g->target_data_ref, struct_type->type_ref, type_struct_field->gen_index);
...	...	@@ -1913,7 +1913,7 @@ TypeTableEntry get_struct_type(CodeGen g, const char type_name, const char f
1913	1913	return struct_type;
1914	1914	}
1915	1915
1916		static Error resolve_struct_type(CodeGen g, TypeTableEntry struct_type) {
	1916	static Error resolve_struct_type(CodeGen g, ZigType struct_type) {
1917	1917	assert(struct_type->id == TypeTableEntryIdStruct);
1918	1918
1919	1919	if (struct_type->data.structure.complete)
...	...	@@ -1957,7 +1957,7 @@ static Error resolve_struct_type(CodeGen g, TypeTableEntry struct_type) {
1957	1957
1958	1958	for (size_t i = 0; i < field_count; i += 1) {
1959	1959	TypeStructField *type_struct_field = &struct_type->data.structure.fields[i];
1960		TypeTableEntry *field_type = type_struct_field->type_entry;
	1960	ZigType *field_type = type_struct_field->type_entry;
1961	1961
1962	1962	if ((err = ensure_complete_type(g, field_type))) {
1963	1963	struct_type->data.structure.is_invalid = true;
...	...	@@ -2088,12 +2088,12 @@ static Error resolve_struct_type(CodeGen g, TypeTableEntry struct_type) {
2088	2088	continue;
2089	2089	}
2090	2090
2091		TypeTableEntry *field_type = type_struct_field->type_entry;
	2091	ZigType *field_type = type_struct_field->type_entry;
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	2095	if (field_type->id == TypeTableEntryIdFn) {
2096		TypeTableEntry *field_ptr_type = get_pointer_to_type(g, field_type, true);
	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);
2099	2099	field_di_type = ZigLLVMCreateDebugPointerType(g->dbuilder, field_type->di_type,
...	...	@@ -2147,7 +2147,7 @@ static Error resolve_struct_type(CodeGen g, TypeTableEntry struct_type) {
2147	2147	return ErrorNone;
2148	2148	}
2149	2149
2150		static Error resolve_union_type(CodeGen g, TypeTableEntry union_type) {
	2150	static Error resolve_union_type(CodeGen g, ZigType union_type) {
2151	2151	assert(union_type->id == TypeTableEntryIdUnion);
2152	2152
2153	2153	if (union_type->data.unionation.complete)
...	...	@@ -2179,7 +2179,7 @@ static Error resolve_union_type(CodeGen g, TypeTableEntry union_type) {
2179	2179	uint32_t gen_field_count = union_type->data.unionation.gen_field_count;
2180	2180	ZigLLVMDIType *union_inner_di_types = allocate<ZigLLVMDIType>(gen_field_count);
2181	2181
2182		TypeTableEntry *most_aligned_union_member = nullptr;
	2182	ZigType *most_aligned_union_member = nullptr;
2183	2183	uint64_t size_of_most_aligned_member_in_bits = 0;
2184	2184	uint64_t biggest_align_in_bits = 0;
2185	2185	uint64_t biggest_size_in_bits = 0;
...	...	@@ -2194,7 +2194,7 @@ static Error resolve_union_type(CodeGen g, TypeTableEntry union_type) {
2194	2194	for (uint32_t i = 0; i < field_count; i += 1) {
2195	2195	AstNode *field_node = decl_node->data.container_decl.fields.at(i);
2196	2196	TypeUnionField *union_field = &union_type->data.unionation.fields[i];
2197		TypeTableEntry *field_type = union_field->type_entry;
	2197	ZigType *field_type = union_field->type_entry;
2198	2198
2199	2199	if ((err = ensure_complete_type(g, field_type))) {
2200	2200	union_type->data.unionation.is_invalid = true;
...	...	@@ -2259,13 +2259,13 @@ static Error resolve_union_type(CodeGen g, TypeTableEntry union_type) {
2259	2259
2260	2260	uint64_t padding_in_bits = biggest_size_in_bits - size_of_most_aligned_member_in_bits;
2261	2261
2262		TypeTableEntry *tag_type = union_type->data.unionation.tag_type;
	2262	ZigType *tag_type = union_type->data.unionation.tag_type;
2263	2263	if (tag_type == nullptr \|\| tag_type->zero_bits) {
2264	2264	assert(most_aligned_union_member != nullptr);
2265	2265
2266	2266	if (padding_in_bits > 0) {
2267		TypeTableEntry *u8_type = get_int_type(g, false, 8);
2268		TypeTableEntry *padding_array = get_array_type(g, u8_type, padding_in_bits / 8);
	2267	ZigType *u8_type = get_int_type(g, false, 8);
	2268	ZigType *padding_array = get_array_type(g, u8_type, padding_in_bits / 8);
2269	2269	LLVMTypeRef union_element_types[] = {
2270	2270	most_aligned_union_member->type_ref,
2271	2271	padding_array->type_ref,
...	...	@@ -2295,8 +2295,8 @@ static Error resolve_union_type(CodeGen g, TypeTableEntry union_type) {
2295	2295
2296	2296	LLVMTypeRef union_type_ref;
2297	2297	if (padding_in_bits > 0) {
2298		TypeTableEntry *u8_type = get_int_type(g, false, 8);
2299		TypeTableEntry *padding_array = get_array_type(g, u8_type, padding_in_bits / 8);
	2298	ZigType *u8_type = get_int_type(g, false, 8);
	2299	ZigType *padding_array = get_array_type(g, u8_type, padding_in_bits / 8);
2300	2300	LLVMTypeRef union_element_types[] = {
2301	2301	most_aligned_union_member->type_ref,
2302	2302	padding_array->type_ref,
...	...	@@ -2319,7 +2319,7 @@ static Error resolve_union_type(CodeGen g, TypeTableEntry union_type) {
2319	2319	assert(8*LLVMStoreSizeOfType(g->target_data_ref, union_type_ref) >= biggest_size_in_bits);
2320	2320
2321	2321	// create llvm type for root struct
2322		TypeTableEntry *tag_int_type = tag_type->data.enumeration.tag_int_type;
	2322	ZigType *tag_int_type = tag_type->data.enumeration.tag_int_type;
2323	2323	uint64_t align_of_tag_in_bits = 8*LLVMABIAlignmentOfType(g->target_data_ref, tag_int_type->type_ref);
2324	2324
2325	2325	if (align_of_tag_in_bits >= biggest_align_in_bits) {
...	...	@@ -2387,7 +2387,7 @@ static Error resolve_union_type(CodeGen g, TypeTableEntry union_type) {
2387	2387	return ErrorNone;
2388	2388	}
2389	2389
2390		static Error resolve_enum_zero_bits(CodeGen g, TypeTableEntry enum_type) {
	2390	static Error resolve_enum_zero_bits(CodeGen g, ZigType enum_type) {
2391	2391	assert(enum_type->id == TypeTableEntryIdEnum);
2392	2392
2393	2393	if (enum_type->data.enumeration.zero_bits_known)
...	...	@@ -2428,7 +2428,7 @@ static Error resolve_enum_zero_bits(CodeGen g, TypeTableEntry enum_type) {
2428	2428	HashMap<BigInt, AstNode *, bigint_hash, bigint_eql> occupied_tag_values = {};
2429	2429	occupied_tag_values.init(field_count);
2430	2430
2431		TypeTableEntry *tag_int_type;
	2431	ZigType *tag_int_type;
2432	2432	if (enum_type->data.enumeration.layout == ContainerLayoutExtern) {
2433	2433	tag_int_type = get_c_int_type(g, CIntTypeInt);
2434	2434	} else {
...	...	@@ -2437,7 +2437,7 @@ static Error resolve_enum_zero_bits(CodeGen g, TypeTableEntry enum_type) {
2437	2437
2438	2438	// TODO: Are extern enums allowed to have an init_arg_expr?
2439	2439	if (decl_node->data.container_decl.init_arg_expr != nullptr) {
2440		TypeTableEntry *wanted_tag_int_type = analyze_type_expr(g, scope, decl_node->data.container_decl.init_arg_expr);
	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	2443	} else if (wanted_tag_int_type->id != TypeTableEntryIdInt) {
...	...	@@ -2550,7 +2550,7 @@ static Error resolve_enum_zero_bits(CodeGen g, TypeTableEntry enum_type) {
2550	2550	return ErrorNone;
2551	2551	}
2552	2552
2553		static Error resolve_struct_zero_bits(CodeGen g, TypeTableEntry struct_type) {
	2553	static Error resolve_struct_zero_bits(CodeGen g, ZigType struct_type) {
2554	2554	assert(struct_type->id == TypeTableEntryIdStruct);
2555	2555
2556	2556	Error err;
...	...	@@ -2614,7 +2614,7 @@ static Error resolve_struct_zero_bits(CodeGen g, TypeTableEntry struct_type) {
2614	2614	continue;
2615	2615	}
2616	2616
2617		TypeTableEntry *field_type = analyze_type_expr(g, scope, field_node->data.struct_field.type);
	2617	ZigType *field_type = analyze_type_expr(g, scope, field_node->data.struct_field.type);
2618	2618	type_struct_field->type_entry = field_type;
2619	2619	type_struct_field->src_index = i;
2620	2620	type_struct_field->gen_index = SIZE_MAX;
...	...	@@ -2669,7 +2669,7 @@ static Error resolve_struct_zero_bits(CodeGen g, TypeTableEntry struct_type) {
2669	2669	return ErrorNone;
2670	2670	}
2671	2671
2672		static Error resolve_union_zero_bits(CodeGen g, TypeTableEntry union_type) {
	2672	static Error resolve_union_zero_bits(CodeGen g, ZigType union_type) {
2673	2673	assert(union_type->id == TypeTableEntryIdUnion);
2674	2674
2675	2675	Error err;
...	...	@@ -2734,7 +2734,7 @@ static Error resolve_union_zero_bits(CodeGen g, TypeTableEntry union_type) {
2734	2734	enum_type_node != nullptr;
2735	2735	bool auto_layout = (union_type->data.unionation.layout == ContainerLayoutAuto);
2736	2736	bool want_safety = (field_count >= 2) && (auto_layout \|\| enum_type_node != nullptr);
2737		TypeTableEntry *tag_type;
	2737	ZigType *tag_type;
2738	2738	bool create_enum_type = decl_node->data.container_decl.auto_enum \|\| (enum_type_node == nullptr && want_safety);
2739	2739	bool *covered_enum_fields;
2740	2740	ZigLLVMDIEnumerator **di_enumerators;
...	...	@@ -2744,7 +2744,7 @@ static Error resolve_union_zero_bits(CodeGen g, TypeTableEntry union_type) {
2744	2744
2745	2745	di_enumerators = allocate<ZigLLVMDIEnumerator*>(field_count);
2746	2746
2747		TypeTableEntry *tag_int_type;
	2747	ZigType *tag_int_type;
2748	2748	if (enum_type_node != nullptr) {
2749	2749	tag_int_type = analyze_type_expr(g, scope, enum_type_node);
2750	2750	if (type_is_invalid(tag_int_type)) {
...	...	@@ -2779,7 +2779,7 @@ static Error resolve_union_zero_bits(CodeGen g, TypeTableEntry union_type) {
2779	2779	tag_type->data.enumeration.decls_scope = union_type->data.unionation.decls_scope;
2780	2780	tag_type->data.enumeration.complete = true;
2781	2781	} else if (enum_type_node != nullptr) {
2782		TypeTableEntry *enum_type = analyze_type_expr(g, scope, enum_type_node);
	2782	ZigType *enum_type = analyze_type_expr(g, scope, enum_type_node);
2783	2783	if (type_is_invalid(enum_type)) {
2784	2784	union_type->data.unionation.is_invalid = true;
2785	2785	return ErrorSemanticAnalyzeFail;
...	...	@@ -2816,7 +2816,7 @@ static Error resolve_union_zero_bits(CodeGen g, TypeTableEntry union_type) {
2816	2816	continue;
2817	2817	}
2818	2818
2819		TypeTableEntry *field_type;
	2819	ZigType *field_type;
2820	2820	if (field_node->data.struct_field.type == nullptr) {
2821	2821	if (decl_node->data.container_decl.auto_enum \|\| decl_node->data.container_decl.init_arg_expr != nullptr) {
2822	2822	field_type = g->builtin_types.entry_void;
...	...	@@ -2860,7 +2860,7 @@ static Error resolve_union_zero_bits(CodeGen g, TypeTableEntry union_type) {
2860	2860	// In this first pass we resolve explicit tag values.
2861	2861	// In a second pass we will fill in the unspecified ones.
2862	2862	if (tag_value != nullptr) {
2863		TypeTableEntry *tag_int_type = tag_type->data.enumeration.tag_int_type;
	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	2865	if (result_inst->value.type->id == TypeTableEntryIdInvalid) {
2866	2866	union_type->data.unionation.is_invalid = true;
...	...	@@ -3075,7 +3075,7 @@ static bool scope_is_root_decls(Scope *scope) {
3075	3075	zig_unreachable();
3076	3076	}
3077	3077
3078		static void wrong_panic_prototype(CodeGen g, AstNode proto_node, TypeTableEntry *fn_type) {
	3078	static void wrong_panic_prototype(CodeGen g, AstNode proto_node, ZigType *fn_type) {
3079	3079	add_node_error(g, proto_node,
3080	3080	buf_sprintf("expected 'fn([]const u8, ?*builtin.StackTrace) noreturn', found '%s'",
3081	3081	buf_ptr(&fn_type->name)));
...	...	@@ -3084,30 +3084,30 @@ static void wrong_panic_prototype(CodeGen g, AstNode proto_node, TypeTableEntr
3084	3084	static void typecheck_panic_fn(CodeGen g, FnTableEntry panic_fn) {
3085	3085	AstNode *proto_node = panic_fn->proto_node;
3086	3086	assert(proto_node->type == NodeTypeFnProto);
3087		TypeTableEntry *fn_type = panic_fn->type_entry;
	3087	ZigType *fn_type = panic_fn->type_entry;
3088	3088	FnTypeId *fn_type_id = &fn_type->data.fn.fn_type_id;
3089	3089	if (fn_type_id->param_count != 2) {
3090	3090	return wrong_panic_prototype(g, proto_node, fn_type);
3091	3091	}
3092		TypeTableEntry *const_u8_ptr = get_pointer_to_type_extra(g, g->builtin_types.entry_u8, true, false,
	3092	ZigType *const_u8_ptr = get_pointer_to_type_extra(g, g->builtin_types.entry_u8, true, false,
3093	3093	PtrLenUnknown, get_abi_alignment(g, g->builtin_types.entry_u8), 0, 0);
3094		TypeTableEntry *const_u8_slice = get_slice_type(g, const_u8_ptr);
	3094	ZigType *const_u8_slice = get_slice_type(g, const_u8_ptr);
3095	3095	if (fn_type_id->param_info[0].type != const_u8_slice) {
3096	3096	return wrong_panic_prototype(g, proto_node, fn_type);
3097	3097	}
3098	3098
3099		TypeTableEntry *optional_ptr_to_stack_trace_type = get_optional_type(g, get_ptr_to_stack_trace_type(g));
	3099	ZigType *optional_ptr_to_stack_trace_type = get_optional_type(g, get_ptr_to_stack_trace_type(g));
3100	3100	if (fn_type_id->param_info[1].type != optional_ptr_to_stack_trace_type) {
3101	3101	return wrong_panic_prototype(g, proto_node, fn_type);
3102	3102	}
3103	3103
3104		TypeTableEntry *actual_return_type = fn_type_id->return_type;
	3104	ZigType *actual_return_type = fn_type_id->return_type;
3105	3105	if (actual_return_type != g->builtin_types.entry_unreachable) {
3106	3106	return wrong_panic_prototype(g, proto_node, fn_type);
3107	3107	}
3108	3108	}
3109	3109
3110		TypeTableEntry get_test_fn_type(CodeGen g) {
	3110	ZigType get_test_fn_type(CodeGen g) {
3111	3111	if (g->test_fn_type)
3112	3112	return g->test_fn_type;
3113	3113
...	...	@@ -3280,7 +3280,7 @@ static void add_top_level_decl(CodeGen g, ScopeDecls decls_scope, Tld *tld) {
3280	3280	}
3281	3281
3282	3282	{
3283		TypeTableEntry *type = get_primitive_type(g, tld->name);
	3283	ZigType *type = get_primitive_type(g, tld->name);
3284	3284	if (type != nullptr) {
3285	3285	add_node_error(g, tld->source_node,
3286	3286	buf_sprintf("declaration shadows type '%s'", buf_ptr(&type->name)));
...	...	@@ -3444,7 +3444,7 @@ void scan_decls(CodeGen g, ScopeDecls decls_scope, AstNode *node) {
3444	3444	}
3445	3445
3446	3446	static void resolve_decl_container(CodeGen g, TldContainer tld_container) {
3447		TypeTableEntry *type_entry = tld_container->type_entry;
	3447	ZigType *type_entry = tld_container->type_entry;
3448	3448	assert(type_entry);
3449	3449
3450	3450	switch (type_entry->id) {
...	...	@@ -3462,7 +3462,7 @@ static void resolve_decl_container(CodeGen g, TldContainer tld_container) {
3462	3462	}
3463	3463	}
3464	3464
3465		TypeTableEntry validate_var_type(CodeGen g, AstNode source_node, TypeTableEntry type_entry) {
	3465	ZigType validate_var_type(CodeGen g, AstNode source_node, ZigType type_entry) {
3466	3466	switch (type_entry->id) {
3467	3467	case TypeTableEntryIdInvalid:
3468	3468	return g->builtin_types.entry_invalid;
...	...	@@ -3526,7 +3526,7 @@ VariableTableEntry add_variable(CodeGen g, AstNode source_node, Scope parent
3526	3526	add_error_note(g, msg, existing_var->decl_node, buf_sprintf("previous declaration is here"));
3527	3527	variable_entry->value->type = g->builtin_types.entry_invalid;
3528	3528	} else {
3529		TypeTableEntry *type = get_primitive_type(g, name);
	3529	ZigType *type = get_primitive_type(g, name);
3530	3530	if (type != nullptr) {
3531	3531	add_node_error(g, source_node,
3532	3532	buf_sprintf("variable shadows type '%s'", buf_ptr(&type->name)));
...	...	@@ -3577,9 +3577,9 @@ static void resolve_decl_var(CodeGen g, TldVar tld_var) {
3577	3577	bool is_extern = var_decl->is_extern;
3578	3578	bool is_export = var_decl->is_export;
3579	3579
3580		TypeTableEntry *explicit_type = nullptr;
	3580	ZigType *explicit_type = nullptr;
3581	3581	if (var_decl->type) {
3582		TypeTableEntry *proposed_type = analyze_type_expr(g, tld_var->base.parent_scope, var_decl->type);
	3582	ZigType *proposed_type = analyze_type_expr(g, tld_var->base.parent_scope, var_decl->type);
3583	3583	explicit_type = validate_var_type(g, var_decl->type, proposed_type);
3584	3584	}
3585	3585
...	...	@@ -3597,7 +3597,7 @@ static void resolve_decl_var(CodeGen g, TldVar tld_var) {
3597	3597	IrInstruction *init_value = nullptr;
3598	3598
3599	3599	// TODO more validation for types that can't be used for export/extern variables
3600		TypeTableEntry *implicit_type = nullptr;
	3600	ZigType *implicit_type = nullptr;
3601	3601	if (explicit_type && explicit_type->id == TypeTableEntryIdInvalid) {
3602	3602	implicit_type = explicit_type;
3603	3603	} else if (var_decl->expr) {
...	...	@@ -3627,7 +3627,7 @@ static void resolve_decl_var(CodeGen g, TldVar tld_var) {
3627	3627	implicit_type = g->builtin_types.entry_invalid;
3628	3628	}
3629	3629
3630		TypeTableEntry *type = explicit_type ? explicit_type : implicit_type;
	3630	ZigType *type = explicit_type ? explicit_type : implicit_type;
3631	3631	assert(type != nullptr); // should have been caught by the parser
3632	3632
3633	3633	ConstExprValue *init_val = init_value ? &init_value->value : create_const_runtime(type);
...	...	@@ -3789,7 +3789,7 @@ FnTableEntry scope_get_fn_if_root(Scope scope) {
3789	3789	return nullptr;
3790	3790	}
3791	3791
3792		TypeEnumField find_enum_type_field(TypeTableEntry enum_type, Buf *name) {
	3792	TypeEnumField find_enum_type_field(ZigType enum_type, Buf *name) {
3793	3793	assert(enum_type->id == TypeTableEntryIdEnum);
3794	3794	if (enum_type->data.enumeration.src_field_count == 0)
3795	3795	return nullptr;
...	...	@@ -3799,7 +3799,7 @@ TypeEnumField find_enum_type_field(TypeTableEntry enum_type, Buf *name) {
3799	3799	return entry->value;
3800	3800	}
3801	3801
3802		TypeStructField find_struct_type_field(TypeTableEntry type_entry, Buf *name) {
	3802	TypeStructField find_struct_type_field(ZigType type_entry, Buf *name) {
3803	3803	assert(type_entry->id == TypeTableEntryIdStruct);
3804	3804	assert(type_entry->data.structure.complete);
3805	3805	if (type_entry->data.structure.src_field_count == 0)
...	...	@@ -3810,7 +3810,7 @@ TypeStructField find_struct_type_field(TypeTableEntry type_entry, Buf *name) {
3810	3810	return entry->value;
3811	3811	}
3812	3812
3813		TypeUnionField find_union_type_field(TypeTableEntry type_entry, Buf *name) {
	3813	TypeUnionField find_union_type_field(ZigType type_entry, Buf *name) {
3814	3814	assert(type_entry->id == TypeTableEntryIdUnion);
3815	3815	assert(type_entry->data.unionation.zero_bits_known);
3816	3816	if (type_entry->data.unionation.src_field_count == 0)
...	...	@@ -3821,7 +3821,7 @@ TypeUnionField find_union_type_field(TypeTableEntry type_entry, Buf *name) {
3821	3821	return entry->value;
3822	3822	}
3823	3823
3824		TypeUnionField find_union_field_by_tag(TypeTableEntry type_entry, const BigInt *tag) {
	3824	TypeUnionField find_union_field_by_tag(ZigType type_entry, const BigInt *tag) {
3825	3825	assert(type_entry->id == TypeTableEntryIdUnion);
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) {
...	...	@@ -3833,7 +3833,7 @@ TypeUnionField find_union_field_by_tag(TypeTableEntry type_entry, const BigInt
3833	3833	return nullptr;
3834	3834	}
3835	3835
3836		TypeEnumField find_enum_field_by_tag(TypeTableEntry enum_type, const BigInt *tag) {
	3836	TypeEnumField find_enum_field_by_tag(ZigType enum_type, const BigInt *tag) {
3837	3837	assert(enum_type->data.enumeration.zero_bits_known);
3838	3838	for (uint32_t i = 0; i < enum_type->data.enumeration.src_field_count; i += 1) {
3839	3839	TypeEnumField *field = &enum_type->data.enumeration.fields[i];
...	...	@@ -3845,7 +3845,7 @@ TypeEnumField find_enum_field_by_tag(TypeTableEntry enum_type, const BigInt *t
3845	3845	}
3846	3846
3847	3847
3848		static bool is_container(TypeTableEntry *type_entry) {
	3848	static bool is_container(ZigType *type_entry) {
3849	3849	switch (type_entry->id) {
3850	3850	case TypeTableEntryIdInvalid:
3851	3851	zig_unreachable();
...	...	@@ -3880,28 +3880,28 @@ static bool is_container(TypeTableEntry *type_entry) {
3880	3880	zig_unreachable();
3881	3881	}
3882	3882
3883		bool is_ref(TypeTableEntry *type_entry) {
	3883	bool is_ref(ZigType *type_entry) {
3884	3884	return type_entry->id == TypeTableEntryIdPointer && type_entry->data.pointer.ptr_len == PtrLenSingle;
3885	3885	}
3886	3886
3887		bool is_array_ref(TypeTableEntry *type_entry) {
3888		TypeTableEntry *array = is_ref(type_entry) ?
	3887	bool is_array_ref(ZigType *type_entry) {
	3888	ZigType *array = is_ref(type_entry) ?
3889	3889	type_entry->data.pointer.child_type : type_entry;
3890	3890	return array->id == TypeTableEntryIdArray;
3891	3891	}
3892	3892
3893		bool is_container_ref(TypeTableEntry *type_entry) {
	3893	bool is_container_ref(ZigType *type_entry) {
3894	3894	return is_ref(type_entry) ?
3895	3895	is_container(type_entry->data.pointer.child_type) : is_container(type_entry);
3896	3896	}
3897	3897
3898		TypeTableEntry container_ref_type(TypeTableEntry type_entry) {
	3898	ZigType container_ref_type(ZigType type_entry) {
3899	3899	assert(is_container_ref(type_entry));
3900	3900	return is_ref(type_entry) ?
3901	3901	type_entry->data.pointer.child_type : type_entry;
3902	3902	}
3903	3903
3904		void resolve_container_type(CodeGen g, TypeTableEntry type_entry) {
	3904	void resolve_container_type(CodeGen g, ZigType type_entry) {
3905	3905	switch (type_entry->id) {
3906	3906	case TypeTableEntryIdStruct:
3907	3907	resolve_struct_type(g, type_entry);
...	...	@@ -3939,7 +3939,7 @@ void resolve_container_type(CodeGen g, TypeTableEntry type_entry) {
3939	3939	}
3940	3940	}
3941	3941
3942		TypeTableEntry get_codegen_ptr_type(TypeTableEntry type) {
	3942	ZigType get_codegen_ptr_type(ZigType type) {
3943	3943	if (type->id == TypeTableEntryIdPointer) return type;
3944	3944	if (type->id == TypeTableEntryIdFn) return type;
3945	3945	if (type->id == TypeTableEntryIdPromise) return type;
...	...	@@ -3951,12 +3951,12 @@ TypeTableEntry get_codegen_ptr_type(TypeTableEntry type) {
3951	3951	return nullptr;
3952	3952	}
3953	3953
3954		bool type_is_codegen_pointer(TypeTableEntry *type) {
	3954	bool type_is_codegen_pointer(ZigType *type) {
3955	3955	return get_codegen_ptr_type(type) == type;
3956	3956	}
3957	3957
3958		uint32_t get_ptr_align(TypeTableEntry *type) {
3959		TypeTableEntry *ptr_type = get_codegen_ptr_type(type);
	3958	uint32_t get_ptr_align(ZigType *type) {
	3959	ZigType *ptr_type = get_codegen_ptr_type(type);
3960	3960	if (ptr_type->id == TypeTableEntryIdPointer) {
3961	3961	return ptr_type->data.pointer.alignment;
3962	3962	} else if (ptr_type->id == TypeTableEntryIdFn) {
...	...	@@ -3968,8 +3968,8 @@ uint32_t get_ptr_align(TypeTableEntry *type) {
3968	3968	}
3969	3969	}
3970	3970
3971		bool get_ptr_const(TypeTableEntry *type) {
3972		TypeTableEntry *ptr_type = get_codegen_ptr_type(type);
	3971	bool get_ptr_const(ZigType *type) {
	3972	ZigType *ptr_type = get_codegen_ptr_type(type);
3973	3973	if (ptr_type->id == TypeTableEntryIdPointer) {
3974	3974	return ptr_type->data.pointer.is_const;
3975	3975	} else if (ptr_type->id == TypeTableEntryIdFn) {
...	...	@@ -3991,7 +3991,7 @@ AstNode get_param_decl_node(FnTableEntry fn_entry, size_t index) {
3991	3991	}
3992	3992
3993	3993	static void define_local_param_variables(CodeGen g, FnTableEntry fn_table_entry) {
3994		TypeTableEntry *fn_type = fn_table_entry->type_entry;
	3994	ZigType *fn_type = fn_table_entry->type_entry;
3995	3995	assert(!fn_type->data.fn.is_generic);
3996	3996	FnTypeId *fn_type_id = &fn_type->data.fn.fn_type_id;
3997	3997	for (size_t i = 0; i < fn_type_id->param_count; i += 1) {
...	...	@@ -4008,7 +4008,7 @@ static void define_local_param_variables(CodeGen g, FnTableEntry fn_table_entr
4008	4008	continue;
4009	4009	}
4010	4010
4011		TypeTableEntry *param_type = param_info->type;
	4011	ZigType *param_type = param_info->type;
4012	4012	bool is_noalias = param_info->is_noalias;
4013	4013
4014	4014	if (is_noalias && get_codegen_ptr_type(param_type) == nullptr) {
...	...	@@ -4031,7 +4031,7 @@ static void define_local_param_variables(CodeGen g, FnTableEntry fn_table_entr
4031	4031	}
4032	4032	}
4033	4033
4034		bool resolve_inferred_error_set(CodeGen g, TypeTableEntry err_set_type, AstNode *source_node) {
	4034	bool resolve_inferred_error_set(CodeGen g, ZigType err_set_type, AstNode *source_node) {
4035	4035	FnTableEntry *infer_fn = err_set_type->data.error_set.infer_fn;
4036	4036	if (infer_fn != nullptr) {
4037	4037	if (infer_fn->anal_state == FnAnalStateInvalid) {
...	...	@@ -4053,11 +4053,11 @@ bool resolve_inferred_error_set(CodeGen g, TypeTableEntry err_set_type, AstNod
4053	4053	}
4054	4054
4055	4055	void analyze_fn_ir(CodeGen g, FnTableEntry fn_table_entry, AstNode *return_type_node) {
4056		TypeTableEntry *fn_type = fn_table_entry->type_entry;
	4056	ZigType *fn_type = fn_table_entry->type_entry;
4057	4057	assert(!fn_type->data.fn.is_generic);
4058	4058	FnTypeId *fn_type_id = &fn_type->data.fn.fn_type_id;
4059	4059
4060		TypeTableEntry *block_return_type = ir_analyze(g, &fn_table_entry->ir_executable,
	4060	ZigType *block_return_type = ir_analyze(g, &fn_table_entry->ir_executable,
4061	4061	&fn_table_entry->analyzed_executable, fn_type_id->return_type, return_type_node);
4062	4062	fn_table_entry->src_implicit_return_type = block_return_type;
4063	4063
...	...	@@ -4068,9 +4068,9 @@ void analyze_fn_ir(CodeGen g, FnTableEntry fn_table_entry, AstNode *return_typ
4068	4068	}
4069	4069
4070	4070	if (fn_type_id->return_type->id == TypeTableEntryIdErrorUnion) {
4071		TypeTableEntry *return_err_set_type = fn_type_id->return_type->data.error_union.err_set_type;
	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		TypeTableEntry *inferred_err_set_type;
	4073	ZigType *inferred_err_set_type;
4074	4074	if (fn_table_entry->src_implicit_return_type->id == TypeTableEntryIdErrorSet) {
4075	4075	inferred_err_set_type = fn_table_entry->src_implicit_return_type;
4076	4076	} else if (fn_table_entry->src_implicit_return_type->id == TypeTableEntryIdErrorUnion) {
...	...	@@ -4129,7 +4129,7 @@ static void analyze_fn_body(CodeGen g, FnTableEntry fn_table_entry) {
4129	4129
4130	4130	define_local_param_variables(g, fn_table_entry);
4131	4131
4132		TypeTableEntry *fn_type = fn_table_entry->type_entry;
	4132	ZigType *fn_type = fn_table_entry->type_entry;
4133	4133	assert(!fn_type->data.fn.is_generic);
4134	4134
4135	4135	ir_gen_fn(g, fn_table_entry);
...	...	@@ -4355,7 +4355,7 @@ void semantic_analyze(CodeGen *g) {
4355	4355	}
4356	4356	}
4357	4357
4358		TypeTableEntry get_int_type(CodeGen g, bool is_signed, uint32_t size_in_bits) {
	4358	ZigType get_int_type(CodeGen g, bool is_signed, uint32_t size_in_bits) {
4359	4359	TypeId type_id = {};
4360	4360	type_id.id = TypeTableEntryIdInt;
4361	4361	type_id.data.integer.is_signed = is_signed;
...	...	@@ -4367,20 +4367,20 @@ TypeTableEntry get_int_type(CodeGen g, bool is_signed, uint32_t size_in_bits)
4367	4367	return entry->value;
4368	4368	}
4369	4369
4370		TypeTableEntry *new_entry = make_int_type(g, is_signed, size_in_bits);
	4370	ZigType *new_entry = make_int_type(g, is_signed, size_in_bits);
4371	4371	g->type_table.put(type_id, new_entry);
4372	4372	return new_entry;
4373	4373	}
4374	4374
4375		TypeTableEntry *get_c_int_type_ptr(CodeGen g, CIntType c_int_type) {
	4375	ZigType *get_c_int_type_ptr(CodeGen g, CIntType c_int_type) {
4376	4376	return &g->builtin_types.entry_c_int[c_int_type];
4377	4377	}
4378	4378
4379		TypeTableEntry get_c_int_type(CodeGen g, CIntType c_int_type) {
	4379	ZigType get_c_int_type(CodeGen g, CIntType c_int_type) {
4380	4380	return *get_c_int_type_ptr(g, c_int_type);
4381	4381	}
4382	4382
4383		bool handle_is_ptr(TypeTableEntry *type_entry) {
	4383	bool handle_is_ptr(ZigType *type_entry) {
4384	4384	switch (type_entry->id) {
4385	4385	case TypeTableEntryIdInvalid:
4386	4386	case TypeTableEntryIdMetaType:
...	...	@@ -4916,7 +4916,7 @@ static bool can_mutate_comptime_var_state(ConstExprValue *value) {
4916	4916	zig_unreachable();
4917	4917	}
4918	4918
4919		static bool return_type_is_cacheable(TypeTableEntry *return_type) {
	4919	static bool return_type_is_cacheable(ZigType *return_type) {
4920	4920	switch (return_type->id) {
4921	4921	case TypeTableEntryIdInvalid:
4922	4922	zig_unreachable();
...	...	@@ -4958,7 +4958,7 @@ static bool return_type_is_cacheable(TypeTableEntry *return_type) {
4958	4958	zig_unreachable();
4959	4959	}
4960	4960
4961		bool fn_eval_cacheable(Scope scope, TypeTableEntry return_type) {
	4961	bool fn_eval_cacheable(Scope scope, ZigType return_type) {
4962	4962	if (!return_type_is_cacheable(return_type))
4963	4963	return false;
4964	4964	while (scope) {
...	...	@@ -5027,14 +5027,14 @@ bool fn_eval_eql(Scope a, Scope b) {
5027	5027	return false;
5028	5028	}
5029	5029
5030		bool type_has_bits(TypeTableEntry *type_entry) {
	5030	bool type_has_bits(ZigType *type_entry) {
5031	5031	assert(type_entry);
5032	5032	assert(type_entry->id != TypeTableEntryIdInvalid);
5033	5033	assert(type_has_zero_bits_known(type_entry));
5034	5034	return !type_entry->zero_bits;
5035	5035	}
5036	5036
5037		bool type_requires_comptime(TypeTableEntry *type_entry) {
	5037	bool type_requires_comptime(ZigType *type_entry) {
5038	5038	switch (type_entry->id) {
5039	5039	case TypeTableEntryIdInvalid:
5040	5040	case TypeTableEntryIdOpaque:
...	...	@@ -5143,27 +5143,27 @@ ConstExprValue create_const_c_str_lit(CodeGen g, Buf *str) {
5143	5143	return const_val;
5144	5144	}
5145	5145
5146		void init_const_bigint(ConstExprValue const_val, TypeTableEntry type, const BigInt *bigint) {
	5146	void init_const_bigint(ConstExprValue const_val, ZigType type, const BigInt *bigint) {
5147	5147	const_val->special = ConstValSpecialStatic;
5148	5148	const_val->type = type;
5149	5149	bigint_init_bigint(&const_val->data.x_bigint, bigint);
5150	5150	}
5151	5151
5152		ConstExprValue create_const_bigint(TypeTableEntry type, const BigInt *bigint) {
	5152	ConstExprValue create_const_bigint(ZigType type, const BigInt *bigint) {
5153	5153	ConstExprValue *const_val = create_const_vals(1);
5154	5154	init_const_bigint(const_val, type, bigint);
5155	5155	return const_val;
5156	5156	}
5157	5157
5158	5158
5159		void init_const_unsigned_negative(ConstExprValue const_val, TypeTableEntry type, uint64_t x, bool negative) {
	5159	void init_const_unsigned_negative(ConstExprValue const_val, ZigType type, uint64_t x, bool negative) {
5160	5160	const_val->special = ConstValSpecialStatic;
5161	5161	const_val->type = type;
5162	5162	bigint_init_unsigned(&const_val->data.x_bigint, x);
5163	5163	const_val->data.x_bigint.is_negative = negative;
5164	5164	}
5165	5165
5166		ConstExprValue create_const_unsigned_negative(TypeTableEntry type, uint64_t x, bool negative) {
	5166	ConstExprValue create_const_unsigned_negative(ZigType type, uint64_t x, bool negative) {
5167	5167	ConstExprValue *const_val = create_const_vals(1);
5168	5168	init_const_unsigned_negative(const_val, type, x, negative);
5169	5169	return const_val;
...	...	@@ -5177,19 +5177,19 @@ ConstExprValue create_const_usize(CodeGen g, uint64_t x) {
5177	5177	return create_const_unsigned_negative(g->builtin_types.entry_usize, x, false);
5178	5178	}
5179	5179
5180		void init_const_signed(ConstExprValue const_val, TypeTableEntry type, int64_t x) {
	5180	void init_const_signed(ConstExprValue const_val, ZigType type, int64_t x) {
5181	5181	const_val->special = ConstValSpecialStatic;
5182	5182	const_val->type = type;
5183	5183	bigint_init_signed(&const_val->data.x_bigint, x);
5184	5184	}
5185	5185
5186		ConstExprValue create_const_signed(TypeTableEntry type, int64_t x) {
	5186	ConstExprValue create_const_signed(ZigType type, int64_t x) {
5187	5187	ConstExprValue *const_val = create_const_vals(1);
5188	5188	init_const_signed(const_val, type, x);
5189	5189	return const_val;
5190	5190	}
5191	5191
5192		void init_const_float(ConstExprValue const_val, TypeTableEntry type, double value) {
	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	5195	if (type->id == TypeTableEntryIdComptimeFloat) {
...	...	@@ -5216,19 +5216,19 @@ void init_const_float(ConstExprValue const_val, TypeTableEntry type, double va
5216	5216	}
5217	5217	}
5218	5218
5219		ConstExprValue create_const_float(TypeTableEntry type, double value) {
	5219	ConstExprValue create_const_float(ZigType type, double value) {
5220	5220	ConstExprValue *const_val = create_const_vals(1);
5221	5221	init_const_float(const_val, type, value);
5222	5222	return const_val;
5223	5223	}
5224	5224
5225		void init_const_enum(ConstExprValue const_val, TypeTableEntry type, const BigInt *tag) {
	5225	void init_const_enum(ConstExprValue const_val, ZigType type, const BigInt *tag) {
5226	5226	const_val->special = ConstValSpecialStatic;
5227	5227	const_val->type = type;
5228	5228	bigint_init_bigint(&const_val->data.x_enum_tag, tag);
5229	5229	}
5230	5230
5231		ConstExprValue create_const_enum(TypeTableEntry type, const BigInt *tag) {
	5231	ConstExprValue create_const_enum(ZigType type, const BigInt *tag) {
5232	5232	ConstExprValue *const_val = create_const_vals(1);
5233	5233	init_const_enum(const_val, type, tag);
5234	5234	return const_val;
...	...	@@ -5247,24 +5247,24 @@ ConstExprValue create_const_bool(CodeGen g, bool value) {
5247	5247	return const_val;
5248	5248	}
5249	5249
5250		void init_const_runtime(ConstExprValue const_val, TypeTableEntry type) {
	5250	void init_const_runtime(ConstExprValue const_val, ZigType type) {
5251	5251	const_val->special = ConstValSpecialRuntime;
5252	5252	const_val->type = type;
5253	5253	}
5254	5254
5255		ConstExprValue create_const_runtime(TypeTableEntry type) {
	5255	ConstExprValue create_const_runtime(ZigType type) {
5256	5256	ConstExprValue *const_val = create_const_vals(1);
5257	5257	init_const_runtime(const_val, type);
5258	5258	return const_val;
5259	5259	}
5260	5260
5261		void init_const_type(CodeGen g, ConstExprValue const_val, TypeTableEntry *type_value) {
	5261	void init_const_type(CodeGen g, ConstExprValue const_val, ZigType *type_value) {
5262	5262	const_val->special = ConstValSpecialStatic;
5263	5263	const_val->type = g->builtin_types.entry_type;
5264	5264	const_val->data.x_type = type_value;
5265	5265	}
5266	5266
5267		ConstExprValue create_const_type(CodeGen g, TypeTableEntry *type_value) {
	5267	ConstExprValue create_const_type(CodeGen g, ZigType *type_value) {
5268	5268	ConstExprValue *const_val = create_const_vals(1);
5269	5269	init_const_type(g, const_val, type_value);
5270	5270	return const_val;
...	...	@@ -5275,7 +5275,7 @@ void init_const_slice(CodeGen g, ConstExprValue const_val, ConstExprValue *arr
5275	5275	{
5276	5276	assert(array_val->type->id == TypeTableEntryIdArray);
5277	5277
5278		TypeTableEntry *ptr_type = get_pointer_to_type_extra(g, array_val->type->data.array.child_type,
	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),
5280	5280	0, 0);
5281	5281
...	...	@@ -5298,7 +5298,7 @@ void init_const_ptr_array(CodeGen g, ConstExprValue const_val, ConstExprValue
5298	5298	size_t elem_index, bool is_const, PtrLen ptr_len)
5299	5299	{
5300	5300	assert(array_val->type->id == TypeTableEntryIdArray);
5301		TypeTableEntry *child_type = array_val->type->data.array.child_type;
	5301	ZigType *child_type = array_val->type->data.array.child_type;
5302	5302
5303	5303	const_val->special = ConstValSpecialStatic;
5304	5304	const_val->type = get_pointer_to_type_extra(g, child_type, is_const, false,
...	...	@@ -5329,7 +5329,7 @@ ConstExprValue create_const_ptr_ref(CodeGen g, ConstExprValue *pointee_val, bo
5329	5329	return const_val;
5330	5330	}
5331	5331
5332		void init_const_ptr_hard_coded_addr(CodeGen g, ConstExprValue const_val, TypeTableEntry *pointee_type,
	5332	void init_const_ptr_hard_coded_addr(CodeGen g, ConstExprValue const_val, ZigType *pointee_type,
5333	5333	size_t addr, bool is_const)
5334	5334	{
5335	5335	const_val->special = ConstValSpecialStatic;
...	...	@@ -5338,7 +5338,7 @@ void init_const_ptr_hard_coded_addr(CodeGen g, ConstExprValue const_val, TypeT
5338	5338	const_val->data.x_ptr.data.hard_coded_addr.addr = addr;
5339	5339	}
5340	5340
5341		ConstExprValue create_const_ptr_hard_coded_addr(CodeGen g, TypeTableEntry *pointee_type,
	5341	ConstExprValue create_const_ptr_hard_coded_addr(CodeGen g, ZigType *pointee_type,
5342	5342	size_t addr, bool is_const)
5343	5343	{
5344	5344	ConstExprValue *const_val = create_const_vals(1);
...	...	@@ -5362,7 +5362,7 @@ ConstExprValue create_const_arg_tuple(CodeGen g, size_t arg_index_start, size_
5362	5362
5363	5363	void init_const_undefined(CodeGen g, ConstExprValue const_val) {
5364	5364	Error err;
5365		TypeTableEntry *wanted_type = const_val->type;
	5365	ZigType *wanted_type = const_val->type;
5366	5366	if (wanted_type->id == TypeTableEntryIdArray) {
5367	5367	const_val->special = ConstValSpecialStatic;
5368	5368	const_val->data.x_array.special = ConstArraySpecialUndef;
...	...	@@ -5400,7 +5400,7 @@ ConstExprValue *create_const_vals(size_t count) {
5400	5400	return vals;
5401	5401	}
5402	5402
5403		Error ensure_complete_type(CodeGen g, TypeTableEntry type_entry) {
	5403	Error ensure_complete_type(CodeGen g, ZigType type_entry) {
5404	5404	if (type_is_invalid(type_entry))
5405	5405	return ErrorSemanticAnalyzeFail;
5406	5406	if (type_entry->id == TypeTableEntryIdStruct) {
...	...	@@ -5416,7 +5416,7 @@ Error ensure_complete_type(CodeGen g, TypeTableEntry type_entry) {
5416	5416	return ErrorNone;
5417	5417	}
5418	5418
5419		Error type_ensure_zero_bits_known(CodeGen g, TypeTableEntry type_entry) {
	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	5422	if (type_entry->id == TypeTableEntryIdStruct) {
...	...	@@ -5591,7 +5591,7 @@ bool const_values_equal(ConstExprValue a, ConstExprValue b) {
5591	5591	zig_unreachable();
5592	5592	}
5593	5593
5594		void eval_min_max_value_int(CodeGen g, TypeTableEntry int_type, BigInt *bigint, bool is_max) {
	5594	void eval_min_max_value_int(CodeGen g, ZigType int_type, BigInt *bigint, bool is_max) {
5595	5595	assert(int_type->id == TypeTableEntryIdInt);
5596	5596	if (int_type->data.integral.bit_count == 0) {
5597	5597	bigint_init_unsigned(bigint, 0);
...	...	@@ -5628,7 +5628,7 @@ void eval_min_max_value_int(CodeGen g, TypeTableEntry int_type, BigInt *bigint
5628	5628	}
5629	5629	}
5630	5630
5631		void eval_min_max_value(CodeGen g, TypeTableEntry type_entry, ConstExprValue *const_val, bool is_max) {
	5631	void eval_min_max_value(CodeGen g, ZigType type_entry, ConstExprValue *const_val, bool is_max) {
5632	5632	if (type_entry->id == TypeTableEntryIdInt) {
5633	5633	const_val->special = ConstValSpecialStatic;
5634	5634	eval_min_max_value_int(g, type_entry, &const_val->data.x_bigint, is_max);
...	...	@@ -5642,7 +5642,7 @@ void eval_min_max_value(CodeGen g, TypeTableEntry type_entry, ConstExprValue *
5642	5642	}
5643	5643	}
5644	5644
5645		void render_const_val_ptr(CodeGen g, Buf buf, ConstExprValue const_val, TypeTableEntry type_entry) {
	5645	void render_const_val_ptr(CodeGen g, Buf buf, ConstExprValue const_val, ZigType type_entry) {
5646	5646	switch (const_val->data.x_ptr.special) {
5647	5647	case ConstPtrSpecialInvalid:
5648	5648	zig_unreachable();
...	...	@@ -5690,7 +5690,7 @@ void render_const_value(CodeGen g, Buf buf, ConstExprValue *const_val) {
5690	5690	}
5691	5691	assert(const_val->type);
5692	5692
5693		TypeTableEntry *type_entry = const_val->type;
	5693	ZigType *type_entry = const_val->type;
5694	5694	switch (type_entry->id) {
5695	5695	case TypeTableEntryIdOpaque:
5696	5696	zig_unreachable();
...	...	@@ -5765,7 +5765,7 @@ void render_const_value(CodeGen g, Buf buf, ConstExprValue *const_val) {
5765	5765	}
5766	5766	case TypeTableEntryIdArray:
5767	5767	{
5768		TypeTableEntry *child_type = type_entry->data.array.child_type;
	5768	ZigType *child_type = type_entry->data.array.child_type;
5769	5769	uint64_t len = type_entry->data.array.len;
5770	5770
5771	5771	if (const_val->data.x_array.special == ConstArraySpecialUndef) {
...	...	@@ -5878,8 +5878,8 @@ void render_const_value(CodeGen g, Buf buf, ConstExprValue *const_val) {
5878	5878	zig_unreachable();
5879	5879	}
5880	5880
5881		TypeTableEntry make_int_type(CodeGen g, bool is_signed, uint32_t size_in_bits) {
5882		TypeTableEntry *entry = new_type_table_entry(TypeTableEntryIdInt);
	5881	ZigType make_int_type(CodeGen g, bool is_signed, uint32_t size_in_bits) {
	5882	ZigType *entry = new_type_table_entry(TypeTableEntryIdInt);
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);
...	...	@@ -6071,7 +6071,7 @@ void expand_undef_array(CodeGen g, ConstExprValue const_val) {
6071	6071
6072	6072	ConstParent get_const_val_parent(CodeGen g, ConstExprValue *value) {
6073	6073	assert(value->type);
6074		TypeTableEntry *type_entry = value->type;
	6074	ZigType *type_entry = value->type;
6075	6075	if (type_entry->id == TypeTableEntryIdArray) {
6076	6076	expand_undef_array(g, value);
6077	6077	return &value->data.x_array.s_none.parent;
...	...	@@ -6083,7 +6083,7 @@ ConstParent get_const_val_parent(CodeGen g, ConstExprValue *value) {
6083	6083	return nullptr;
6084	6084	}
6085	6085
6086		static const TypeTableEntryId all_type_ids[] = {
	6086	static const ZigTypeId all_type_ids[] = {
6087	6087	TypeTableEntryIdMetaType,
6088	6088	TypeTableEntryIdVoid,
6089	6089	TypeTableEntryIdBool,
...	...	@@ -6111,7 +6111,7 @@ static const TypeTableEntryId all_type_ids[] = {
6111	6111	TypeTableEntryIdPromise,
6112	6112	};
6113	6113
6114		TypeTableEntryId type_id_at_index(size_t index) {
	6114	ZigTypeId type_id_at_index(size_t index) {
6115	6115	assert(index < array_length(all_type_ids));
6116	6116	return all_type_ids[index];
6117	6117	}
...	...	@@ -6120,7 +6120,7 @@ size_t type_id_len() {
6120	6120	return array_length(all_type_ids);
6121	6121	}
6122	6122
6123		size_t type_id_index(TypeTableEntry *entry) {
	6123	size_t type_id_index(ZigType *entry) {
6124	6124	switch (entry->id) {
6125	6125	case TypeTableEntryIdInvalid:
6126	6126	zig_unreachable();
...	...	@@ -6180,7 +6180,7 @@ size_t type_id_index(TypeTableEntry *entry) {
6180	6180	zig_unreachable();
6181	6181	}
6182	6182
6183		const char *type_id_name(TypeTableEntryId id) {
	6183	const char *type_id_name(ZigTypeId id) {
6184	6184	switch (id) {
6185	6185	case TypeTableEntryIdInvalid:
6186	6186	zig_unreachable();
...	...	@@ -6266,7 +6266,7 @@ LinkLib add_link_lib(CodeGen g, Buf *name) {
6266	6266	return link_lib;
6267	6267	}
6268	6268
6269		uint32_t get_abi_alignment(CodeGen g, TypeTableEntry type_entry) {
	6269	uint32_t get_abi_alignment(CodeGen g, ZigType type_entry) {
6270	6270	assertNoError(type_ensure_zero_bits_known(g, type_entry));
6271	6271	if (type_entry->zero_bits) return 0;
6272	6272
...	...	@@ -6290,7 +6290,7 @@ uint32_t get_abi_alignment(CodeGen g, TypeTableEntry type_entry) {
6290	6290	}
6291	6291	}
6292	6292
6293		TypeTableEntry get_align_amt_type(CodeGen g) {
	6293	ZigType get_align_amt_type(CodeGen g) {
6294	6294	if (g->align_amt_type == nullptr) {
6295	6295	// according to LLVM the maximum alignment is 1 << 29.
6296	6296	g->align_amt_type = get_int_type(g, false, 29);
...	...	@@ -6298,11 +6298,11 @@ TypeTableEntry get_align_amt_type(CodeGen g) {
6298	6298	return g->align_amt_type;
6299	6299	}
6300	6300
6301		uint32_t type_ptr_hash(const TypeTableEntry *ptr) {
	6301	uint32_t type_ptr_hash(const ZigType *ptr) {
6302	6302	return hash_ptr((void*)ptr);
6303	6303	}
6304	6304
6305		bool type_ptr_eql(const TypeTableEntry a, const TypeTableEntry b) {
	6305	bool type_ptr_eql(const ZigType a, const ZigType b) {
6306	6306	return a == b;
6307	6307	}
6308	6308
...	...	@@ -6316,7 +6316,7 @@ ConstExprValue get_builtin_value(CodeGen codegen, const char *name) {
6316	6316	return var_value;
6317	6317	}
6318	6318
6319		bool type_is_global_error_set(TypeTableEntry *err_set_type) {
	6319	bool type_is_global_error_set(ZigType *err_set_type) {
6320	6320	assert(err_set_type->id == TypeTableEntryIdErrorSet);
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;
...	...	@@ -6326,7 +6326,7 @@ uint32_t get_coro_frame_align_bytes(CodeGen *g) {
6326	6326	return g->pointer_size_bytes * 2;
6327	6327	}
6328	6328
6329		bool type_can_fail(TypeTableEntry *type_entry) {
	6329	bool type_can_fail(ZigType *type_entry) {
6330	6330	return type_entry->id == TypeTableEntryIdErrorUnion \|\| type_entry->id == TypeTableEntryIdErrorSet;
6331	6331	}
6332	6332
...	...	@@ -6334,7 +6334,7 @@ bool fn_type_can_fail(FnTypeId *fn_type_id) {
6334	6334	return type_can_fail(fn_type_id->return_type) \|\| fn_type_id->cc == CallingConventionAsync;
6335	6335	}
6336	6336
6337		TypeTableEntry get_primitive_type(CodeGen g, Buf *name) {
	6337	ZigType get_primitive_type(CodeGen g, Buf *name) {
6338	6338	if (buf_len(name) >= 2) {
6339	6339	uint8_t first_c = buf_ptr(name)[0];
6340	6340	if (first_c == 'i' \|\| first_c == 'u') {

src/analyze.hpp+85-85

...	...	@@ -14,35 +14,35 @@
14	14	void semantic_analyze(CodeGen *g);
15	15	ErrorMsg add_node_error(CodeGen g, AstNode node, Buf msg);
16	16	ErrorMsg add_error_note(CodeGen g, ErrorMsg parent_msg, AstNode node, Buf *msg);
17		TypeTableEntry *new_type_table_entry(TypeTableEntryId id);
18		TypeTableEntry get_pointer_to_type(CodeGen g, TypeTableEntry *child_type, bool is_const);
19		TypeTableEntry get_pointer_to_type_extra(CodeGen g, TypeTableEntry *child_type, bool is_const,
	17	ZigType *new_type_table_entry(ZigTypeId id);
	18	ZigType get_pointer_to_type(CodeGen g, ZigType *child_type, bool is_const);
	19	ZigType get_pointer_to_type_extra(CodeGen g, ZigType *child_type, bool is_const,
20	20	bool is_volatile, PtrLen ptr_len, uint32_t byte_alignment, uint32_t bit_offset, uint32_t unaligned_bit_count);
21		uint64_t type_size(CodeGen g, TypeTableEntry type_entry);
22		uint64_t type_size_bits(CodeGen g, TypeTableEntry type_entry);
23		TypeTableEntry get_int_type(CodeGen g, bool is_signed, uint32_t size_in_bits);
24		TypeTableEntry *get_c_int_type_ptr(CodeGen g, CIntType c_int_type);
25		TypeTableEntry get_c_int_type(CodeGen g, CIntType c_int_type);
26		TypeTableEntry get_fn_type(CodeGen g, FnTypeId *fn_type_id);
27		TypeTableEntry get_optional_type(CodeGen g, TypeTableEntry *child_type);
28		TypeTableEntry get_array_type(CodeGen g, TypeTableEntry *child_type, uint64_t array_size);
29		TypeTableEntry get_slice_type(CodeGen g, TypeTableEntry *ptr_type);
30		TypeTableEntry get_partial_container_type(CodeGen g, Scope *scope, ContainerKind kind,
	21	uint64_t type_size(CodeGen g, ZigType type_entry);
	22	uint64_t type_size_bits(CodeGen g, ZigType type_entry);
	23	ZigType get_int_type(CodeGen g, bool is_signed, uint32_t size_in_bits);
	24	ZigType *get_c_int_type_ptr(CodeGen g, CIntType c_int_type);
	25	ZigType get_c_int_type(CodeGen g, CIntType c_int_type);
	26	ZigType get_fn_type(CodeGen g, FnTypeId *fn_type_id);
	27	ZigType get_optional_type(CodeGen g, ZigType *child_type);
	28	ZigType get_array_type(CodeGen g, ZigType *child_type, uint64_t array_size);
	29	ZigType get_slice_type(CodeGen g, ZigType *ptr_type);
	30	ZigType get_partial_container_type(CodeGen g, Scope *scope, ContainerKind kind,
31	31	AstNode decl_node, const char name, ContainerLayout layout);
32		TypeTableEntry get_smallest_unsigned_int_type(CodeGen g, uint64_t x);
33		TypeTableEntry get_error_union_type(CodeGen g, TypeTableEntry err_set_type, TypeTableEntry payload_type);
34		TypeTableEntry get_bound_fn_type(CodeGen g, FnTableEntry *fn_entry);
35		TypeTableEntry get_opaque_type(CodeGen g, Scope scope, AstNode source_node, const char *name);
36		TypeTableEntry get_struct_type(CodeGen g, const char type_name, const char field_names[],
37		TypeTableEntry *field_types[], size_t field_count);
38		TypeTableEntry get_promise_type(CodeGen g, TypeTableEntry *result_type);
39		TypeTableEntry get_promise_frame_type(CodeGen g, TypeTableEntry *return_type);
40		TypeTableEntry get_test_fn_type(CodeGen g);
41		bool handle_is_ptr(TypeTableEntry *type_entry);
	32	ZigType get_smallest_unsigned_int_type(CodeGen g, uint64_t x);
	33	ZigType get_error_union_type(CodeGen g, ZigType err_set_type, ZigType payload_type);
	34	ZigType get_bound_fn_type(CodeGen g, FnTableEntry *fn_entry);
	35	ZigType get_opaque_type(CodeGen g, Scope scope, AstNode source_node, const char *name);
	36	ZigType get_struct_type(CodeGen g, const char type_name, const char field_names[],
	37	ZigType *field_types[], size_t field_count);
	38	ZigType get_promise_type(CodeGen g, ZigType *result_type);
	39	ZigType get_promise_frame_type(CodeGen g, ZigType *return_type);
	40	ZigType get_test_fn_type(CodeGen g);
	41	bool handle_is_ptr(ZigType *type_entry);
42	42	void find_libc_include_path(CodeGen *g);
43	43	void find_libc_lib_path(CodeGen *g);
44	44
45		bool type_has_bits(TypeTableEntry *type_entry);
	45	bool type_has_bits(ZigType *type_entry);
46	46
47	47
48	48	ImportTableEntry add_source_file(CodeGen g, PackageTableEntry package, Buf abs_full_path, Buf *source_code);
...	...	@@ -51,28 +51,28 @@ ImportTableEntry add_source_file(CodeGen g, PackageTableEntry package, Buf a
51	51	VariableTableEntry find_variable(CodeGen g, Scope orig_context, Buf name);
52	52	Tld find_decl(CodeGen g, Scope scope, Buf name);
53	53	void resolve_top_level_decl(CodeGen g, Tld tld, bool pointer_only, AstNode *source_node);
54		bool type_is_codegen_pointer(TypeTableEntry *type);
55
56		TypeTableEntry get_codegen_ptr_type(TypeTableEntry type);
57		uint32_t get_ptr_align(TypeTableEntry *type);
58		bool get_ptr_const(TypeTableEntry *type);
59		TypeTableEntry validate_var_type(CodeGen g, AstNode source_node, TypeTableEntry type_entry);
60		TypeTableEntry container_ref_type(TypeTableEntry type_entry);
61		bool type_is_complete(TypeTableEntry *type_entry);
62		bool type_is_invalid(TypeTableEntry *type_entry);
63		bool type_is_global_error_set(TypeTableEntry *err_set_type);
64		bool type_has_zero_bits_known(TypeTableEntry *type_entry);
65		void resolve_container_type(CodeGen g, TypeTableEntry type_entry);
66		ScopeDecls get_container_scope(TypeTableEntry type_entry);
67		TypeStructField find_struct_type_field(TypeTableEntry type_entry, Buf *name);
68		TypeEnumField find_enum_type_field(TypeTableEntry enum_type, Buf *name);
69		TypeUnionField find_union_type_field(TypeTableEntry type_entry, Buf *name);
70		TypeEnumField find_enum_field_by_tag(TypeTableEntry enum_type, const BigInt *tag);
71		TypeUnionField find_union_field_by_tag(TypeTableEntry type_entry, const BigInt *tag);
72
73		bool is_ref(TypeTableEntry *type_entry);
74		bool is_array_ref(TypeTableEntry *type_entry);
75		bool is_container_ref(TypeTableEntry *type_entry);
	54	bool type_is_codegen_pointer(ZigType *type);
	55
	56	ZigType get_codegen_ptr_type(ZigType type);
	57	uint32_t get_ptr_align(ZigType *type);
	58	bool get_ptr_const(ZigType *type);
	59	ZigType validate_var_type(CodeGen g, AstNode source_node, ZigType type_entry);
	60	ZigType container_ref_type(ZigType type_entry);
	61	bool type_is_complete(ZigType *type_entry);
	62	bool type_is_invalid(ZigType *type_entry);
	63	bool type_is_global_error_set(ZigType *err_set_type);
	64	bool type_has_zero_bits_known(ZigType *type_entry);
	65	void resolve_container_type(CodeGen g, ZigType type_entry);
	66	ScopeDecls get_container_scope(ZigType type_entry);
	67	TypeStructField find_struct_type_field(ZigType type_entry, Buf *name);
	68	TypeEnumField find_enum_type_field(ZigType enum_type, Buf *name);
	69	TypeUnionField find_union_type_field(ZigType type_entry, Buf *name);
	70	TypeEnumField find_enum_field_by_tag(ZigType enum_type, const BigInt *tag);
	71	TypeUnionField find_union_field_by_tag(ZigType type_entry, const BigInt *tag);
	72
	73	bool is_ref(ZigType *type_entry);
	74	bool is_array_ref(ZigType *type_entry);
	75	bool is_container_ref(ZigType *type_entry);
76	76	void scan_decls(CodeGen g, ScopeDecls decls_scope, AstNode *node);
77	77	void scan_import(CodeGen g, ImportTableEntry import);
78	78	void preview_use_decl(CodeGen g, AstNode node);
...	...	@@ -82,20 +82,20 @@ ImportTableEntry get_scope_import(Scope scope);
82	82	void init_tld(Tld tld, TldId id, Buf name, VisibMod visib_mod, AstNode source_node, Scope parent_scope);
83	83	VariableTableEntry add_variable(CodeGen g, AstNode source_node, Scope parent_scope, Buf *name,
84	84	bool is_const, ConstExprValue init_value, Tld src_tld);
85		TypeTableEntry analyze_type_expr(CodeGen g, Scope scope, AstNode node);
	85	ZigType analyze_type_expr(CodeGen g, Scope scope, AstNode node);
86	86	FnTableEntry create_fn(AstNode proto_node);
87	87	FnTableEntry *create_fn_raw(FnInline inline_value, GlobalLinkageId linkage);
88	88	void init_fn_type_id(FnTypeId fn_type_id, AstNode proto_node, size_t param_count_alloc);
89	89	AstNode get_param_decl_node(FnTableEntry fn_entry, size_t index);
90	90	FnTableEntry scope_get_fn_if_root(Scope scope);
91		bool type_requires_comptime(TypeTableEntry *type_entry);
92		Error ATTRIBUTE_MUST_USE ensure_complete_type(CodeGen g, TypeTableEntry type_entry);
93		Error ATTRIBUTE_MUST_USE type_ensure_zero_bits_known(CodeGen g, TypeTableEntry type_entry);
94		void complete_enum(CodeGen g, TypeTableEntry enum_type);
	91	bool type_requires_comptime(ZigType *type_entry);
	92	Error ATTRIBUTE_MUST_USE ensure_complete_type(CodeGen g, ZigType type_entry);
	93	Error ATTRIBUTE_MUST_USE type_ensure_zero_bits_known(CodeGen g, ZigType type_entry);
	94	void complete_enum(CodeGen g, ZigType enum_type);
95	95	bool ir_get_var_is_comptime(VariableTableEntry *var);
96	96	bool const_values_equal(ConstExprValue a, ConstExprValue b);
97		void eval_min_max_value(CodeGen g, TypeTableEntry type_entry, ConstExprValue *const_val, bool is_max);
98		void eval_min_max_value_int(CodeGen g, TypeTableEntry int_type, BigInt *bigint, bool is_max);
	97	void eval_min_max_value(CodeGen g, ZigType type_entry, ConstExprValue *const_val, bool is_max);
	98	void eval_min_max_value_int(CodeGen g, ZigType int_type, BigInt *bigint, bool is_max);
99	99
100	100	void render_const_value(CodeGen g, Buf buf, ConstExprValue *const_val);
101	101	void analyze_fn_ir(CodeGen g, FnTableEntry fn_table_entry, AstNode *return_type_node);
...	...	@@ -108,7 +108,7 @@ ScopeCImport create_cimport_scope(AstNode node, Scope *parent);
108	108	ScopeLoop create_loop_scope(AstNode node, Scope *parent);
109	109	ScopeSuspend create_suspend_scope(AstNode node, Scope *parent);
110	110	ScopeFnDef create_fndef_scope(AstNode node, Scope parent, FnTableEntry fn_entry);
111		ScopeDecls create_decls_scope(AstNode node, Scope parent, TypeTableEntry container_type, ImportTableEntry *import);
	111	ScopeDecls create_decls_scope(AstNode node, Scope parent, ZigType container_type, ImportTableEntry *import);
112	112	Scope create_comptime_scope(AstNode node, Scope *parent);
113	113	Scope create_coro_prelude_scope(AstNode node, Scope *parent);
114	114	Scope create_runtime_scope(AstNode node, Scope parent, IrInstruction is_comptime);
...	...	@@ -119,39 +119,39 @@ ConstExprValue create_const_str_lit(CodeGen g, Buf *str);
119	119	void init_const_c_str_lit(CodeGen g, ConstExprValue const_val, Buf *c_str);
120	120	ConstExprValue create_const_c_str_lit(CodeGen g, Buf *c_str);
121	121
122		void init_const_bigint(ConstExprValue const_val, TypeTableEntry type, const BigInt *bigint);
123		ConstExprValue create_const_bigint(TypeTableEntry type, const BigInt *bigint);
	122	void init_const_bigint(ConstExprValue const_val, ZigType type, const BigInt *bigint);
	123	ConstExprValue create_const_bigint(ZigType type, const BigInt *bigint);
124	124
125		void init_const_unsigned_negative(ConstExprValue const_val, TypeTableEntry type, uint64_t x, bool negative);
126		ConstExprValue create_const_unsigned_negative(TypeTableEntry type, uint64_t x, bool negative);
	125	void init_const_unsigned_negative(ConstExprValue const_val, ZigType type, uint64_t x, bool negative);
	126	ConstExprValue create_const_unsigned_negative(ZigType type, uint64_t x, bool negative);
127	127
128		void init_const_signed(ConstExprValue const_val, TypeTableEntry type, int64_t x);
129		ConstExprValue create_const_signed(TypeTableEntry type, int64_t x);
	128	void init_const_signed(ConstExprValue const_val, ZigType type, int64_t x);
	129	ConstExprValue create_const_signed(ZigType type, int64_t x);
130	130
131	131	void init_const_usize(CodeGen g, ConstExprValue const_val, uint64_t x);
132	132	ConstExprValue create_const_usize(CodeGen g, uint64_t x);
133	133
134		void init_const_float(ConstExprValue const_val, TypeTableEntry type, double value);
135		ConstExprValue create_const_float(TypeTableEntry type, double value);
	134	void init_const_float(ConstExprValue const_val, ZigType type, double value);
	135	ConstExprValue create_const_float(ZigType type, double value);
136	136
137		void init_const_enum(ConstExprValue const_val, TypeTableEntry type, const BigInt *tag);
138		ConstExprValue create_const_enum(TypeTableEntry type, const BigInt *tag);
	137	void init_const_enum(ConstExprValue const_val, ZigType type, const BigInt *tag);
	138	ConstExprValue create_const_enum(ZigType type, const BigInt *tag);
139	139
140	140	void init_const_bool(CodeGen g, ConstExprValue const_val, bool value);
141	141	ConstExprValue create_const_bool(CodeGen g, bool value);
142	142
143		void init_const_type(CodeGen g, ConstExprValue const_val, TypeTableEntry *type_value);
144		ConstExprValue create_const_type(CodeGen g, TypeTableEntry *type_value);
	143	void init_const_type(CodeGen g, ConstExprValue const_val, ZigType *type_value);
	144	ConstExprValue create_const_type(CodeGen g, ZigType *type_value);
145	145
146		void init_const_runtime(ConstExprValue const_val, TypeTableEntry type);
147		ConstExprValue create_const_runtime(TypeTableEntry type);
	146	void init_const_runtime(ConstExprValue const_val, ZigType type);
	147	ConstExprValue create_const_runtime(ZigType type);
148	148
149	149	void init_const_ptr_ref(CodeGen g, ConstExprValue const_val, ConstExprValue *pointee_val, bool is_const);
150	150	ConstExprValue create_const_ptr_ref(CodeGen g, ConstExprValue *pointee_val, bool is_const);
151	151
152		void init_const_ptr_hard_coded_addr(CodeGen g, ConstExprValue const_val, TypeTableEntry *pointee_type,
	152	void init_const_ptr_hard_coded_addr(CodeGen g, ConstExprValue const_val, ZigType *pointee_type,
153	153	size_t addr, bool is_const);
154		ConstExprValue create_const_ptr_hard_coded_addr(CodeGen g, TypeTableEntry *pointee_type,
	154	ConstExprValue create_const_ptr_hard_coded_addr(CodeGen g, ZigType *pointee_type,
155	155	size_t addr, bool is_const);
156	156
157	157	void init_const_ptr_array(CodeGen g, ConstExprValue const_val, ConstExprValue *array_val,
...	...	@@ -170,23 +170,23 @@ void init_const_undefined(CodeGen g, ConstExprValue const_val);
170	170
171	171	ConstExprValue *create_const_vals(size_t count);
172	172
173		TypeTableEntry make_int_type(CodeGen g, bool is_signed, uint32_t size_in_bits);
	173	ZigType make_int_type(CodeGen g, bool is_signed, uint32_t size_in_bits);
174	174	ConstParent get_const_val_parent(CodeGen g, ConstExprValue *value);
175	175	void expand_undef_array(CodeGen g, ConstExprValue const_val);
176	176	void update_compile_var(CodeGen g, Buf name, ConstExprValue *value);
177	177
178		const char *type_id_name(TypeTableEntryId id);
179		TypeTableEntryId type_id_at_index(size_t index);
	178	const char *type_id_name(ZigTypeId id);
	179	ZigTypeId type_id_at_index(size_t index);
180	180	size_t type_id_len();
181		size_t type_id_index(TypeTableEntry *entry);
182		TypeTableEntry get_generic_fn_type(CodeGen g, FnTypeId *fn_type_id);
183		Result<bool> type_is_copyable(CodeGen g, TypeTableEntry type_entry);
	181	size_t type_id_index(ZigType *entry);
	182	ZigType get_generic_fn_type(CodeGen g, FnTypeId *fn_type_id);
	183	Result<bool> type_is_copyable(CodeGen g, ZigType type_entry);
184	184	LinkLib create_link_lib(Buf name);
185	185	bool calling_convention_does_first_arg_return(CallingConvention cc);
186	186	LinkLib add_link_lib(CodeGen codegen, Buf *lib);
187	187
188		uint32_t get_abi_alignment(CodeGen g, TypeTableEntry type_entry);
189		TypeTableEntry get_align_amt_type(CodeGen g);
	188	uint32_t get_abi_alignment(CodeGen g, ZigType type_entry);
	189	ZigType get_align_amt_type(CodeGen g);
190	190	PackageTableEntry *new_anonymous_package(void);
191	191
192	192	Buf const_value_to_buffer(ConstExprValue const_val);
...	...	@@ -194,17 +194,17 @@ void add_fn_export(CodeGen g, FnTableEntry fn_table_entry, Buf *symbol_name, G
194	194
195	195
196	196	ConstExprValue get_builtin_value(CodeGen codegen, const char *name);
197		TypeTableEntry get_ptr_to_stack_trace_type(CodeGen g);
198		bool resolve_inferred_error_set(CodeGen g, TypeTableEntry err_set_type, AstNode *source_node);
	197	ZigType get_ptr_to_stack_trace_type(CodeGen g);
	198	bool resolve_inferred_error_set(CodeGen g, ZigType err_set_type, AstNode *source_node);
199	199
200		TypeTableEntry get_auto_err_set_type(CodeGen g, FnTableEntry *fn_entry);
	200	ZigType get_auto_err_set_type(CodeGen g, FnTableEntry *fn_entry);
201	201
202	202	uint32_t get_coro_frame_align_bytes(CodeGen *g);
203	203	bool fn_type_can_fail(FnTypeId *fn_type_id);
204		bool type_can_fail(TypeTableEntry *type_entry);
205		bool fn_eval_cacheable(Scope scope, TypeTableEntry return_type);
206		AstNode type_decl_node(TypeTableEntry type_entry);
	204	bool type_can_fail(ZigType *type_entry);
	205	bool fn_eval_cacheable(Scope scope, ZigType return_type);
	206	AstNode type_decl_node(ZigType type_entry);
207	207
208		TypeTableEntry get_primitive_type(CodeGen g, Buf *name);
	208	ZigType get_primitive_type(CodeGen g, Buf *name);
209	209
210	210	#endif

src/codegen.cpp+192-192

...	...	@@ -437,11 +437,11 @@ static uint32_t get_err_ret_trace_arg_index(CodeGen g, FnTableEntry fn_table_e
437	437	if (fn_table_entry->type_entry->data.fn.fn_type_id.cc == CallingConventionAsync) {
438	438	return 0;
439	439	}
440		TypeTableEntry *fn_type = fn_table_entry->type_entry;
	440	ZigType *fn_type = fn_table_entry->type_entry;
441	441	if (!fn_type_can_fail(&fn_type->data.fn.fn_type_id)) {
442	442	return UINT32_MAX;
443	443	}
444		TypeTableEntry *return_type = fn_type->data.fn.fn_type_id.return_type;
	444	ZigType *return_type = fn_type->data.fn.fn_type_id.return_type;
445	445	bool first_arg_ret = type_has_bits(return_type) && handle_is_ptr(return_type);
446	446	return first_arg_ret ? 1 : 0;
447	447	}
...	...	@@ -474,7 +474,7 @@ static LLVMValueRef fn_llvm_value(CodeGen g, FnTableEntry fn_table_entry) {
474	474	}
475	475
476	476
477		TypeTableEntry *fn_type = fn_table_entry->type_entry;
	477	ZigType *fn_type = fn_table_entry->type_entry;
478	478	LLVMTypeRef fn_llvm_type = fn_type->data.fn.raw_type_ref;
479	479	if (fn_table_entry->body_node == nullptr) {
480	480	LLVMValueRef existing_llvm_fn = LLVMGetNamedFunction(g->module, buf_ptr(symbol_name));
...	...	@@ -532,7 +532,7 @@ static LLVMValueRef fn_llvm_value(CodeGen g, FnTableEntry fn_table_entry) {
532	532	LLVMSetUnnamedAddr(fn_table_entry->llvm_value, true);
533	533	}
534	534
535		TypeTableEntry *return_type = fn_type->data.fn.fn_type_id.return_type;
	535	ZigType *return_type = fn_type->data.fn.fn_type_id.return_type;
536	536	if (return_type->id == TypeTableEntryIdUnreachable) {
537	537	addLLVMFnAttr(fn_table_entry->llvm_value, "noreturn");
538	538	}
...	...	@@ -596,7 +596,7 @@ static LLVMValueRef fn_llvm_value(CodeGen g, FnTableEntry fn_table_entry) {
596	596
597	597	FnTypeParamInfo *param_info = &fn_type->data.fn.fn_type_id.param_info[param_i];
598	598
599		TypeTableEntry *param_type = gen_info->type;
	599	ZigType *param_type = gen_info->type;
600	600	if (param_info->is_noalias) {
601	601	addLLVMArgAttr(fn_table_entry->llvm_value, (unsigned)gen_index, "noalias");
602	602	}
...	...	@@ -688,7 +688,7 @@ static void clear_debug_source_node(CodeGen *g) {
688	688	ZigLLVMClearCurrentDebugLocation(g->builder);
689	689	}
690	690
691		static LLVMValueRef get_arithmetic_overflow_fn(CodeGen g, TypeTableEntry type_entry,
	691	static LLVMValueRef get_arithmetic_overflow_fn(CodeGen g, ZigType type_entry,
692	692	const char signed_name, const char unsigned_name)
693	693	{
694	694	char fn_name[64];
...	...	@@ -712,7 +712,7 @@ static LLVMValueRef get_arithmetic_overflow_fn(CodeGen g, TypeTableEntry type_
712	712	return fn_val;
713	713	}
714	714
715		static LLVMValueRef get_int_overflow_fn(CodeGen g, TypeTableEntry type_entry, AddSubMul add_sub_mul) {
	715	static LLVMValueRef get_int_overflow_fn(CodeGen g, ZigType type_entry, AddSubMul add_sub_mul) {
716	716	assert(type_entry->id == TypeTableEntryIdInt);
717	717
718	718	ZigLLVMFnKey key = {};
...	...	@@ -742,7 +742,7 @@ static LLVMValueRef get_int_overflow_fn(CodeGen g, TypeTableEntry type_entry,
742	742	return fn_val;
743	743	}
744	744
745		static LLVMValueRef get_float_fn(CodeGen g, TypeTableEntry type_entry, ZigLLVMFnId fn_id) {
	745	static LLVMValueRef get_float_fn(CodeGen g, ZigType type_entry, ZigLLVMFnId fn_id) {
746	746	assert(type_entry->id == TypeTableEntryIdFloat);
747	747
748	748	ZigLLVMFnKey key = {};
...	...	@@ -787,7 +787,7 @@ static LLVMValueRef gen_store_untyped(CodeGen *g, LLVMValueRef value, LLVMValueR
787	787	return instruction;
788	788	}
789	789
790		static LLVMValueRef gen_store(CodeGen g, LLVMValueRef value, LLVMValueRef ptr, TypeTableEntry ptr_type) {
	790	static LLVMValueRef gen_store(CodeGen g, LLVMValueRef value, LLVMValueRef ptr, ZigType ptr_type) {
791	791	assert(ptr_type->id == TypeTableEntryIdPointer);
792	792	return gen_store_untyped(g, value, ptr, ptr_type->data.pointer.alignment, ptr_type->data.pointer.is_volatile);
793	793	}
...	...	@@ -805,12 +805,12 @@ static LLVMValueRef gen_load_untyped(CodeGen *g, LLVMValueRef ptr, uint32_t alig
805	805	return result;
806	806	}
807	807
808		static LLVMValueRef gen_load(CodeGen g, LLVMValueRef ptr, TypeTableEntry ptr_type, const char *name) {
	808	static LLVMValueRef gen_load(CodeGen g, LLVMValueRef ptr, ZigType ptr_type, const char *name) {
809	809	assert(ptr_type->id == TypeTableEntryIdPointer);
810	810	return gen_load_untyped(g, ptr, ptr_type->data.pointer.alignment, ptr_type->data.pointer.is_volatile, name);
811	811	}
812	812
813		static LLVMValueRef get_handle_value(CodeGen g, LLVMValueRef ptr, TypeTableEntry type, TypeTableEntry *ptr_type) {
	813	static LLVMValueRef get_handle_value(CodeGen g, LLVMValueRef ptr, ZigType type, ZigType *ptr_type) {
814	814	if (type_has_bits(type)) {
815	815	if (handle_is_ptr(type)) {
816	816	return ptr;
...	...	@@ -918,9 +918,9 @@ static LLVMValueRef get_panic_msg_ptr_val(CodeGen *g, PanicMsgId msg_id) {
918	918	assert(val->global_refs->llvm_global);
919	919	}
920	920
921		TypeTableEntry *u8_ptr_type = get_pointer_to_type_extra(g, g->builtin_types.entry_u8, true, false,
	921	ZigType *u8_ptr_type = get_pointer_to_type_extra(g, g->builtin_types.entry_u8, true, false,
922	922	PtrLenUnknown, get_abi_alignment(g, g->builtin_types.entry_u8), 0, 0);
923		TypeTableEntry *str_type = get_slice_type(g, u8_ptr_type);
	923	ZigType *str_type = get_slice_type(g, u8_ptr_type);
924	924	return LLVMConstBitCast(val->global_refs->llvm_global, LLVMPointerType(str_type->type_ref, 0));
925	925	}
926	926
...	...	@@ -929,7 +929,7 @@ static void gen_panic(CodeGen *g, LLVMValueRef msg_arg, LLVMValueRef stack_trace
929	929	LLVMValueRef fn_val = fn_llvm_value(g, g->panic_fn);
930	930	LLVMCallConv llvm_cc = get_llvm_cc(g, g->panic_fn->type_entry->data.fn.fn_type_id.cc);
931	931	if (stack_trace_arg == nullptr) {
932		TypeTableEntry *ptr_to_stack_trace_type = get_ptr_to_stack_trace_type(g);
	932	ZigType *ptr_to_stack_trace_type = get_ptr_to_stack_trace_type(g);
933	933	stack_trace_arg = LLVMConstNull(ptr_to_stack_trace_type->type_ref);
934	934	}
935	935	LLVMValueRef args[] = {
...	...	@@ -1186,7 +1186,7 @@ static LLVMValueRef get_return_address_fn_val(CodeGen *g) {
1186	1186	if (g->return_address_fn_val)
1187	1187	return g->return_address_fn_val;
1188	1188
1189		TypeTableEntry *return_type = get_pointer_to_type(g, g->builtin_types.entry_u8, true);
	1189	ZigType *return_type = get_pointer_to_type(g, g->builtin_types.entry_u8, true);
1190	1190
1191	1191	LLVMTypeRef fn_type = LLVMFunctionType(return_type->type_ref,
1192	1192	&g->builtin_types.entry_i32->type_ref, 1, false);
...	...	@@ -1237,7 +1237,7 @@ static LLVMValueRef get_add_error_return_trace_addr_fn(CodeGen *g) {
1237	1237	size_t addresses_field_index = g->stack_trace_type->data.structure.fields[1].gen_index;
1238	1238	LLVMValueRef addresses_field_ptr = LLVMBuildStructGEP(g->builder, err_ret_trace_ptr, (unsigned)addresses_field_index, "");
1239	1239
1240		TypeTableEntry *slice_type = g->stack_trace_type->data.structure.fields[1].type_entry;
	1240	ZigType *slice_type = g->stack_trace_type->data.structure.fields[1].type_entry;
1241	1241	size_t ptr_field_index = slice_type->data.structure.fields[slice_ptr_index].gen_index;
1242	1242	LLVMValueRef ptr_field_ptr = LLVMBuildStructGEP(g->builder, addresses_field_ptr, (unsigned)ptr_field_index, "");
1243	1243	size_t len_field_index = slice_type->data.structure.fields[slice_len_index].gen_index;
...	...	@@ -1337,7 +1337,7 @@ static LLVMValueRef get_merge_err_ret_traces_fn_val(CodeGen *g) {
1337	1337	(unsigned)src_index_field_index, "");
1338	1338	LLVMValueRef src_addresses_field_ptr = LLVMBuildStructGEP(g->builder, src_stack_trace_ptr,
1339	1339	(unsigned)src_addresses_field_index, "");
1340		TypeTableEntry *slice_type = g->stack_trace_type->data.structure.fields[1].type_entry;
	1340	ZigType *slice_type = g->stack_trace_type->data.structure.fields[1].type_entry;
1341	1341	size_t ptr_field_index = slice_type->data.structure.fields[slice_ptr_index].gen_index;
1342	1342	LLVMValueRef src_ptr_field_ptr = LLVMBuildStructGEP(g->builder, src_addresses_field_ptr, (unsigned)ptr_field_index, "");
1343	1343	size_t len_field_index = slice_type->data.structure.fields[slice_len_index].gen_index;
...	...	@@ -1479,7 +1479,7 @@ static LLVMValueRef get_safety_crash_err_fn(CodeGen *g) {
1479	1479	LLVMSetUnnamedAddr(global_array, true);
1480	1480	LLVMSetAlignment(global_array, u8_align_bytes);
1481	1481
1482		TypeTableEntry *usize = g->builtin_types.entry_usize;
	1482	ZigType *usize = g->builtin_types.entry_usize;
1483	1483	LLVMValueRef full_buf_ptr_indices[] = {
1484	1484	LLVMConstNull(usize->type_ref),
1485	1485	LLVMConstNull(usize->type_ref),
...	...	@@ -1487,9 +1487,9 @@ static LLVMValueRef get_safety_crash_err_fn(CodeGen *g) {
1487	1487	LLVMValueRef full_buf_ptr = LLVMConstInBoundsGEP(global_array, full_buf_ptr_indices, 2);
1488	1488
1489	1489
1490		TypeTableEntry *u8_ptr_type = get_pointer_to_type_extra(g, g->builtin_types.entry_u8, true, false,
	1490	ZigType *u8_ptr_type = get_pointer_to_type_extra(g, g->builtin_types.entry_u8, true, false,
1491	1491	PtrLenUnknown, get_abi_alignment(g, g->builtin_types.entry_u8), 0, 0);
1492		TypeTableEntry *str_type = get_slice_type(g, u8_ptr_type);
	1492	ZigType *str_type = get_slice_type(g, u8_ptr_type);
1493	1493	LLVMValueRef global_slice_fields[] = {
1494	1494	full_buf_ptr,
1495	1495	LLVMConstNull(usize->type_ref),
...	...	@@ -1603,7 +1603,7 @@ static void gen_safety_crash_for_err(CodeGen g, LLVMValueRef err_val, Scope sc
1603	1603	LLVMValueRef safety_crash_err_fn = get_safety_crash_err_fn(g);
1604	1604	LLVMValueRef err_ret_trace_val = get_cur_err_ret_trace_val(g, scope);
1605	1605	if (err_ret_trace_val == nullptr) {
1606		TypeTableEntry *ptr_to_stack_trace_type = get_ptr_to_stack_trace_type(g);
	1606	ZigType *ptr_to_stack_trace_type = get_ptr_to_stack_trace_type(g);
1607	1607	err_ret_trace_val = LLVMConstNull(ptr_to_stack_trace_type->type_ref);
1608	1608	}
1609	1609	LLVMValueRef args[] = {
...	...	@@ -1649,8 +1649,8 @@ static void add_bounds_check(CodeGen *g, LLVMValueRef target_val,
1649	1649	LLVMPositionBuilderAtEnd(g->builder, ok_block);
1650	1650	}
1651	1651
1652		static LLVMValueRef gen_widen_or_shorten(CodeGen g, bool want_runtime_safety, TypeTableEntry actual_type,
1653		TypeTableEntry *wanted_type, LLVMValueRef expr_val)
	1652	static LLVMValueRef gen_widen_or_shorten(CodeGen g, bool want_runtime_safety, ZigType actual_type,
	1653	ZigType *wanted_type, LLVMValueRef expr_val)
1654	1654	{
1655	1655	assert(actual_type->id == wanted_type->id);
1656	1656
...	...	@@ -1729,7 +1729,7 @@ static LLVMValueRef gen_widen_or_shorten(CodeGen *g, bool want_runtime_safety, T
1729	1729	}
1730	1730	}
1731	1731
1732		static LLVMValueRef gen_overflow_op(CodeGen g, TypeTableEntry type_entry, AddSubMul op,
	1732	static LLVMValueRef gen_overflow_op(CodeGen g, ZigType type_entry, AddSubMul op,
1733	1733	LLVMValueRef val1, LLVMValueRef val2)
1734	1734	{
1735	1735	LLVMValueRef fn_val = get_int_overflow_fn(g, type_entry, op);
...	...	@@ -1789,11 +1789,11 @@ static LLVMRealPredicate cmp_op_to_real_predicate(IrBinOp cmp_op) {
1789	1789	}
1790	1790	}
1791	1791
1792		static LLVMValueRef gen_assign_raw(CodeGen g, LLVMValueRef ptr, TypeTableEntry ptr_type,
	1792	static LLVMValueRef gen_assign_raw(CodeGen g, LLVMValueRef ptr, ZigType ptr_type,
1793	1793	LLVMValueRef value)
1794	1794	{
1795	1795	assert(ptr_type->id == TypeTableEntryIdPointer);
1796		TypeTableEntry *child_type = ptr_type->data.pointer.child_type;
	1796	ZigType *child_type = ptr_type->data.pointer.child_type;
1797	1797
1798	1798	if (!type_has_bits(child_type))
1799	1799	return nullptr;
...	...	@@ -1807,7 +1807,7 @@ static LLVMValueRef gen_assign_raw(CodeGen *g, LLVMValueRef ptr, TypeTableEntry
1807	1807	LLVMValueRef src_ptr = LLVMBuildBitCast(g->builder, value, ptr_u8, "");
1808	1808	LLVMValueRef dest_ptr = LLVMBuildBitCast(g->builder, ptr, ptr_u8, "");
1809	1809
1810		TypeTableEntry *usize = g->builtin_types.entry_usize;
	1810	ZigType *usize = g->builtin_types.entry_usize;
1811	1811	uint64_t size_bytes = LLVMStoreSizeOfType(g->target_data_ref, child_type->type_ref);
1812	1812	uint64_t align_bytes = ptr_type->data.pointer.alignment;
1813	1813	assert(size_bytes > 0);
...	...	@@ -1876,7 +1876,7 @@ static LLVMValueRef ir_llvm_value(CodeGen g, IrInstruction instruction) {
1876	1876	// values are rendered with a type other than the one we expect
1877	1877	if (handle_is_ptr(instruction->value.type)) {
1878	1878	render_const_val_global(g, &instruction->value, "");
1879		TypeTableEntry *ptr_type = get_pointer_to_type(g, instruction->value.type, true);
	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	1881	} else if (instruction->value.type->id == TypeTableEntryIdPointer) {
1882	1882	instruction->llvm_value = LLVMBuildBitCast(g->builder, instruction->value.global_refs->llvm_value, instruction->value.type->type_ref, "");
...	...	@@ -1904,7 +1904,7 @@ static LLVMValueRef ir_render_save_err_ret_addr(CodeGen g, IrExecutable execut
1904	1904
1905	1905	static LLVMValueRef ir_render_return(CodeGen g, IrExecutable executable, IrInstructionReturn *return_instruction) {
1906	1906	LLVMValueRef value = ir_llvm_value(g, return_instruction->value);
1907		TypeTableEntry *return_type = return_instruction->value->value.type;
	1907	ZigType *return_type = return_instruction->value->value.type;
1908	1908
1909	1909	if (handle_is_ptr(return_type)) {
1910	1910	if (calling_convention_does_first_arg_return(g->cur_fn->type_entry->data.fn.fn_type_id.cc)) {
...	...	@@ -1921,7 +1921,7 @@ static LLVMValueRef ir_render_return(CodeGen g, IrExecutable executable, IrIns
1921	1921	return nullptr;
1922	1922	}
1923	1923
1924		static LLVMValueRef gen_overflow_shl_op(CodeGen g, TypeTableEntry type_entry,
	1924	static LLVMValueRef gen_overflow_shl_op(CodeGen g, ZigType type_entry,
1925	1925	LLVMValueRef val1, LLVMValueRef val2)
1926	1926	{
1927	1927	// for unsigned left shifting, we do the lossy shift, then logically shift
...	...	@@ -1951,7 +1951,7 @@ static LLVMValueRef gen_overflow_shl_op(CodeGen g, TypeTableEntry type_entry,
1951	1951	return result;
1952	1952	}
1953	1953
1954		static LLVMValueRef gen_overflow_shr_op(CodeGen g, TypeTableEntry type_entry,
	1954	static LLVMValueRef gen_overflow_shr_op(CodeGen g, ZigType type_entry,
1955	1955	LLVMValueRef val1, LLVMValueRef val2)
1956	1956	{
1957	1957	assert(type_entry->id == TypeTableEntryIdInt);
...	...	@@ -1976,7 +1976,7 @@ static LLVMValueRef gen_overflow_shr_op(CodeGen g, TypeTableEntry type_entry,
1976	1976	return result;
1977	1977	}
1978	1978
1979		static LLVMValueRef gen_floor(CodeGen g, LLVMValueRef val, TypeTableEntry type_entry) {
	1979	static LLVMValueRef gen_floor(CodeGen g, LLVMValueRef val, ZigType type_entry) {
1980	1980	if (type_entry->id == TypeTableEntryIdInt)
1981	1981	return val;
1982	1982
...	...	@@ -1984,7 +1984,7 @@ static LLVMValueRef gen_floor(CodeGen g, LLVMValueRef val, TypeTableEntry type
1984	1984	return LLVMBuildCall(g->builder, floor_fn, &val, 1, "");
1985	1985	}
1986	1986
1987		static LLVMValueRef gen_ceil(CodeGen g, LLVMValueRef val, TypeTableEntry type_entry) {
	1987	static LLVMValueRef gen_ceil(CodeGen g, LLVMValueRef val, ZigType type_entry) {
1988	1988	if (type_entry->id == TypeTableEntryIdInt)
1989	1989	return val;
1990	1990
...	...	@@ -2018,7 +2018,7 @@ static LLVMValueRef bigint_to_llvm_const(LLVMTypeRef type_ref, BigInt *bigint) {
2018	2018
2019	2019	static LLVMValueRef gen_div(CodeGen *g, bool want_runtime_safety, bool want_fast_math,
2020	2020	LLVMValueRef val1, LLVMValueRef val2,
2021		TypeTableEntry *type_entry, DivKind div_kind)
	2021	ZigType *type_entry, DivKind div_kind)
2022	2022	{
2023	2023	ZigLLVMSetFastMath(g->builder, want_fast_math);
2024	2024
...	...	@@ -2177,7 +2177,7 @@ enum RemKind {
2177	2177
2178	2178	static LLVMValueRef gen_rem(CodeGen *g, bool want_runtime_safety, bool want_fast_math,
2179	2179	LLVMValueRef val1, LLVMValueRef val2,
2180		TypeTableEntry *type_entry, RemKind rem_kind)
	2180	ZigType *type_entry, RemKind rem_kind)
2181	2181	{
2182	2182	ZigLLVMSetFastMath(g->builder, want_fast_math);
2183	2183
...	...	@@ -2246,7 +2246,7 @@ static LLVMValueRef ir_render_bin_op(CodeGen g, IrExecutable executable,
2246	2246	(op_id == IrBinOpAdd \|\| op_id == IrBinOpSub) &&
2247	2247	op1->value.type->data.pointer.ptr_len == PtrLenUnknown)
2248	2248	);
2249		TypeTableEntry *type_entry = op1->value.type;
	2249	ZigType *type_entry = op1->value.type;
2250	2250
2251	2251	bool want_runtime_safety = bin_op_instruction->safety_check_on &&
2252	2252	ir_want_runtime_safety(g, &bin_op_instruction->base);
...	...	@@ -2421,7 +2421,7 @@ static LLVMValueRef ir_render_bin_op(CodeGen g, IrExecutable executable,
2421	2421	zig_unreachable();
2422	2422	}
2423	2423
2424		static void add_error_range_check(CodeGen g, TypeTableEntry err_set_type, TypeTableEntry *int_type, LLVMValueRef target_val) {
	2424	static void add_error_range_check(CodeGen g, ZigType err_set_type, ZigType *int_type, LLVMValueRef target_val) {
2425	2425	assert(err_set_type->id == TypeTableEntryIdErrorSet);
2426	2426
2427	2427	if (type_is_global_error_set(err_set_type)) {
...	...	@@ -2472,8 +2472,8 @@ static void add_error_range_check(CodeGen g, TypeTableEntry err_set_type, Type
2472	2472	static LLVMValueRef ir_render_cast(CodeGen g, IrExecutable executable,
2473	2473	IrInstructionCast *cast_instruction)
2474	2474	{
2475		TypeTableEntry *actual_type = cast_instruction->value->value.type;
2476		TypeTableEntry *wanted_type = cast_instruction->base.value.type;
	2475	ZigType *actual_type = cast_instruction->value->value.type;
	2476	ZigType *wanted_type = cast_instruction->base.value.type;
2477	2477	LLVMValueRef expr_val = ir_llvm_value(g, cast_instruction->value);
2478	2478	assert(expr_val);
2479	2479
...	...	@@ -2491,10 +2491,10 @@ static LLVMValueRef ir_render_cast(CodeGen g, IrExecutable executable,
2491	2491	assert(actual_type->id == TypeTableEntryIdStruct);
2492	2492	assert(actual_type->data.structure.is_slice);
2493	2493
2494		TypeTableEntry *actual_pointer_type = actual_type->data.structure.fields[0].type_entry;
2495		TypeTableEntry *actual_child_type = actual_pointer_type->data.pointer.child_type;
2496		TypeTableEntry *wanted_pointer_type = wanted_type->data.structure.fields[0].type_entry;
2497		TypeTableEntry *wanted_child_type = wanted_pointer_type->data.pointer.child_type;
	2494	ZigType *actual_pointer_type = actual_type->data.structure.fields[0].type_entry;
	2495	ZigType *actual_child_type = actual_pointer_type->data.pointer.child_type;
	2496	ZigType *wanted_pointer_type = wanted_type->data.structure.fields[0].type_entry;
	2497	ZigType *wanted_child_type = wanted_pointer_type->data.pointer.child_type;
2498	2498
2499	2499
2500	2500	size_t actual_ptr_index = actual_type->data.structure.fields[slice_ptr_index].gen_index;
...	...	@@ -2553,8 +2553,8 @@ static LLVMValueRef ir_render_cast(CodeGen g, IrExecutable executable,
2553	2553	assert(wanted_type->data.structure.is_slice);
2554	2554	assert(actual_type->id == TypeTableEntryIdArray);
2555	2555
2556		TypeTableEntry *wanted_pointer_type = wanted_type->data.structure.fields[slice_ptr_index].type_entry;
2557		TypeTableEntry *wanted_child_type = wanted_pointer_type->data.pointer.child_type;
	2556	ZigType *wanted_pointer_type = wanted_type->data.structure.fields[slice_ptr_index].type_entry;
	2557	ZigType *wanted_child_type = wanted_pointer_type->data.pointer.child_type;
2558	2558
2559	2559
2560	2560	size_t wanted_ptr_index = wanted_type->data.structure.fields[0].gen_index;
...	...	@@ -2628,7 +2628,7 @@ static LLVMValueRef ir_render_cast(CodeGen g, IrExecutable executable,
2628	2628	case CastOpPtrOfArrayToSlice: {
2629	2629	assert(cast_instruction->tmp_ptr);
2630	2630	assert(actual_type->id == TypeTableEntryIdPointer);
2631		TypeTableEntry *array_type = actual_type->data.pointer.child_type;
	2631	ZigType *array_type = actual_type->data.pointer.child_type;
2632	2632	assert(array_type->id == TypeTableEntryIdArray);
2633	2633
2634	2634	LLVMValueRef ptr_field_ptr = LLVMBuildStructGEP(g->builder, cast_instruction->tmp_ptr,
...	...	@@ -2655,7 +2655,7 @@ static LLVMValueRef ir_render_cast(CodeGen g, IrExecutable executable,
2655	2655	static LLVMValueRef ir_render_ptr_cast(CodeGen g, IrExecutable executable,
2656	2656	IrInstructionPtrCast *instruction)
2657	2657	{
2658		TypeTableEntry *wanted_type = instruction->base.value.type;
	2658	ZigType *wanted_type = instruction->base.value.type;
2659	2659	if (!type_has_bits(wanted_type)) {
2660	2660	return nullptr;
2661	2661	}
...	...	@@ -2666,7 +2666,7 @@ static LLVMValueRef ir_render_ptr_cast(CodeGen g, IrExecutable executable,
2666	2666	static LLVMValueRef ir_render_bit_cast(CodeGen g, IrExecutable executable,
2667	2667	IrInstructionBitCast *instruction)
2668	2668	{
2669		TypeTableEntry *wanted_type = instruction->base.value.type;
	2669	ZigType *wanted_type = instruction->base.value.type;
2670	2670	LLVMValueRef value = ir_llvm_value(g, instruction->value);
2671	2671	return LLVMBuildBitCast(g->builder, value, wanted_type->type_ref, "");
2672	2672	}
...	...	@@ -2674,10 +2674,10 @@ static LLVMValueRef ir_render_bit_cast(CodeGen g, IrExecutable executable,
2674	2674	static LLVMValueRef ir_render_widen_or_shorten(CodeGen g, IrExecutable executable,
2675	2675	IrInstructionWidenOrShorten *instruction)
2676	2676	{
2677		TypeTableEntry *actual_type = instruction->target->value.type;
	2677	ZigType *actual_type = instruction->target->value.type;
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		TypeTableEntry *int_type;
	2680	ZigType *int_type;
2681	2681	if (actual_type->id == TypeTableEntryIdEnum) {
2682	2682	int_type = actual_type->data.enumeration.tag_int_type;
2683	2683	} else {
...	...	@@ -2689,21 +2689,21 @@ static LLVMValueRef ir_render_widen_or_shorten(CodeGen g, IrExecutable executa
2689	2689	}
2690	2690
2691	2691	static LLVMValueRef ir_render_int_to_ptr(CodeGen g, IrExecutable executable, IrInstructionIntToPtr *instruction) {
2692		TypeTableEntry *wanted_type = instruction->base.value.type;
	2692	ZigType *wanted_type = instruction->base.value.type;
2693	2693	LLVMValueRef target_val = ir_llvm_value(g, instruction->target);
2694	2694	return LLVMBuildIntToPtr(g->builder, target_val, wanted_type->type_ref, "");
2695	2695	}
2696	2696
2697	2697	static LLVMValueRef ir_render_ptr_to_int(CodeGen g, IrExecutable executable, IrInstructionPtrToInt *instruction) {
2698		TypeTableEntry *wanted_type = instruction->base.value.type;
	2698	ZigType *wanted_type = instruction->base.value.type;
2699	2699	LLVMValueRef target_val = ir_llvm_value(g, instruction->target);
2700	2700	return LLVMBuildPtrToInt(g->builder, target_val, wanted_type->type_ref, "");
2701	2701	}
2702	2702
2703	2703	static LLVMValueRef ir_render_int_to_enum(CodeGen g, IrExecutable executable, IrInstructionIntToEnum *instruction) {
2704		TypeTableEntry *wanted_type = instruction->base.value.type;
	2704	ZigType *wanted_type = instruction->base.value.type;
2705	2705	assert(wanted_type->id == TypeTableEntryIdEnum);
2706		TypeTableEntry *tag_int_type = wanted_type->data.enumeration.tag_int_type;
	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);
2709	2709	LLVMValueRef tag_int_value = gen_widen_or_shorten(g, ir_want_runtime_safety(g, &instruction->base),
...	...	@@ -2728,10 +2728,10 @@ static LLVMValueRef ir_render_int_to_enum(CodeGen g, IrExecutable executable,
2728	2728	}
2729	2729
2730	2730	static LLVMValueRef ir_render_int_to_err(CodeGen g, IrExecutable executable, IrInstructionIntToErr *instruction) {
2731		TypeTableEntry *wanted_type = instruction->base.value.type;
	2731	ZigType *wanted_type = instruction->base.value.type;
2732	2732	assert(wanted_type->id == TypeTableEntryIdErrorSet);
2733	2733
2734		TypeTableEntry *actual_type = instruction->target->value.type;
	2734	ZigType *actual_type = instruction->target->value.type;
2735	2735	assert(actual_type->id == TypeTableEntryIdInt);
2736	2736	assert(!actual_type->data.integral.is_signed);
2737	2737
...	...	@@ -2745,11 +2745,11 @@ static LLVMValueRef ir_render_int_to_err(CodeGen g, IrExecutable executable, I
2745	2745	}
2746	2746
2747	2747	static LLVMValueRef ir_render_err_to_int(CodeGen g, IrExecutable executable, IrInstructionErrToInt *instruction) {
2748		TypeTableEntry *wanted_type = instruction->base.value.type;
	2748	ZigType *wanted_type = instruction->base.value.type;
2749	2749	assert(wanted_type->id == TypeTableEntryIdInt);
2750	2750	assert(!wanted_type->data.integral.is_signed);
2751	2751
2752		TypeTableEntry *actual_type = instruction->target->value.type;
	2752	ZigType *actual_type = instruction->target->value.type;
2753	2753	LLVMValueRef target_val = ir_llvm_value(g, instruction->target);
2754	2754
2755	2755	if (actual_type->id == TypeTableEntryIdErrorSet) {
...	...	@@ -2799,7 +2799,7 @@ static LLVMValueRef ir_render_br(CodeGen g, IrExecutable executable, IrInstruc
2799	2799	static LLVMValueRef ir_render_un_op(CodeGen g, IrExecutable executable, IrInstructionUnOp *un_op_instruction) {
2800	2800	IrUnOp op_id = un_op_instruction->op_id;
2801	2801	LLVMValueRef expr = ir_llvm_value(g, un_op_instruction->value);
2802		TypeTableEntry *expr_type = un_op_instruction->value->value.type;
	2802	ZigType *expr_type = un_op_instruction->value->value.type;
2803	2803
2804	2804	switch (op_id) {
2805	2805	case IrUnOpInvalid:
...	...	@@ -2880,13 +2880,13 @@ static LLVMValueRef ir_render_decl_var(CodeGen g, IrExecutable executable,
2880	2880
2881	2881	if (have_init_expr) {
2882	2882	assert(var->value->type == init_value->value.type);
2883		TypeTableEntry *var_ptr_type = get_pointer_to_type_extra(g, var->value->type, false, false,
	2883	ZigType *var_ptr_type = get_pointer_to_type_extra(g, var->value->type, false, false,
2884	2884	PtrLenSingle, var->align_bytes, 0, 0);
2885	2885	gen_assign_raw(g, var->value_ref, var_ptr_type, ir_llvm_value(g, init_value));
2886	2886	} else {
2887	2887	bool want_safe = ir_want_runtime_safety(g, &decl_var_instruction->base);
2888	2888	if (want_safe) {
2889		TypeTableEntry *usize = g->builtin_types.entry_usize;
	2889	ZigType *usize = g->builtin_types.entry_usize;
2890	2890	uint64_t size_bytes = LLVMStoreSizeOfType(g->target_data_ref, var->value->type->type_ref);
2891	2891	assert(size_bytes > 0);
2892	2892
...	...	@@ -2915,12 +2915,12 @@ static LLVMValueRef ir_render_decl_var(CodeGen g, IrExecutable executable,
2915	2915	}
2916	2916
2917	2917	static LLVMValueRef ir_render_load_ptr(CodeGen g, IrExecutable executable, IrInstructionLoadPtr *instruction) {
2918		TypeTableEntry *child_type = instruction->base.value.type;
	2918	ZigType *child_type = instruction->base.value.type;
2919	2919	if (!type_has_bits(child_type))
2920	2920	return nullptr;
2921	2921
2922	2922	LLVMValueRef ptr = ir_llvm_value(g, instruction->ptr);
2923		TypeTableEntry *ptr_type = instruction->ptr->value.type;
	2923	ZigType *ptr_type = instruction->ptr->value.type;
2924	2924	assert(ptr_type->id == TypeTableEntryIdPointer);
2925	2925
2926	2926	uint32_t unaligned_bit_count = ptr_type->data.pointer.unaligned_bit_count;
...	...	@@ -2947,7 +2947,7 @@ static LLVMValueRef ir_render_store_ptr(CodeGen g, IrExecutable executable, Ir
2947	2947	LLVMValueRef value = ir_llvm_value(g, instruction->value);
2948	2948
2949	2949	assert(instruction->ptr->value.type->id == TypeTableEntryIdPointer);
2950		TypeTableEntry *ptr_type = instruction->ptr->value.type;
	2950	ZigType *ptr_type = instruction->ptr->value.type;
2951	2951
2952	2952	gen_assign_raw(g, ptr, ptr_type, value);
2953	2953
...	...	@@ -2966,9 +2966,9 @@ static LLVMValueRef ir_render_var_ptr(CodeGen g, IrExecutable executable, IrIn
2966	2966
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		TypeTableEntry *array_ptr_type = instruction->array_ptr->value.type;
	2969	ZigType *array_ptr_type = instruction->array_ptr->value.type;
2970	2970	assert(array_ptr_type->id == TypeTableEntryIdPointer);
2971		TypeTableEntry *array_type = array_ptr_type->data.pointer.child_type;
	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);
2974	2974	assert(subscript_value);
...	...	@@ -2993,7 +2993,7 @@ static LLVMValueRef ir_render_elem_ptr(CodeGen g, IrExecutable executable, IrI
2993	2993	if (array_ptr_type->data.pointer.unaligned_bit_count != 0) {
2994	2994	return array_ptr_ptr;
2995	2995	}
2996		TypeTableEntry *child_type = array_type->data.array.child_type;
	2996	ZigType *child_type = array_type->data.array.child_type;
2997	2997	if (child_type->id == TypeTableEntryIdStruct &&
2998	2998	child_type->data.structure.layout == ContainerLayoutPacked)
2999	2999	{
...	...	@@ -3113,7 +3113,7 @@ static void set_call_instr_sret(CodeGen *g, LLVMValueRef call_instr) {
3113	3113
3114	3114	static LLVMValueRef ir_render_call(CodeGen g, IrExecutable executable, IrInstructionCall *instruction) {
3115	3115	LLVMValueRef fn_val;
3116		TypeTableEntry *fn_type;
	3116	ZigType *fn_type;
3117	3117	if (instruction->fn_entry) {
3118	3118	fn_val = fn_llvm_value(g, instruction->fn_entry);
3119	3119	fn_type = instruction->fn_entry->type_entry;
...	...	@@ -3125,7 +3125,7 @@ static LLVMValueRef ir_render_call(CodeGen g, IrExecutable executable, IrInstr
3125	3125
3126	3126	FnTypeId *fn_type_id = &fn_type->data.fn.fn_type_id;
3127	3127
3128		TypeTableEntry *src_return_type = fn_type_id->return_type;
	3128	ZigType *src_return_type = fn_type_id->return_type;
3129	3129	bool ret_has_bits = type_has_bits(src_return_type);
3130	3130
3131	3131	bool first_arg_ret = ret_has_bits && handle_is_ptr(src_return_type) &&
...	...	@@ -3154,7 +3154,7 @@ static LLVMValueRef ir_render_call(CodeGen g, IrExecutable executable, IrInstr
3154	3154	}
3155	3155	for (size_t call_i = 0; call_i < instruction->arg_count; call_i += 1) {
3156	3156	IrInstruction *param_instruction = instruction->args[call_i];
3157		TypeTableEntry *param_type = param_instruction->value.type;
	3157	ZigType *param_type = param_instruction->value.type;
3158	3158	if (is_var_args \|\| type_has_bits(param_type)) {
3159	3159	LLVMValueRef param_value = ir_llvm_value(g, param_instruction);
3160	3160	assert(param_value);
...	...	@@ -3222,7 +3222,7 @@ static LLVMValueRef ir_render_struct_field_ptr(CodeGen g, IrExecutable executa
3222	3222	{
3223	3223	LLVMValueRef struct_ptr = ir_llvm_value(g, instruction->struct_ptr);
3224	3224	// not necessarily a pointer. could be TypeTableEntryIdStruct
3225		TypeTableEntry *struct_ptr_type = instruction->struct_ptr->value.type;
	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))
...	...	@@ -3241,9 +3241,9 @@ static LLVMValueRef ir_render_struct_field_ptr(CodeGen g, IrExecutable executa
3241	3241	static LLVMValueRef ir_render_union_field_ptr(CodeGen g, IrExecutable executable,
3242	3242	IrInstructionUnionFieldPtr *instruction)
3243	3243	{
3244		TypeTableEntry *union_ptr_type = instruction->union_ptr->value.type;
	3244	ZigType *union_ptr_type = instruction->union_ptr->value.type;
3245	3245	assert(union_ptr_type->id == TypeTableEntryIdPointer);
3246		TypeTableEntry *union_type = union_ptr_type->data.pointer.child_type;
	3246	ZigType *union_type = union_ptr_type->data.pointer.child_type;
3247	3247	assert(union_type->id == TypeTableEntryIdUnion);
3248	3248
3249	3249	TypeUnionField *field = instruction->field;
...	...	@@ -3411,9 +3411,9 @@ static LLVMValueRef ir_render_asm(CodeGen g, IrExecutable executable, IrInstru
3411	3411	return LLVMBuildCall(g->builder, asm_fn, param_values, (unsigned)input_and_output_count, "");
3412	3412	}
3413	3413
3414		static LLVMValueRef gen_non_null_bit(CodeGen g, TypeTableEntry maybe_type, LLVMValueRef maybe_handle) {
	3414	static LLVMValueRef gen_non_null_bit(CodeGen g, ZigType maybe_type, LLVMValueRef maybe_handle) {
3415	3415	assert(maybe_type->id == TypeTableEntryIdOptional);
3416		TypeTableEntry *child_type = maybe_type->data.maybe.child_type;
	3416	ZigType *child_type = maybe_type->data.maybe.child_type;
3417	3417	if (child_type->zero_bits) {
3418	3418	return maybe_handle;
3419	3419	} else {
...	...	@@ -3436,11 +3436,11 @@ static LLVMValueRef ir_render_test_non_null(CodeGen g, IrExecutable executable
3436	3436	static LLVMValueRef ir_render_unwrap_maybe(CodeGen g, IrExecutable executable,
3437	3437	IrInstructionUnwrapOptional *instruction)
3438	3438	{
3439		TypeTableEntry *ptr_type = instruction->value->value.type;
	3439	ZigType *ptr_type = instruction->value->value.type;
3440	3440	assert(ptr_type->id == TypeTableEntryIdPointer);
3441		TypeTableEntry *maybe_type = ptr_type->data.pointer.child_type;
	3441	ZigType *maybe_type = ptr_type->data.pointer.child_type;
3442	3442	assert(maybe_type->id == TypeTableEntryIdOptional);
3443		TypeTableEntry *child_type = maybe_type->data.maybe.child_type;
	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);
3446	3446	if (ir_want_runtime_safety(g, &instruction->base) && instruction->safety_check_on) {
...	...	@@ -3467,7 +3467,7 @@ static LLVMValueRef ir_render_unwrap_maybe(CodeGen g, IrExecutable executable,
3467	3467	}
3468	3468	}
3469	3469
3470		static LLVMValueRef get_int_builtin_fn(CodeGen g, TypeTableEntry int_type, BuiltinFnId fn_id) {
	3470	static LLVMValueRef get_int_builtin_fn(CodeGen g, ZigType int_type, BuiltinFnId fn_id) {
3471	3471	ZigLLVMFnKey key = {};
3472	3472	const char *fn_name;
3473	3473	uint32_t n_args;
...	...	@@ -3510,7 +3510,7 @@ static LLVMValueRef get_int_builtin_fn(CodeGen g, TypeTableEntry int_type, Bui
3510	3510	}
3511	3511
3512	3512	static LLVMValueRef ir_render_clz(CodeGen g, IrExecutable executable, IrInstructionClz *instruction) {
3513		TypeTableEntry *int_type = instruction->value->value.type;
	3513	ZigType *int_type = instruction->value->value.type;
3514	3514	LLVMValueRef fn_val = get_int_builtin_fn(g, int_type, BuiltinFnIdClz);
3515	3515	LLVMValueRef operand = ir_llvm_value(g, instruction->value);
3516	3516	LLVMValueRef params[] {
...	...	@@ -3522,7 +3522,7 @@ static LLVMValueRef ir_render_clz(CodeGen g, IrExecutable executable, IrInstru
3522	3522	}
3523	3523
3524	3524	static LLVMValueRef ir_render_ctz(CodeGen g, IrExecutable executable, IrInstructionCtz *instruction) {
3525		TypeTableEntry *int_type = instruction->value->value.type;
	3525	ZigType *int_type = instruction->value->value.type;
3526	3526	LLVMValueRef fn_val = get_int_builtin_fn(g, int_type, BuiltinFnIdCtz);
3527	3527	LLVMValueRef operand = ir_llvm_value(g, instruction->value);
3528	3528	LLVMValueRef params[] {
...	...	@@ -3534,7 +3534,7 @@ static LLVMValueRef ir_render_ctz(CodeGen g, IrExecutable executable, IrInstru
3534	3534	}
3535	3535
3536	3536	static LLVMValueRef ir_render_pop_count(CodeGen g, IrExecutable executable, IrInstructionPopCount *instruction) {
3537		TypeTableEntry *int_type = instruction->value->value.type;
	3537	ZigType *int_type = instruction->value->value.type;
3538	3538	LLVMValueRef fn_val = get_int_builtin_fn(g, int_type, BuiltinFnIdPopCount);
3539	3539	LLVMValueRef operand = ir_llvm_value(g, instruction->value);
3540	3540	LLVMValueRef wrong_size_int = LLVMBuildCall(g->builder, fn_val, &operand, 1, "");
...	...	@@ -3611,15 +3611,15 @@ static LLVMValueRef ir_render_err_name(CodeGen g, IrExecutable executable, IrI
3611	3611	return LLVMBuildInBoundsGEP(g->builder, g->err_name_table, indices, 2, "");
3612	3612	}
3613	3613
3614		static LLVMValueRef get_enum_tag_name_function(CodeGen g, TypeTableEntry enum_type) {
	3614	static LLVMValueRef get_enum_tag_name_function(CodeGen g, ZigType enum_type) {
3615	3615	assert(enum_type->id == TypeTableEntryIdEnum);
3616	3616	if (enum_type->data.enumeration.name_function)
3617	3617	return enum_type->data.enumeration.name_function;
3618	3618
3619		TypeTableEntry *u8_ptr_type = get_pointer_to_type_extra(g, g->builtin_types.entry_u8, false, false,
	3619	ZigType *u8_ptr_type = get_pointer_to_type_extra(g, g->builtin_types.entry_u8, false, false,
3620	3620	PtrLenUnknown, get_abi_alignment(g, g->builtin_types.entry_u8), 0, 0);
3621		TypeTableEntry *u8_slice_type = get_slice_type(g, u8_ptr_type);
3622		TypeTableEntry *tag_int_type = enum_type->data.enumeration.tag_int_type;
	3621	ZigType *u8_slice_type = get_slice_type(g, u8_ptr_type);
	3622	ZigType *tag_int_type = enum_type->data.enumeration.tag_int_type;
3623	3623
3624	3624	LLVMTypeRef fn_type_ref = LLVMFunctionType(LLVMPointerType(u8_slice_type->type_ref, 0),
3625	3625	&tag_int_type->type_ref, 1, false);
...	...	@@ -3652,7 +3652,7 @@ static LLVMValueRef get_enum_tag_name_function(CodeGen g, TypeTableEntry enum_
3652	3652	LLVMValueRef switch_instr = LLVMBuildSwitch(g->builder, tag_int_value, bad_value_block, field_count);
3653	3653
3654	3654
3655		TypeTableEntry *usize = g->builtin_types.entry_usize;
	3655	ZigType *usize = g->builtin_types.entry_usize;
3656	3656	LLVMValueRef array_ptr_indices[] = {
3657	3657	LLVMConstNull(usize->type_ref),
3658	3658	LLVMConstNull(usize->type_ref),
...	...	@@ -3709,7 +3709,7 @@ static LLVMValueRef get_enum_tag_name_function(CodeGen g, TypeTableEntry enum_
3709	3709	static LLVMValueRef ir_render_enum_tag_name(CodeGen g, IrExecutable executable,
3710	3710	IrInstructionTagName *instruction)
3711	3711	{
3712		TypeTableEntry *enum_type = instruction->target->value.type;
	3712	ZigType *enum_type = instruction->target->value.type;
3713	3713	assert(enum_type->id == TypeTableEntryIdEnum);
3714	3714
3715	3715	LLVMValueRef enum_name_function = get_enum_tag_name_function(g, enum_type);
...	...	@@ -3722,10 +3722,10 @@ static LLVMValueRef ir_render_enum_tag_name(CodeGen g, IrExecutable executable
3722	3722	static LLVMValueRef ir_render_field_parent_ptr(CodeGen g, IrExecutable executable,
3723	3723	IrInstructionFieldParentPtr *instruction)
3724	3724	{
3725		TypeTableEntry *container_ptr_type = instruction->base.value.type;
	3725	ZigType *container_ptr_type = instruction->base.value.type;
3726	3726	assert(container_ptr_type->id == TypeTableEntryIdPointer);
3727	3727
3728		TypeTableEntry *container_type = container_ptr_type->data.pointer.child_type;
	3728	ZigType *container_type = container_ptr_type->data.pointer.child_type;
3729	3729
3730	3730	size_t byte_offset = LLVMOffsetOfElement(g->target_data_ref,
3731	3731	container_type->type_ref, instruction->field->gen_index);
...	...	@@ -3735,7 +3735,7 @@ static LLVMValueRef ir_render_field_parent_ptr(CodeGen g, IrExecutable executa
3735	3735	if (byte_offset == 0) {
3736	3736	return LLVMBuildBitCast(g->builder, field_ptr_val, container_ptr_type->type_ref, "");
3737	3737	} else {
3738		TypeTableEntry *usize = g->builtin_types.entry_usize;
	3738	ZigType *usize = g->builtin_types.entry_usize;
3739	3739
3740	3740	LLVMValueRef field_ptr_int = LLVMBuildPtrToInt(g->builder, field_ptr_val,
3741	3741	usize->type_ref, "");
...	...	@@ -3756,7 +3756,7 @@ static LLVMValueRef ir_render_align_cast(CodeGen g, IrExecutable executable, I
3756	3756	return target_val;
3757	3757	}
3758	3758
3759		TypeTableEntry *target_type = instruction->base.value.type;
	3759	ZigType *target_type = instruction->base.value.type;
3760	3760	uint32_t align_bytes;
3761	3761	LLVMValueRef ptr_val;
3762	3762
...	...	@@ -3781,7 +3781,7 @@ static LLVMValueRef ir_render_align_cast(CodeGen g, IrExecutable executable, I
3781	3781	{
3782	3782	zig_panic("TODO audit this function");
3783	3783	} else if (target_type->id == TypeTableEntryIdStruct && target_type->data.structure.is_slice) {
3784		TypeTableEntry *slice_ptr_type = target_type->data.structure.fields[slice_ptr_index].type_entry;
	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
3787	3787	size_t ptr_index = target_type->data.structure.fields[slice_ptr_index].gen_index;
...	...	@@ -3793,7 +3793,7 @@ static LLVMValueRef ir_render_align_cast(CodeGen g, IrExecutable executable, I
3793	3793
3794	3794	assert(align_bytes != 1);
3795	3795
3796		TypeTableEntry *usize = g->builtin_types.entry_usize;
	3796	ZigType *usize = g->builtin_types.entry_usize;
3797	3797	LLVMValueRef ptr_as_int_val = LLVMBuildPtrToInt(g->builder, ptr_val, usize->type_ref, "");
3798	3798	LLVMValueRef alignment_minus_1 = LLVMConstInt(usize->type_ref, align_bytes - 1, false);
3799	3799	LLVMValueRef anded_val = LLVMBuildAnd(g->builder, ptr_as_int_val, alignment_minus_1, "");
...	...	@@ -3817,7 +3817,7 @@ static LLVMValueRef ir_render_error_return_trace(CodeGen g, IrExecutable execu
3817	3817	{
3818	3818	LLVMValueRef cur_err_ret_trace_val = get_cur_err_ret_trace_val(g, instruction->base.scope);
3819	3819	if (cur_err_ret_trace_val == nullptr) {
3820		TypeTableEntry *ptr_to_stack_trace_type = get_ptr_to_stack_trace_type(g);
	3820	ZigType *ptr_to_stack_trace_type = get_ptr_to_stack_trace_type(g);
3821	3821	return LLVMConstNull(ptr_to_stack_trace_type->type_ref);
3822	3822	}
3823	3823	return cur_err_ret_trace_val;
...	...	@@ -3877,9 +3877,9 @@ static LLVMValueRef ir_render_cmpxchg(CodeGen g, IrExecutable executable, IrIn
3877	3877	LLVMValueRef result_val = ZigLLVMBuildCmpXchg(g->builder, ptr_val, cmp_val, new_val,
3878	3878	success_order, failure_order, instruction->is_weak);
3879	3879
3880		TypeTableEntry *maybe_type = instruction->base.value.type;
	3880	ZigType *maybe_type = instruction->base.value.type;
3881	3881	assert(maybe_type->id == TypeTableEntryIdOptional);
3882		TypeTableEntry *child_type = maybe_type->data.maybe.child_type;
	3882	ZigType *child_type = maybe_type->data.maybe.child_type;
3883	3883
3884	3884	if (type_is_codegen_pointer(child_type)) {
3885	3885	LLVMValueRef payload_val = LLVMBuildExtractValue(g->builder, result_val, 0, "");
...	...	@@ -3909,8 +3909,8 @@ static LLVMValueRef ir_render_fence(CodeGen g, IrExecutable executable, IrInst
3909	3909
3910	3910	static LLVMValueRef ir_render_truncate(CodeGen g, IrExecutable executable, IrInstructionTruncate *instruction) {
3911	3911	LLVMValueRef target_val = ir_llvm_value(g, instruction->target);
3912		TypeTableEntry *dest_type = instruction->base.value.type;
3913		TypeTableEntry *src_type = instruction->target->value.type;
	3912	ZigType *dest_type = instruction->base.value.type;
	3913	ZigType *src_type = instruction->target->value.type;
3914	3914	if (dest_type == src_type) {
3915	3915	// no-op
3916	3916	return target_val;
...	...	@@ -3931,7 +3931,7 @@ static LLVMValueRef ir_render_memset(CodeGen g, IrExecutable executable, IrIns
3931	3931
3932	3932	LLVMValueRef dest_ptr_casted = LLVMBuildBitCast(g->builder, dest_ptr, ptr_u8, "");
3933	3933
3934		TypeTableEntry *ptr_type = instruction->dest_ptr->value.type;
	3934	ZigType *ptr_type = instruction->dest_ptr->value.type;
3935	3935	assert(ptr_type->id == TypeTableEntryIdPointer);
3936	3936
3937	3937	LLVMValueRef is_volatile = ptr_type->data.pointer.is_volatile ?
...	...	@@ -3961,8 +3961,8 @@ static LLVMValueRef ir_render_memcpy(CodeGen g, IrExecutable executable, IrIns
3961	3961	LLVMValueRef dest_ptr_casted = LLVMBuildBitCast(g->builder, dest_ptr, ptr_u8, "");
3962	3962	LLVMValueRef src_ptr_casted = LLVMBuildBitCast(g->builder, src_ptr, ptr_u8, "");
3963	3963
3964		TypeTableEntry *dest_ptr_type = instruction->dest_ptr->value.type;
3965		TypeTableEntry *src_ptr_type = instruction->src_ptr->value.type;
	3964	ZigType *dest_ptr_type = instruction->dest_ptr->value.type;
	3965	ZigType *src_ptr_type = instruction->src_ptr->value.type;
3966	3966
3967	3967	assert(dest_ptr_type->id == TypeTableEntryIdPointer);
3968	3968	assert(src_ptr_type->id == TypeTableEntryIdPointer);
...	...	@@ -3989,9 +3989,9 @@ static LLVMValueRef ir_render_slice(CodeGen g, IrExecutable executable, IrInst
3989	3989	assert(instruction->tmp_ptr);
3990	3990
3991	3991	LLVMValueRef array_ptr_ptr = ir_llvm_value(g, instruction->ptr);
3992		TypeTableEntry *array_ptr_type = instruction->ptr->value.type;
	3992	ZigType *array_ptr_type = instruction->ptr->value.type;
3993	3993	assert(array_ptr_type->id == TypeTableEntryIdPointer);
3994		TypeTableEntry *array_type = array_ptr_type->data.pointer.child_type;
	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
3997	3997	LLVMValueRef tmp_struct_ptr = instruction->tmp_ptr;
...	...	@@ -4140,7 +4140,7 @@ static LLVMValueRef get_frame_address_fn_val(CodeGen *g) {
4140	4140	if (g->frame_address_fn_val)
4141	4141	return g->frame_address_fn_val;
4142	4142
4143		TypeTableEntry *return_type = get_pointer_to_type(g, g->builtin_types.entry_u8, true);
	4143	ZigType *return_type = get_pointer_to_type(g, g->builtin_types.entry_u8, true);
4144	4144
4145	4145	LLVMTypeRef fn_type = LLVMFunctionType(return_type->type_ref,
4146	4146	&g->builtin_types.entry_i32->type_ref, 1, false);
...	...	@@ -4178,7 +4178,7 @@ static LLVMValueRef ir_render_handle(CodeGen g, IrExecutable executable,
4178	4178	}
4179	4179
4180	4180	static LLVMValueRef render_shl_with_overflow(CodeGen g, IrInstructionOverflowOp instruction) {
4181		TypeTableEntry *int_type = instruction->result_ptr_type;
	4181	ZigType *int_type = instruction->result_ptr_type;
4182	4182	assert(int_type->id == TypeTableEntryIdInt);
4183	4183
4184	4184	LLVMValueRef op1 = ir_llvm_value(g, instruction->op1);
...	...	@@ -4218,7 +4218,7 @@ static LLVMValueRef ir_render_overflow_op(CodeGen g, IrExecutable executable,
4218	4218	return render_shl_with_overflow(g, instruction);
4219	4219	}
4220	4220
4221		TypeTableEntry *int_type = instruction->result_ptr_type;
	4221	ZigType *int_type = instruction->result_ptr_type;
4222	4222	assert(int_type->id == TypeTableEntryIdInt);
4223	4223
4224	4224	LLVMValueRef fn_val = get_int_overflow_fn(g, int_type, add_sub_mul);
...	...	@@ -4241,8 +4241,8 @@ static LLVMValueRef ir_render_overflow_op(CodeGen g, IrExecutable executable,
4241	4241	}
4242	4242
4243	4243	static LLVMValueRef ir_render_test_err(CodeGen g, IrExecutable executable, IrInstructionTestErr *instruction) {
4244		TypeTableEntry *err_union_type = instruction->value->value.type;
4245		TypeTableEntry *payload_type = err_union_type->data.error_union.payload_type;
	4244	ZigType *err_union_type = instruction->value->value.type;
	4245	ZigType *payload_type = err_union_type->data.error_union.payload_type;
4246	4246	LLVMValueRef err_union_handle = ir_llvm_value(g, instruction->value);
4247	4247
4248	4248	LLVMValueRef err_val;
...	...	@@ -4258,10 +4258,10 @@ static LLVMValueRef ir_render_test_err(CodeGen g, IrExecutable executable, IrI
4258	4258	}
4259	4259
4260	4260	static LLVMValueRef ir_render_unwrap_err_code(CodeGen g, IrExecutable executable, IrInstructionUnwrapErrCode *instruction) {
4261		TypeTableEntry *ptr_type = instruction->value->value.type;
	4261	ZigType *ptr_type = instruction->value->value.type;
4262	4262	assert(ptr_type->id == TypeTableEntryIdPointer);
4263		TypeTableEntry *err_union_type = ptr_type->data.pointer.child_type;
4264		TypeTableEntry *payload_type = err_union_type->data.error_union.payload_type;
	4263	ZigType *err_union_type = ptr_type->data.pointer.child_type;
	4264	ZigType *payload_type = err_union_type->data.error_union.payload_type;
4265	4265	LLVMValueRef err_union_ptr = ir_llvm_value(g, instruction->value);
4266	4266	LLVMValueRef err_union_handle = get_handle_value(g, err_union_ptr, err_union_type, ptr_type);
4267	4267
...	...	@@ -4274,10 +4274,10 @@ static LLVMValueRef ir_render_unwrap_err_code(CodeGen g, IrExecutable executab
4274	4274	}
4275	4275
4276	4276	static LLVMValueRef ir_render_unwrap_err_payload(CodeGen g, IrExecutable executable, IrInstructionUnwrapErrPayload *instruction) {
4277		TypeTableEntry *ptr_type = instruction->value->value.type;
	4277	ZigType *ptr_type = instruction->value->value.type;
4278	4278	assert(ptr_type->id == TypeTableEntryIdPointer);
4279		TypeTableEntry *err_union_type = ptr_type->data.pointer.child_type;
4280		TypeTableEntry *payload_type = err_union_type->data.error_union.payload_type;
	4279	ZigType *err_union_type = ptr_type->data.pointer.child_type;
	4280	ZigType *payload_type = err_union_type->data.error_union.payload_type;
4281	4281	LLVMValueRef err_union_ptr = ir_llvm_value(g, instruction->value);
4282	4282	LLVMValueRef err_union_handle = get_handle_value(g, err_union_ptr, err_union_type, ptr_type);
4283	4283
...	...	@@ -4313,11 +4313,11 @@ static LLVMValueRef ir_render_unwrap_err_payload(CodeGen g, IrExecutable execu
4313	4313	}
4314	4314
4315	4315	static LLVMValueRef ir_render_maybe_wrap(CodeGen g, IrExecutable executable, IrInstructionOptionalWrap *instruction) {
4316		TypeTableEntry *wanted_type = instruction->base.value.type;
	4316	ZigType *wanted_type = instruction->base.value.type;
4317	4317
4318	4318	assert(wanted_type->id == TypeTableEntryIdOptional);
4319	4319
4320		TypeTableEntry *child_type = wanted_type->data.maybe.child_type;
	4320	ZigType *child_type = wanted_type->data.maybe.child_type;
4321	4321
4322	4322	if (child_type->zero_bits) {
4323	4323	return LLVMConstInt(LLVMInt1Type(), 1, false);
...	...	@@ -4340,12 +4340,12 @@ static LLVMValueRef ir_render_maybe_wrap(CodeGen g, IrExecutable executable, I
4340	4340	}
4341	4341
4342	4342	static LLVMValueRef ir_render_err_wrap_code(CodeGen g, IrExecutable executable, IrInstructionErrWrapCode *instruction) {
4343		TypeTableEntry *wanted_type = instruction->base.value.type;
	4343	ZigType *wanted_type = instruction->base.value.type;
4344	4344
4345	4345	assert(wanted_type->id == TypeTableEntryIdErrorUnion);
4346	4346
4347		TypeTableEntry *payload_type = wanted_type->data.error_union.payload_type;
4348		TypeTableEntry *err_set_type = wanted_type->data.error_union.err_set_type;
	4347	ZigType *payload_type = wanted_type->data.error_union.payload_type;
	4348	ZigType *err_set_type = wanted_type->data.error_union.err_set_type;
4349	4349
4350	4350	LLVMValueRef err_val = ir_llvm_value(g, instruction->value);
4351	4351
...	...	@@ -4361,12 +4361,12 @@ static LLVMValueRef ir_render_err_wrap_code(CodeGen g, IrExecutable executable
4361	4361	}
4362	4362
4363	4363	static LLVMValueRef ir_render_err_wrap_payload(CodeGen g, IrExecutable executable, IrInstructionErrWrapPayload *instruction) {
4364		TypeTableEntry *wanted_type = instruction->base.value.type;
	4364	ZigType *wanted_type = instruction->base.value.type;
4365	4365
4366	4366	assert(wanted_type->id == TypeTableEntryIdErrorUnion);
4367	4367
4368		TypeTableEntry *payload_type = wanted_type->data.error_union.payload_type;
4369		TypeTableEntry *err_set_type = wanted_type->data.error_union.err_set_type;
	4368	ZigType *payload_type = wanted_type->data.error_union.payload_type;
	4369	ZigType *err_set_type = wanted_type->data.error_union.err_set_type;
4370	4370
4371	4371	if (!type_has_bits(err_set_type)) {
4372	4372	return ir_llvm_value(g, instruction->value);
...	...	@@ -4391,10 +4391,10 @@ static LLVMValueRef ir_render_err_wrap_payload(CodeGen g, IrExecutable executa
4391	4391	}
4392	4392
4393	4393	static LLVMValueRef ir_render_union_tag(CodeGen g, IrExecutable executable, IrInstructionUnionTag *instruction) {
4394		TypeTableEntry *union_type = instruction->value->value.type;
	4394	ZigType *union_type = instruction->value->value.type;
4395	4395	assert(union_type->data.unionation.gen_tag_index != SIZE_MAX);
4396	4396
4397		TypeTableEntry *tag_type = union_type->data.unionation.tag_type;
	4397	ZigType *tag_type = union_type->data.unionation.tag_type;
4398	4398	if (!type_has_bits(tag_type))
4399	4399	return nullptr;
4400	4400
...	...	@@ -4404,7 +4404,7 @@ static LLVMValueRef ir_render_union_tag(CodeGen g, IrExecutable executable, Ir
4404	4404
4405	4405	LLVMValueRef tag_field_ptr = LLVMBuildStructGEP(g->builder, union_val,
4406	4406	union_type->data.unionation.gen_tag_index, "");
4407		TypeTableEntry *ptr_type = get_pointer_to_type(g, tag_type, false);
	4407	ZigType *ptr_type = get_pointer_to_type(g, tag_type, false);
4408	4408	return get_handle_value(g, tag_field_ptr, tag_type, ptr_type);
4409	4409	}
4410	4410
...	...	@@ -4421,7 +4421,7 @@ static LLVMValueRef ir_render_struct_init(CodeGen g, IrExecutable executable,
4421	4421
4422	4422	uint32_t field_align_bytes = get_abi_alignment(g, type_struct_field->type_entry);
4423	4423
4424		TypeTableEntry *ptr_type = get_pointer_to_type_extra(g, type_struct_field->type_entry,
	4424	ZigType *ptr_type = get_pointer_to_type_extra(g, type_struct_field->type_entry,
4425	4425	false, false, PtrLenSingle, field_align_bytes,
4426	4426	(uint32_t)type_struct_field->packed_bits_offset, (uint32_t)type_struct_field->unaligned_bit_count);
4427	4427
...	...	@@ -4437,14 +4437,14 @@ static LLVMValueRef ir_render_union_init(CodeGen g, IrExecutable executable, I
4437	4437	return nullptr;
4438	4438
4439	4439	uint32_t field_align_bytes = get_abi_alignment(g, type_union_field->type_entry);
4440		TypeTableEntry *ptr_type = get_pointer_to_type_extra(g, type_union_field->type_entry,
	4440	ZigType *ptr_type = get_pointer_to_type_extra(g, type_union_field->type_entry,
4441	4441	false, false, PtrLenSingle, field_align_bytes,
4442	4442	0, 0);
4443	4443
4444	4444	LLVMValueRef uncasted_union_ptr;
4445	4445	// Even if safety is off in this block, if the union type has the safety field, we have to populate it
4446	4446	// correctly. Otherwise safety code somewhere other than here could fail.
4447		TypeTableEntry *union_type = instruction->union_type;
	4447	ZigType *union_type = instruction->union_type;
4448	4448	if (union_type->data.unionation.gen_tag_index != SIZE_MAX) {
4449	4449	LLVMValueRef tag_field_ptr = LLVMBuildStructGEP(g->builder, instruction->tmp_ptr,
4450	4450	union_type->data.unionation.gen_tag_index, "");
...	...	@@ -4470,14 +4470,14 @@ static LLVMValueRef ir_render_union_init(CodeGen g, IrExecutable executable, I
4470	4470	static LLVMValueRef ir_render_container_init_list(CodeGen g, IrExecutable executable,
4471	4471	IrInstructionContainerInitList *instruction)
4472	4472	{
4473		TypeTableEntry *array_type = instruction->base.value.type;
	4473	ZigType *array_type = instruction->base.value.type;
4474	4474	assert(array_type->id == TypeTableEntryIdArray);
4475	4475	LLVMValueRef tmp_array_ptr = instruction->tmp_ptr;
4476	4476	assert(tmp_array_ptr);
4477	4477
4478	4478	size_t field_count = instruction->item_count;
4479	4479
4480		TypeTableEntry *child_type = array_type->data.array.child_type;
	4480	ZigType *child_type = array_type->data.array.child_type;
4481	4481	for (size_t i = 0; i < field_count; i += 1) {
4482	4482	LLVMValueRef elem_val = ir_llvm_value(g, instruction->items[i]);
4483	4483	LLVMValueRef indices[] = {
...	...	@@ -4601,13 +4601,13 @@ static LLVMValueRef ir_render_coro_promise(CodeGen g, IrExecutable executable,
4601	4601	return LLVMBuildBitCast(g->builder, uncasted_result, instruction->base.value.type->type_ref, "");
4602	4602	}
4603	4603
4604		static LLVMValueRef get_coro_alloc_helper_fn_val(CodeGen g, LLVMTypeRef alloc_fn_type_ref, TypeTableEntry fn_type) {
	4604	static LLVMValueRef get_coro_alloc_helper_fn_val(CodeGen g, LLVMTypeRef alloc_fn_type_ref, ZigType fn_type) {
4605	4605	if (g->coro_alloc_helper_fn_val != nullptr)
4606	4606	return g->coro_alloc_helper_fn_val;
4607	4607
4608	4608	assert(fn_type->id == TypeTableEntryIdFn);
4609	4609
4610		TypeTableEntry *ptr_to_err_code_type = get_pointer_to_type(g, g->builtin_types.entry_global_error_set, false);
	4610	ZigType *ptr_to_err_code_type = get_pointer_to_type(g, g->builtin_types.entry_global_error_set, false);
4611	4611
4612	4612	LLVMTypeRef alloc_raw_fn_type_ref = LLVMGetElementType(alloc_fn_type_ref);
4613	4613	LLVMTypeRef *alloc_fn_arg_types = allocate<LLVMTypeRef>(LLVMCountParamTypes(alloc_raw_fn_type_ref));
...	...	@@ -4686,9 +4686,9 @@ static LLVMValueRef get_coro_alloc_helper_fn_val(CodeGen *g, LLVMTypeRef alloc_f
4686	4686
4687	4687	LLVMPositionBuilderAtEnd(g->builder, ok_block);
4688	4688	LLVMValueRef payload_ptr = LLVMBuildStructGEP(g->builder, sret_ptr, err_union_payload_index, "");
4689		TypeTableEntry *u8_ptr_type = get_pointer_to_type_extra(g, g->builtin_types.entry_u8, false, false,
	4689	ZigType *u8_ptr_type = get_pointer_to_type_extra(g, g->builtin_types.entry_u8, false, false,
4690	4690	PtrLenUnknown, get_abi_alignment(g, g->builtin_types.entry_u8), 0, 0);
4691		TypeTableEntry *slice_type = get_slice_type(g, u8_ptr_type);
	4691	ZigType *slice_type = get_slice_type(g, u8_ptr_type);
4692	4692	size_t ptr_field_index = slice_type->data.structure.fields[slice_ptr_index].gen_index;
4693	4693	LLVMValueRef ptr_field_ptr = LLVMBuildStructGEP(g->builder, payload_ptr, ptr_field_index, "");
4694	4694	LLVMValueRef ptr_val = LLVMBuildLoad(g->builder, ptr_field_ptr, "");
...	...	@@ -4733,7 +4733,7 @@ static LLVMValueRef ir_render_atomic_rmw(CodeGen g, IrExecutable executable,
4733	4733	IrInstructionAtomicRmw *instruction)
4734	4734	{
4735	4735	bool is_signed;
4736		TypeTableEntry *operand_type = instruction->operand->value.type;
	4736	ZigType *operand_type = instruction->operand->value.type;
4737	4737	if (operand_type->id == TypeTableEntryIdInt) {
4738	4738	is_signed = operand_type->data.integral.is_signed;
4739	4739	} else {
...	...	@@ -5090,14 +5090,14 @@ static LLVMValueRef gen_const_ptr_array_recursive(CodeGen g, ConstExprValue ar
5090	5090
5091	5091	LLVMTypeKind el_type = LLVMGetTypeKind(LLVMGetElementType(LLVMTypeOf(base_ptr)));
5092	5092	if (el_type == LLVMArrayTypeKind) {
5093		TypeTableEntry *usize = g->builtin_types.entry_usize;
	5093	ZigType *usize = g->builtin_types.entry_usize;
5094	5094	LLVMValueRef indices[] = {
5095	5095	LLVMConstNull(usize->type_ref),
5096	5096	LLVMConstInt(usize->type_ref, index, false),
5097	5097	};
5098	5098	return LLVMConstInBoundsGEP(base_ptr, indices, 2);
5099	5099	} else if (el_type == LLVMStructTypeKind) {
5100		TypeTableEntry *u32 = g->builtin_types.entry_u32;
	5100	ZigType *u32 = g->builtin_types.entry_u32;
5101	5101	LLVMValueRef indices[] = {
5102	5102	LLVMConstNull(u32->type_ref),
5103	5103	LLVMConstInt(u32->type_ref, index, false),
...	...	@@ -5113,7 +5113,7 @@ static LLVMValueRef gen_const_ptr_struct_recursive(CodeGen g, ConstExprValue s
5113	5113	ConstParent *parent = &struct_const_val->data.x_struct.parent;
5114	5114	LLVMValueRef base_ptr = gen_parent_ptr(g, struct_const_val, parent);
5115	5115
5116		TypeTableEntry *u32 = g->builtin_types.entry_u32;
	5116	ZigType *u32 = g->builtin_types.entry_u32;
5117	5117	LLVMValueRef indices[] = {
5118	5118	LLVMConstNull(u32->type_ref),
5119	5119	LLVMConstInt(u32->type_ref, field_index, false),
...	...	@@ -5125,7 +5125,7 @@ static LLVMValueRef gen_const_ptr_union_recursive(CodeGen g, ConstExprValue un
5125	5125	ConstParent *parent = &union_const_val->data.x_union.parent;
5126	5126	LLVMValueRef base_ptr = gen_parent_ptr(g, union_const_val, parent);
5127	5127
5128		TypeTableEntry *u32 = g->builtin_types.entry_u32;
	5128	ZigType *u32 = g->builtin_types.entry_u32;
5129	5129	LLVMValueRef indices[] = {
5130	5130	LLVMConstNull(u32->type_ref),
5131	5131	LLVMConstInt(u32->type_ref, 0, false), // TODO test const union with more aligned tag type than payload
...	...	@@ -5143,7 +5143,7 @@ static LLVMValueRef pack_const_int(CodeGen *g, LLVMTypeRef big_int_type_ref, Con
5143	5143	break;
5144	5144	}
5145	5145
5146		TypeTableEntry *type_entry = const_val->type;
	5146	ZigType *type_entry = const_val->type;
5147	5147	assert(!type_entry->zero_bits);
5148	5148	switch (type_entry->id) {
5149	5149	case TypeTableEntryIdInvalid:
...	...	@@ -5228,7 +5228,7 @@ static LLVMValueRef pack_const_int(CodeGen *g, LLVMTypeRef big_int_type_ref, Con
5228	5228
5229	5229	// We have this because union constants can't be represented by the official union type,
5230	5230	// and this property bubbles up in whatever aggregate type contains a union constant
5231		static bool is_llvm_value_unnamed_type(TypeTableEntry *type_entry, LLVMValueRef val) {
	5231	static bool is_llvm_value_unnamed_type(ZigType *type_entry, LLVMValueRef val) {
5232	5232	return LLVMTypeOf(val) != type_entry->type_ref;
5233	5233	}
5234	5234
...	...	@@ -5256,7 +5256,7 @@ static LLVMValueRef gen_const_val_ptr(CodeGen g, ConstExprValue const_val, con
5256	5256	assert(array_const_val->type->id == TypeTableEntryIdArray);
5257	5257	if (array_const_val->type->zero_bits) {
5258	5258	// make this a null pointer
5259		TypeTableEntry *usize = g->builtin_types.entry_usize;
	5259	ZigType *usize = g->builtin_types.entry_usize;
5260	5260	const_val->global_refs->llvm_value = LLVMConstIntToPtr(LLVMConstNull(usize->type_ref),
5261	5261	const_val->type->type_ref);
5262	5262	render_const_val_global(g, const_val, "");
...	...	@@ -5276,7 +5276,7 @@ static LLVMValueRef gen_const_val_ptr(CodeGen g, ConstExprValue const_val, con
5276	5276	assert(struct_const_val->type->id == TypeTableEntryIdStruct);
5277	5277	if (struct_const_val->type->zero_bits) {
5278	5278	// make this a null pointer
5279		TypeTableEntry *usize = g->builtin_types.entry_usize;
	5279	ZigType *usize = g->builtin_types.entry_usize;
5280	5280	const_val->global_refs->llvm_value = LLVMConstIntToPtr(LLVMConstNull(usize->type_ref),
5281	5281	const_val->type->type_ref);
5282	5282	render_const_val_global(g, const_val, "");
...	...	@@ -5296,7 +5296,7 @@ static LLVMValueRef gen_const_val_ptr(CodeGen g, ConstExprValue const_val, con
5296	5296	{
5297	5297	render_const_val_global(g, const_val, name);
5298	5298	uint64_t addr_value = const_val->data.x_ptr.data.hard_coded_addr.addr;
5299		TypeTableEntry *usize = g->builtin_types.entry_usize;
	5299	ZigType *usize = g->builtin_types.entry_usize;
5300	5300	const_val->global_refs->llvm_value = LLVMConstIntToPtr(LLVMConstInt(usize->type_ref, addr_value, false),
5301	5301	const_val->type->type_ref);
5302	5302	render_const_val_global(g, const_val, "");
...	...	@@ -5309,7 +5309,7 @@ static LLVMValueRef gen_const_val_ptr(CodeGen g, ConstExprValue const_val, con
5309	5309	}
5310	5310
5311	5311	static LLVMValueRef gen_const_val(CodeGen g, ConstExprValue const_val, const char *name) {
5312		TypeTableEntry *type_entry = const_val->type;
	5312	ZigType *type_entry = const_val->type;
5313	5313	assert(!type_entry->zero_bits);
5314	5314
5315	5315	switch (const_val->special) {
...	...	@@ -5356,7 +5356,7 @@ static LLVMValueRef gen_const_val(CodeGen g, ConstExprValue const_val, const c
5356	5356	}
5357	5357	case TypeTableEntryIdOptional:
5358	5358	{
5359		TypeTableEntry *child_type = type_entry->data.maybe.child_type;
	5359	ZigType *child_type = type_entry->data.maybe.child_type;
5360	5360	if (child_type->zero_bits) {
5361	5361	return LLVMConstInt(LLVMInt1Type(), const_val->data.x_optional ? 1 : 0, false);
5362	5362	} else if (type_is_codegen_pointer(child_type)) {
...	...	@@ -5559,8 +5559,8 @@ static LLVMValueRef gen_const_val(CodeGen g, ConstExprValue const_val, const c
5559	5559	return gen_const_val_ptr(g, const_val, name);
5560	5560	case TypeTableEntryIdErrorUnion:
5561	5561	{
5562		TypeTableEntry *payload_type = type_entry->data.error_union.payload_type;
5563		TypeTableEntry *err_set_type = type_entry->data.error_union.err_set_type;
	5562	ZigType *payload_type = type_entry->data.error_union.payload_type;
	5563	ZigType *err_set_type = type_entry->data.error_union.err_set_type;
5564	5564	if (!type_has_bits(payload_type)) {
5565	5565	assert(type_has_bits(err_set_type));
5566	5566	uint64_t value = const_val->data.x_err_union.err ? const_val->data.x_err_union.err->value : 0;
...	...	@@ -5650,9 +5650,9 @@ static void generate_error_name_table(CodeGen *g) {
5650	5650
5651	5651	assert(g->errors_by_index.length > 0);
5652	5652
5653		TypeTableEntry *u8_ptr_type = get_pointer_to_type_extra(g, g->builtin_types.entry_u8, true, false,
	5653	ZigType *u8_ptr_type = get_pointer_to_type_extra(g, g->builtin_types.entry_u8, true, false,
5654	5654	PtrLenUnknown, get_abi_alignment(g, g->builtin_types.entry_u8), 0, 0);
5655		TypeTableEntry *str_type = get_slice_type(g, u8_ptr_type);
	5655	ZigType *str_type = get_slice_type(g, u8_ptr_type);
5656	5656
5657	5657	LLVMValueRef *values = allocate<LLVMValueRef>(g->errors_by_index.length);
5658	5658	values[0] = LLVMGetUndef(str_type->type_ref);
...	...	@@ -5700,7 +5700,7 @@ static void build_all_basic_blocks(CodeGen g, FnTableEntry fn) {
5700	5700	}
5701	5701
5702	5702	static void gen_global_var(CodeGen g, VariableTableEntry var, LLVMValueRef init_val,
5703		TypeTableEntry *type_entry)
	5703	ZigType *type_entry)
5704	5704	{
5705	5705	if (g->strip_debug_symbols) {
5706	5706	return;
...	...	@@ -5721,7 +5721,7 @@ static void gen_global_var(CodeGen g, VariableTableEntry var, LLVMValueRef ini
5721	5721	// TODO ^^ make an actual global variable
5722	5722	}
5723	5723
5724		static LLVMValueRef build_alloca(CodeGen g, TypeTableEntry type_entry, const char *name, uint32_t alignment) {
	5724	static LLVMValueRef build_alloca(CodeGen g, ZigType type_entry, const char *name, uint32_t alignment) {
5725	5725	assert(alignment > 0);
5726	5726	LLVMValueRef result = LLVMBuildAlloca(g->builder, type_entry->type_ref, name);
5727	5727	LLVMSetAlignment(result, alignment);
...	...	@@ -5794,7 +5794,7 @@ static void do_code_gen(CodeGen *g) {
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);
5797		TypeTableEntry *var_type = g->builtin_types.entry_f128;
	5797	ZigType *var_type = g->builtin_types.entry_f128;
5798	5798	ConstExprValue coerced_value;
5799	5799	coerced_value.special = ConstValSpecialStatic;
5800	5800	coerced_value.type = var_type;
...	...	@@ -5812,7 +5812,7 @@ static void do_code_gen(CodeGen *g) {
5812	5812	if (bits_needed < 8) {
5813	5813	bits_needed = 8;
5814	5814	}
5815		TypeTableEntry *var_type = get_int_type(g, const_val->data.x_bigint.is_negative, bits_needed);
	5815	ZigType *var_type = get_int_type(g, const_val->data.x_bigint.is_negative, bits_needed);
5816	5816	LLVMValueRef init_val = bigint_to_llvm_const(var_type->type_ref, &const_val->data.x_bigint);
5817	5817	gen_global_var(g, var, init_val, var_type);
5818	5818	continue;
...	...	@@ -5869,7 +5869,7 @@ static void do_code_gen(CodeGen *g) {
5869	5869	LLVMValueRef fn = fn_llvm_value(g, fn_table_entry);
5870	5870	g->cur_fn = fn_table_entry;
5871	5871	g->cur_fn_val = fn;
5872		TypeTableEntry *return_type = fn_table_entry->type_entry->data.fn.fn_type_id.return_type;
	5872	ZigType *return_type = fn_table_entry->type_entry->data.fn.fn_type_id.return_type;
5873	5873	if (handle_is_ptr(return_type)) {
5874	5874	g->cur_ret_ptr = LLVMGetParam(fn, 0);
5875	5875	} else {
...	...	@@ -5892,7 +5892,7 @@ static void do_code_gen(CodeGen *g) {
5892	5892	bool have_err_ret_trace_stack = g->have_err_ret_tracing && fn_table_entry->calls_or_awaits_errorable_fn && !is_async && !have_err_ret_trace_arg;
5893	5893	LLVMValueRef err_ret_array_val = nullptr;
5894	5894	if (have_err_ret_trace_stack) {
5895		TypeTableEntry *array_type = get_array_type(g, g->builtin_types.entry_usize, stack_trace_ptr_count);
	5895	ZigType *array_type = get_array_type(g, g->builtin_types.entry_usize, stack_trace_ptr_count);
5896	5896	err_ret_array_val = build_alloca(g, array_type, "error_return_trace_addresses", get_abi_alignment(g, array_type));
5897	5897	g->cur_err_ret_trace_val_stack = build_alloca(g, g->stack_trace_type, "error_return_trace", get_abi_alignment(g, g->stack_trace_type));
5898	5898	} else {
...	...	@@ -5903,7 +5903,7 @@ static void do_code_gen(CodeGen *g) {
5903	5903	for (size_t alloca_i = 0; alloca_i < fn_table_entry->alloca_list.length; alloca_i += 1) {
5904	5904	IrInstruction *instruction = fn_table_entry->alloca_list.at(alloca_i);
5905	5905	LLVMValueRef *slot;
5906		TypeTableEntry *slot_type = instruction->value.type;
	5906	ZigType *slot_type = instruction->value.type;
5907	5907	if (instruction->id == IrInstructionIdCast) {
5908	5908	IrInstructionCast cast_instruction = (IrInstructionCast )instruction;
5909	5909	slot = &cast_instruction->tmp_ptr;
...	...	@@ -5968,7 +5968,7 @@ static void do_code_gen(CodeGen *g) {
5968	5968
5969	5969	} else {
5970	5970	assert(var->gen_arg_index != SIZE_MAX);
5971		TypeTableEntry *gen_type;
	5971	ZigType *gen_type;
5972	5972	FnGenParamInfo *gen_info = &fn_table_entry->type_entry->data.fn.gen_param_info[var->src_arg_index];
5973	5973
5974	5974	if (handle_is_ptr(var->value->type)) {
...	...	@@ -5994,7 +5994,7 @@ static void do_code_gen(CodeGen *g) {
5994	5994
5995	5995	// finishing error return trace setup. we have to do this after all the allocas.
5996	5996	if (have_err_ret_trace_stack) {
5997		TypeTableEntry *usize = g->builtin_types.entry_usize;
	5997	ZigType *usize = g->builtin_types.entry_usize;
5998	5998	size_t index_field_index = g->stack_trace_type->data.structure.fields[0].gen_index;
5999	5999	LLVMValueRef index_field_ptr = LLVMBuildStructGEP(g->builder, g->cur_err_ret_trace_val_stack, (unsigned)index_field_index, "");
6000	6000	gen_store_untyped(g, LLVMConstNull(usize->type_ref), index_field_ptr, 0, false);
...	...	@@ -6002,14 +6002,14 @@ static void do_code_gen(CodeGen *g) {
6002	6002	size_t addresses_field_index = g->stack_trace_type->data.structure.fields[1].gen_index;
6003	6003	LLVMValueRef addresses_field_ptr = LLVMBuildStructGEP(g->builder, g->cur_err_ret_trace_val_stack, (unsigned)addresses_field_index, "");
6004	6004
6005		TypeTableEntry *slice_type = g->stack_trace_type->data.structure.fields[1].type_entry;
	6005	ZigType *slice_type = g->stack_trace_type->data.structure.fields[1].type_entry;
6006	6006	size_t ptr_field_index = slice_type->data.structure.fields[slice_ptr_index].gen_index;
6007	6007	LLVMValueRef ptr_field_ptr = LLVMBuildStructGEP(g->builder, addresses_field_ptr, (unsigned)ptr_field_index, "");
6008	6008	LLVMValueRef zero = LLVMConstNull(usize->type_ref);
6009	6009	LLVMValueRef indices[] = {zero, zero};
6010	6010	LLVMValueRef err_ret_array_val_elem0_ptr = LLVMBuildInBoundsGEP(g->builder, err_ret_array_val,
6011	6011	indices, 2, "");
6012		TypeTableEntry *ptr_ptr_usize_type = get_pointer_to_type(g, get_pointer_to_type(g, usize, false), false);
	6012	ZigType *ptr_ptr_usize_type = get_pointer_to_type(g, get_pointer_to_type(g, usize, false), false);
6013	6013	gen_store(g, err_ret_array_val_elem0_ptr, ptr_field_ptr, ptr_ptr_usize_type);
6014	6014
6015	6015	size_t len_field_index = slice_type->data.structure.fields[slice_len_index].gen_index;
...	...	@@ -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		TypeTableEntry *entry = new_type_table_entry(TypeTableEntryIdInvalid);
	6176	ZigType *entry = new_type_table_entry(TypeTableEntryIdInvalid);
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		TypeTableEntry *entry = new_type_table_entry(TypeTableEntryIdNamespace);
	6182	ZigType *entry = new_type_table_entry(TypeTableEntryIdNamespace);
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		TypeTableEntry *entry = new_type_table_entry(TypeTableEntryIdBlock);
	6188	ZigType *entry = new_type_table_entry(TypeTableEntryIdBlock);
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		TypeTableEntry *entry = new_type_table_entry(TypeTableEntryIdComptimeFloat);
	6194	ZigType *entry = new_type_table_entry(TypeTableEntryIdComptimeFloat);
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		TypeTableEntry *entry = new_type_table_entry(TypeTableEntryIdComptimeInt);
	6201	ZigType *entry = new_type_table_entry(TypeTableEntryIdComptimeInt);
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		TypeTableEntry *entry = new_type_table_entry(TypeTableEntryIdUndefined);
	6208	ZigType *entry = new_type_table_entry(TypeTableEntryIdUndefined);
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		TypeTableEntry *entry = new_type_table_entry(TypeTableEntryIdNull);
	6214	ZigType *entry = new_type_table_entry(TypeTableEntryIdNull);
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		TypeTableEntry *entry = new_type_table_entry(TypeTableEntryIdArgTuple);
	6220	ZigType *entry = new_type_table_entry(TypeTableEntryIdArgTuple);
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		TypeTableEntry *entry = new_type_table_entry(TypeTableEntryIdInt);
	6231	ZigType *entry = new_type_table_entry(TypeTableEntryIdInt);
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		TypeTableEntry *entry = new_type_table_entry(TypeTableEntryIdBool);
	6248	ZigType *entry = new_type_table_entry(TypeTableEntryIdBool);
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		TypeTableEntry *entry = new_type_table_entry(TypeTableEntryIdInt);
	6262	ZigType *entry = new_type_table_entry(TypeTableEntryIdInt);
6263	6263	entry->type_ref = LLVMIntType(g->pointer_size_bytes * 8);
6264	6264
6265	6265	const char u_or_i = is_signed ? 'i' : 'u';
...	...	@@ -6286,8 +6286,8 @@ static void define_builtin_types(CodeGen *g) {
6286	6286	const char *name,
6287	6287	uint32_t bit_count,
6288	6288	LLVMTypeRef type_ref,
6289		TypeTableEntry **field) {
6290		TypeTableEntry *entry = new_type_table_entry(TypeTableEntryIdFloat);
	6289	ZigType **field) {
	6290	ZigType *entry = new_type_table_entry(TypeTableEntryIdFloat);
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		TypeTableEntry *entry = new_type_table_entry(TypeTableEntryIdVoid);
	6309	ZigType *entry = new_type_table_entry(TypeTableEntryIdVoid);
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		TypeTableEntry *entry = new_type_table_entry(TypeTableEntryIdUnreachable);
	6320	ZigType *entry = new_type_table_entry(TypeTableEntryIdUnreachable);
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		TypeTableEntry *entry = new_type_table_entry(TypeTableEntryIdMetaType);
	6329	ZigType *entry = new_type_table_entry(TypeTableEntryIdMetaType);
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		TypeTableEntry *entry = new_type_table_entry(TypeTableEntryIdErrorSet);
	6351	ZigType *entry = new_type_table_entry(TypeTableEntryIdErrorSet);
6352	6352	buf_init_from_str(&entry->name, "error");
6353	6353	entry->data.error_set.err_count = UINT32_MAX;
6354	6354
...	...	@@ -6370,7 +6370,7 @@ static void define_builtin_types(CodeGen *g) {
6370	6370	g->primitive_type_table.put(&entry->name, entry);
6371	6371	}
6372	6372	{
6373		TypeTableEntry *entry = get_promise_type(g, nullptr);
	6373	ZigType *entry = get_promise_type(g, nullptr);
6374	6374	g->primitive_type_table.put(&entry->name, entry);
6375	6375	}
6376	6376
...	...	@@ -6623,7 +6623,7 @@ Buf codegen_generate_builtin_source(CodeGen g) {
6623	6623	buf_appendf(contents, "pub const TypeId = enum {\n");
6624	6624	size_t field_count = type_id_len();
6625	6625	for (size_t i = 0; i < field_count; i += 1) {
6626		const TypeTableEntryId id = type_id_at_index(i);
	6626	const ZigTypeId id = type_id_at_index(i);
6627	6627	buf_appendf(contents, " %s,\n", type_id_name(id));
6628	6628	}
6629	6629	buf_appendf(contents, "};\n\n");
...	...	@@ -7068,14 +7068,14 @@ static void create_test_compile_var_and_add_test_runner(CodeGen *g) {
7068	7068	exit(0);
7069	7069	}
7070	7070
7071		TypeTableEntry *u8_ptr_type = get_pointer_to_type_extra(g, g->builtin_types.entry_u8, true, false,
	7071	ZigType *u8_ptr_type = get_pointer_to_type_extra(g, g->builtin_types.entry_u8, true, false,
7072	7072	PtrLenUnknown, get_abi_alignment(g, g->builtin_types.entry_u8), 0, 0);
7073		TypeTableEntry *str_type = get_slice_type(g, u8_ptr_type);
7074		TypeTableEntry *fn_type = get_test_fn_type(g);
	7073	ZigType *str_type = get_slice_type(g, u8_ptr_type);
	7074	ZigType *fn_type = get_test_fn_type(g);
7075	7075
7076	7076	const char *field_names[] = { "name", "func", };
7077		TypeTableEntry *field_types[] = { str_type, fn_type, };
7078		TypeTableEntry *struct_type = get_struct_type(g, "ZigTestFn", field_names, field_types, 2);
	7077	ZigType *field_types[] = { str_type, fn_type, };
	7078	ZigType *struct_type = get_struct_type(g, "ZigTestFn", field_names, field_types, 2);
7079	7079
7080	7080	ConstExprValue *test_fn_array = create_const_vals(1);
7081	7081	test_fn_array->type = get_array_type(g, struct_type, g->test_fns.length);
...	...	@@ -7217,10 +7217,10 @@ static const char *c_int_type_names[] = {
7217	7217	};
7218	7218
7219	7219	struct GenH {
7220		ZigList<TypeTableEntry *> types_to_declare;
	7220	ZigList<ZigType *> types_to_declare;
7221	7221	};
7222	7222
7223		static void prepend_c_type_to_decl_list(CodeGen g, GenH gen_h, TypeTableEntry *type_entry) {
	7223	static void prepend_c_type_to_decl_list(CodeGen g, GenH gen_h, ZigType *type_entry) {
7224	7224	if (type_entry->gen_h_loop_flag)
7225	7225	return;
7226	7226	type_entry->gen_h_loop_flag = true;
...	...	@@ -7285,7 +7285,7 @@ static void prepend_c_type_to_decl_list(CodeGen g, GenH gen_h, TypeTableEntry
7285	7285	}
7286	7286	}
7287	7287
7288		static void get_c_type(CodeGen g, GenH gen_h, TypeTableEntry type_entry, Buf out_buf) {
	7288	static void get_c_type(CodeGen g, GenH gen_h, ZigType type_entry, Buf out_buf) {
7289	7289	assert(type_entry);
7290	7290
7291	7291	for (size_t i = 0; i < array_length(c_int_type_names); i += 1) {
...	...	@@ -7354,7 +7354,7 @@ static void get_c_type(CodeGen g, GenH gen_h, TypeTableEntry *type_entry, Buf
7354	7354	case TypeTableEntryIdPointer:
7355	7355	{
7356	7356	Buf child_buf = BUF_INIT;
7357		TypeTableEntry *child_type = type_entry->data.pointer.child_type;
	7357	ZigType *child_type = type_entry->data.pointer.child_type;
7358	7358	get_c_type(g, gen_h, child_type, &child_buf);
7359	7359
7360	7360	const char *const_str = type_entry->data.pointer.is_const ? "const " : "";
...	...	@@ -7364,7 +7364,7 @@ static void get_c_type(CodeGen g, GenH gen_h, TypeTableEntry *type_entry, Buf
7364	7364	}
7365	7365	case TypeTableEntryIdOptional:
7366	7366	{
7367		TypeTableEntry *child_type = type_entry->data.maybe.child_type;
	7367	ZigType *child_type = type_entry->data.maybe.child_type;
7368	7368	if (child_type->zero_bits) {
7369	7369	buf_init_from_str(out_buf, "bool");
7370	7370	return;
...	...	@@ -7555,7 +7555,7 @@ static void gen_h_file(CodeGen *g) {
7555	7555	fprintf(out_h, "\n");
7556	7556
7557	7557	for (size_t type_i = 0; type_i < gen_h->types_to_declare.length; type_i += 1) {
7558		TypeTableEntry *type_entry = gen_h->types_to_declare.at(type_i);
	7558	ZigType *type_entry = gen_h->types_to_declare.at(type_i);
7559	7559	switch (type_entry->id) {
7560	7560	case TypeTableEntryIdInvalid:
7561	7561	case TypeTableEntryIdMetaType:

src/ir.cpp+553-553

...	...	@@ -33,7 +33,7 @@ struct IrAnalyze {
33	33	IrExecContext exec_context;
34	34	size_t old_bb_index;
35	35	size_t instruction_index;
36		TypeTableEntry *explicit_return_type;
	36	ZigType *explicit_return_type;
37	37	ZigList<IrInstruction *> src_implicit_return_type_list;
38	38	IrBasicBlock *const_predecessor_bb;
39	39	};
...	...	@@ -99,38 +99,38 @@ struct ConstCastOnly {
99	99	};
100	100
101	101	struct ConstCastTypeMismatch {
102		TypeTableEntry *wanted_type;
103		TypeTableEntry *actual_type;
	102	ZigType *wanted_type;
	103	ZigType *actual_type;
104	104	};
105	105
106	106	struct ConstCastOptionalMismatch {
107	107	ConstCastOnly child;
108		TypeTableEntry *wanted_child;
109		TypeTableEntry *actual_child;
	108	ZigType *wanted_child;
	109	ZigType *actual_child;
110	110	};
111	111
112	112	struct ConstCastPointerMismatch {
113	113	ConstCastOnly child;
114		TypeTableEntry *wanted_child;
115		TypeTableEntry *actual_child;
	114	ZigType *wanted_child;
	115	ZigType *actual_child;
116	116	};
117	117
118	118	struct ConstCastSliceMismatch {
119	119	ConstCastOnly child;
120		TypeTableEntry *wanted_child;
121		TypeTableEntry *actual_child;
	120	ZigType *wanted_child;
	121	ZigType *actual_child;
122	122	};
123	123
124	124	struct ConstCastErrUnionErrSetMismatch {
125	125	ConstCastOnly child;
126		TypeTableEntry *wanted_err_set;
127		TypeTableEntry *actual_err_set;
	126	ZigType *wanted_err_set;
	127	ZigType *actual_err_set;
128	128	};
129	129
130	130	struct ConstCastErrUnionPayloadMismatch {
131	131	ConstCastOnly child;
132		TypeTableEntry *wanted_payload;
133		TypeTableEntry *actual_payload;
	132	ZigType *wanted_payload;
	133	ZigType *actual_payload;
134	134	};
135	135
136	136	struct ConstCastErrSetMismatch {
...	...	@@ -139,17 +139,17 @@ struct ConstCastErrSetMismatch {
139	139
140	140	static IrInstruction ir_gen_node(IrBuilder irb, AstNode node, Scope scope);
141	141	static IrInstruction ir_gen_node_extra(IrBuilder irb, AstNode node, Scope scope, LVal lval);
142		static TypeTableEntry ir_analyze_instruction(IrAnalyze ira, IrInstruction *instruction);
143		static IrInstruction ir_implicit_cast(IrAnalyze ira, IrInstruction value, TypeTableEntry expected_type);
	142	static ZigType ir_analyze_instruction(IrAnalyze ira, IrInstruction *instruction);
	143	static IrInstruction ir_implicit_cast(IrAnalyze ira, IrInstruction value, ZigType expected_type);
144	144	static IrInstruction ir_get_deref(IrAnalyze ira, IrInstruction source_instruction, IrInstruction ptr);
145	145	static ErrorMsg exec_add_error_node(CodeGen codegen, IrExecutable exec, AstNode source_node, Buf *msg);
146	146	static IrInstruction ir_analyze_container_field_ptr(IrAnalyze ira, Buf *field_name,
147		IrInstruction source_instr, IrInstruction container_ptr, TypeTableEntry *container_type);
	147	IrInstruction source_instr, IrInstruction container_ptr, ZigType *container_type);
148	148	static IrInstruction ir_get_var_ptr(IrAnalyze ira, IrInstruction instruction, VariableTableEntry var);
149		static TypeTableEntry ir_resolve_atomic_operand_type(IrAnalyze ira, IrInstruction *op);
	149	static ZigType ir_resolve_atomic_operand_type(IrAnalyze ira, IrInstruction *op);
150	150	static IrInstruction ir_lval_wrap(IrBuilder irb, Scope scope, IrInstruction value, LVal lval);
151		static TypeTableEntry adjust_ptr_align(CodeGen g, TypeTableEntry *ptr_type, uint32_t new_align);
152		static TypeTableEntry adjust_slice_align(CodeGen g, TypeTableEntry *slice_type, uint32_t new_align);
	151	static ZigType adjust_ptr_align(CodeGen g, ZigType *ptr_type, uint32_t new_align);
	152	static ZigType adjust_slice_align(CodeGen g, ZigType *slice_type, uint32_t new_align);
153	153	static void buf_read_value_bytes(CodeGen codegen, uint8_t buf, ConstExprValue *val);
154	154	static void buf_write_value_bytes(CodeGen codegen, uint8_t buf, ConstExprValue *val);
155	155
...	...	@@ -183,7 +183,7 @@ static ConstExprValue const_ptr_pointee_unchecked(CodeGen g, ConstExprValue *c
183	183	return result;
184	184	}
185	185
186		static bool types_have_same_zig_comptime_repr(TypeTableEntry a, TypeTableEntry b) {
	186	static bool types_have_same_zig_comptime_repr(ZigType a, ZigType b) {
187	187	if (a == b)
188	188	return true;
189	189
...	...	@@ -878,7 +878,7 @@ static T ir_build_instruction(IrBuilder irb, Scope scope, AstNode source_nod
878	878	return special_instruction;
879	879	}
880	880
881		static IrInstruction ir_build_cast(IrBuilder irb, Scope scope, AstNode source_node, TypeTableEntry *dest_type,
	881	static IrInstruction ir_build_cast(IrBuilder irb, Scope scope, AstNode source_node, ZigType *dest_type,
882	882	IrInstruction *value, CastOp cast_op)
883	883	{
884	884	IrInstructionCast *cast_instruction = ir_build_instruction<IrInstructionCast>(irb, scope, source_node);
...	...	@@ -931,7 +931,7 @@ static IrInstruction ir_build_return(IrBuilder irb, Scope scope, AstNode sou
931	931	}
932	932
933	933	static IrInstruction ir_create_const(IrBuilder irb, Scope scope, AstNode source_node,
934		TypeTableEntry *type_entry)
	934	ZigType *type_entry)
935	935	{
936	936	assert(type_entry);
937	937	IrInstructionConst *const_instruction = ir_create_instruction<IrInstructionConst>(irb, scope, source_node);
...	...	@@ -1002,7 +1002,7 @@ static IrInstruction ir_build_const_u8(IrBuilder irb, Scope scope, AstNode s
1002	1002	}
1003	1003
1004	1004	static IrInstruction ir_create_const_type(IrBuilder irb, Scope scope, AstNode source_node,
1005		TypeTableEntry *type_entry)
	1005	ZigType *type_entry)
1006	1006	{
1007	1007	IrInstructionConst *const_instruction = ir_create_instruction<IrInstructionConst>(irb, scope, source_node);
1008	1008	const_instruction->base.value.type = irb->codegen->builtin_types.entry_type;
...	...	@@ -1012,7 +1012,7 @@ static IrInstruction ir_create_const_type(IrBuilder irb, Scope *scope, AstNode
1012	1012	}
1013	1013
1014	1014	static IrInstruction ir_build_const_type(IrBuilder irb, Scope scope, AstNode source_node,
1015		TypeTableEntry *type_entry)
	1015	ZigType *type_entry)
1016	1016	{
1017	1017	IrInstruction *instruction = ir_create_const_type(irb, scope, source_node, type_entry);
1018	1018	ir_instruction_append(irb->current_basic_block, instruction);
...	...	@@ -1376,7 +1376,7 @@ static IrInstruction ir_build_container_init_fields(IrBuilder irb, Scope *scop
1376	1376	}
1377	1377
1378	1378	static IrInstruction ir_build_struct_init(IrBuilder irb, Scope scope, AstNode source_node,
1379		TypeTableEntry struct_type, size_t field_count, IrInstructionStructInitField fields)
	1379	ZigType struct_type, size_t field_count, IrInstructionStructInitField fields)
1380	1380	{
1381	1381	IrInstructionStructInit *struct_init_instruction = ir_build_instruction<IrInstructionStructInit>(irb, scope, source_node);
1382	1382	struct_init_instruction->struct_type = struct_type;
...	...	@@ -1390,7 +1390,7 @@ static IrInstruction ir_build_struct_init(IrBuilder irb, Scope *scope, AstNode
1390	1390	}
1391	1391
1392	1392	static IrInstruction ir_build_struct_init_from(IrBuilder irb, IrInstruction *old_instruction,
1393		TypeTableEntry struct_type, size_t field_count, IrInstructionStructInitField fields)
	1393	ZigType struct_type, size_t field_count, IrInstructionStructInitField fields)
1394	1394	{
1395	1395	IrInstruction *new_instruction = ir_build_struct_init(irb, old_instruction->scope,
1396	1396	old_instruction->source_node, struct_type, field_count, fields);
...	...	@@ -1399,7 +1399,7 @@ static IrInstruction ir_build_struct_init_from(IrBuilder irb, IrInstruction *o
1399	1399	}
1400	1400
1401	1401	static IrInstruction ir_build_union_init(IrBuilder irb, Scope scope, AstNode source_node,
1402		TypeTableEntry union_type, TypeUnionField field, IrInstruction *init_value)
	1402	ZigType union_type, TypeUnionField field, IrInstruction *init_value)
1403	1403	{
1404	1404	IrInstructionUnionInit *union_init_instruction = ir_build_instruction<IrInstructionUnionInit>(irb, scope, source_node);
1405	1405	union_init_instruction->union_type = union_type;
...	...	@@ -1412,7 +1412,7 @@ static IrInstruction ir_build_union_init(IrBuilder irb, Scope *scope, AstNode
1412	1412	}
1413	1413
1414	1414	static IrInstruction ir_build_union_init_from(IrBuilder irb, IrInstruction *old_instruction,
1415		TypeTableEntry union_type, TypeUnionField field, IrInstruction *init_value)
	1415	ZigType union_type, TypeUnionField field, IrInstruction *init_value)
1416	1416	{
1417	1417	IrInstruction *new_instruction = ir_build_union_init(irb, old_instruction->scope,
1418	1418	old_instruction->source_node, union_type, field, init_value);
...	...	@@ -1973,7 +1973,7 @@ static IrInstruction ir_build_cmpxchg(IrBuilder irb, Scope scope, AstNode so
1973	1973	IrInstruction ptr, IrInstruction cmp_value, IrInstruction *new_value,
1974	1974	IrInstruction success_order_value, IrInstruction failure_order_value,
1975	1975	bool is_weak,
1976		TypeTableEntry *type, AtomicOrder success_order, AtomicOrder failure_order)
	1976	ZigType *type, AtomicOrder success_order, AtomicOrder failure_order)
1977	1977	{
1978	1978	IrInstructionCmpxchg *instruction = ir_build_instruction<IrInstructionCmpxchg>(irb, scope, source_node);
1979	1979	instruction->type_value = type_value;
...	...	@@ -2286,7 +2286,7 @@ static IrInstruction ir_build_handle_from(IrBuilder irb, IrInstruction *old_in
2286	2286
2287	2287	static IrInstruction ir_build_overflow_op(IrBuilder irb, Scope scope, AstNode source_node,
2288	2288	IrOverflowOp op, IrInstruction type_value, IrInstruction op1, IrInstruction *op2,
2289		IrInstruction result_ptr, TypeTableEntry result_ptr_type)
	2289	IrInstruction result_ptr, ZigType result_ptr_type)
2290	2290	{
2291	2291	IrInstructionOverflowOp *instruction = ir_build_instruction<IrInstructionOverflowOp>(irb, scope, source_node);
2292	2292	instruction->op = op;
...	...	@@ -2306,7 +2306,7 @@ static IrInstruction ir_build_overflow_op(IrBuilder irb, Scope *scope, AstNode
2306	2306
2307	2307	static IrInstruction ir_build_overflow_op_from(IrBuilder irb, IrInstruction *old_instruction,
2308	2308	IrOverflowOp op, IrInstruction type_value, IrInstruction op1, IrInstruction *op2,
2309		IrInstruction result_ptr, TypeTableEntry result_ptr_type)
	2309	IrInstruction result_ptr, ZigType result_ptr_type)
2310	2310	{
2311	2311	IrInstruction *new_instruction = ir_build_overflow_op(irb, old_instruction->scope, old_instruction->source_node,
2312	2312	op, type_value, op1, op2, result_ptr, result_ptr_type);
...	...	@@ -3343,7 +3343,7 @@ static VariableTableEntry create_local_var(CodeGen codegen, AstNode *node, Sco
3343	3343	add_error_note(codegen, msg, existing_var->decl_node, buf_sprintf("previous declaration is here"));
3344	3344	variable_entry->value->type = codegen->builtin_types.entry_invalid;
3345	3345	} else {
3346		TypeTableEntry *type = get_primitive_type(codegen, name);
	3346	ZigType *type = get_primitive_type(codegen, name);
3347	3347	if (type != nullptr) {
3348	3348	add_node_error(codegen, node,
3349	3349	buf_sprintf("variable shadows type '%s'", buf_ptr(&type->name)));
...	...	@@ -3789,7 +3789,7 @@ static IrInstruction ir_gen_symbol(IrBuilder irb, Scope scope, AstNode node,
3789	3789	return &const_instruction->base;
3790	3790	}
3791	3791
3792		TypeTableEntry *primitive_type = get_primitive_type(irb->codegen, variable_name);
	3792	ZigType *primitive_type = get_primitive_type(irb->codegen, variable_name);
3793	3793	if (primitive_type != nullptr) {
3794	3794	IrInstruction *value = ir_build_const_type(irb, scope, node, primitive_type);
3795	3795	if (lval == LValPtr) {
...	...	@@ -5696,7 +5696,7 @@ static IrInstruction ir_gen_this_literal(IrBuilder irb, Scope *scope, AstNode
5696	5696
5697	5697	if (scope->id == ScopeIdDecls) {
5698	5698	ScopeDecls decls_scope = (ScopeDecls )scope;
5699		TypeTableEntry *container_type = decls_scope->container_type;
	5699	ZigType *container_type = decls_scope->container_type;
5700	5700	assert(container_type);
5701	5701	return ir_build_const_type(irb, scope, node, container_type);
5702	5702	}
...	...	@@ -6566,7 +6566,7 @@ static IrInstruction ir_gen_container_decl(IrBuilder irb, Scope *parent_scope,
6566	6566	init_tld(&tld_container->base, TldIdContainer, name, visib_mod, node, parent_scope);
6567	6567
6568	6568	ContainerLayout layout = node->data.container_decl.layout;
6569		TypeTableEntry *container_type = get_partial_container_type(irb->codegen, parent_scope,
	6569	ZigType *container_type = get_partial_container_type(irb->codegen, parent_scope,
6570	6570	kind, node, buf_ptr(name), layout);
6571	6571	ScopeDecls *child_scope = get_container_scope(container_type);
6572	6572
...	...	@@ -6586,11 +6586,11 @@ static IrInstruction ir_gen_container_decl(IrBuilder irb, Scope *parent_scope,
6586	6586	}
6587	6587
6588	6588	// errors should be populated with set1's values
6589		static TypeTableEntry get_error_set_union(CodeGen g, ErrorTableEntry *errors, TypeTableEntry set1, TypeTableEntry *set2) {
	6589	static ZigType get_error_set_union(CodeGen g, ErrorTableEntry *errors, ZigType set1, ZigType *set2) {
6590	6590	assert(set1->id == TypeTableEntryIdErrorSet);
6591	6591	assert(set2->id == TypeTableEntryIdErrorSet);
6592	6592
6593		TypeTableEntry *err_set_type = new_type_table_entry(TypeTableEntryIdErrorSet);
	6593	ZigType *err_set_type = new_type_table_entry(TypeTableEntryIdErrorSet);
6594	6594	buf_resize(&err_set_type->name, 0);
6595	6595	buf_appendf(&err_set_type->name, "error{");
6596	6596
...	...	@@ -6639,10 +6639,10 @@ static TypeTableEntry get_error_set_union(CodeGen g, ErrorTableEntry **errors,
6639	6639
6640	6640	}
6641	6641
6642		static TypeTableEntry make_err_set_with_one_item(CodeGen g, Scope parent_scope, AstNode node,
	6642	static ZigType make_err_set_with_one_item(CodeGen g, Scope parent_scope, AstNode node,
6643	6643	ErrorTableEntry *err_entry)
6644	6644	{
6645		TypeTableEntry *err_set_type = new_type_table_entry(TypeTableEntryIdErrorSet);
	6645	ZigType *err_set_type = new_type_table_entry(TypeTableEntryIdErrorSet);
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		TypeTableEntry *err_set_type = new_type_table_entry(TypeTableEntryIdErrorSet);
	6667	ZigType *err_set_type = new_type_table_entry(TypeTableEntryIdErrorSet);
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;
...	...	@@ -7386,7 +7386,7 @@ bool ir_gen(CodeGen codegen, AstNode node, Scope scope, IrExecutable ir_exec
7386	7386	IrInstruction *const_bool_false;
7387	7387	IrInstruction *coro_promise_ptr;
7388	7388	IrInstruction *err_ret_trace_ptr;
7389		TypeTableEntry *return_type;
	7389	ZigType *return_type;
7390	7390	Buf *result_ptr_field_name;
7391	7391	VariableTableEntry *coro_size_var;
7392	7392	if (is_async) {
...	...	@@ -7397,7 +7397,7 @@ bool ir_gen(CodeGen codegen, AstNode node, Scope scope, IrExecutable ir_exec
7397	7397
7398	7398	return_type = fn_entry->type_entry->data.fn.fn_type_id.return_type;
7399	7399	IrInstruction *undef = ir_build_const_undefined(irb, coro_scope, node);
7400		TypeTableEntry *coro_frame_type = get_promise_frame_type(irb->codegen, return_type);
	7400	ZigType *coro_frame_type = get_promise_frame_type(irb->codegen, return_type);
7401	7401	IrInstruction *coro_frame_type_value = ir_build_const_type(irb, coro_scope, node, coro_frame_type);
7402	7402	// TODO mark this var decl as "no safety" e.g. disable initializing the undef value to 0xaa
7403	7403	ir_build_var_decl(irb, coro_scope, node, promise_var, coro_frame_type_value, nullptr, undef);
...	...	@@ -7629,7 +7629,7 @@ static ConstExprValue ir_const_ptr_pointee(IrAnalyze ira, ConstExprValue *cons
7629	7629	ConstExprValue *val = const_ptr_pointee_unchecked(ira->codegen, const_val);
7630	7630	assert(val != nullptr);
7631	7631	assert(const_val->type->id == TypeTableEntryIdPointer);
7632		TypeTableEntry *expected_type = const_val->type->data.pointer.child_type;
	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,
7635	7635	buf_sprintf("TODO handle comptime reinterpreted pointer. See https://github.com/ziglang/zig/issues/955"));
...	...	@@ -7668,7 +7668,7 @@ static bool ir_emit_global_runtime_side_effect(IrAnalyze ira, IrInstruction so
7668	7668	return true;
7669	7669	}
7670	7670
7671		static bool const_val_fits_in_num_lit(ConstExprValue const_val, TypeTableEntry num_lit_type) {
	7671	static bool const_val_fits_in_num_lit(ConstExprValue const_val, ZigType num_lit_type) {
7672	7672	return ((num_lit_type->id == TypeTableEntryIdComptimeFloat &&
7673	7673	(const_val->type->id == TypeTableEntryIdFloat \|\| const_val->type->id == TypeTableEntryIdComptimeFloat)) \|\|
7674	7674	(num_lit_type->id == TypeTableEntryIdComptimeInt &&
...	...	@@ -8365,7 +8365,7 @@ void float_read_ieee597(ConstExprValue val, uint8_t buf, bool is_big_endian) {
8365	8365	}
8366	8366	}
8367	8367
8368		static bool ir_num_lit_fits_in_other_type(IrAnalyze ira, IrInstruction instruction, TypeTableEntry *other_type,
	8368	static bool ir_num_lit_fits_in_other_type(IrAnalyze ira, IrInstruction instruction, ZigType *other_type,
8369	8369	bool explicit_cast)
8370	8370	{
8371	8371	if (type_is_invalid(other_type)) {
...	...	@@ -8399,7 +8399,7 @@ static bool ir_num_lit_fits_in_other_type(IrAnalyze ira, IrInstruction instruc
8399	8399	} else if (const_val_fits_in_num_lit(const_val, other_type)) {
8400	8400	return true;
8401	8401	} else if (other_type->id == TypeTableEntryIdOptional) {
8402		TypeTableEntry *child_type = other_type->data.maybe.child_type;
	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	8405	} else if (child_type->id == TypeTableEntryIdInt && const_val_is_int) {
...	...	@@ -8467,16 +8467,16 @@ static bool ir_num_lit_fits_in_other_type(IrAnalyze ira, IrInstruction instruc
8467	8467	return false;
8468	8468	}
8469	8469
8470		static bool is_slice(TypeTableEntry *type) {
	8470	static bool is_slice(ZigType *type) {
8471	8471	return type->id == TypeTableEntryIdStruct && type->data.structure.is_slice;
8472	8472	}
8473	8473
8474		static bool slice_is_const(TypeTableEntry *type) {
	8474	static bool slice_is_const(ZigType *type) {
8475	8475	assert(is_slice(type));
8476	8476	return type->data.structure.fields[slice_ptr_index].type_entry->data.pointer.is_const;
8477	8477	}
8478	8478
8479		static TypeTableEntry get_error_set_intersection(IrAnalyze ira, TypeTableEntry set1, TypeTableEntry set2,
	8479	static ZigType get_error_set_intersection(IrAnalyze ira, ZigType set1, ZigType set2,
8480	8480	AstNode *source_node)
8481	8481	{
8482	8482	assert(set1->id == TypeTableEntryIdErrorSet);
...	...	@@ -8502,7 +8502,7 @@ static TypeTableEntry get_error_set_intersection(IrAnalyze ira, TypeTableEntry
8502	8502	}
8503	8503	ZigList<ErrorTableEntry *> intersection_list = {};
8504	8504
8505		TypeTableEntry *err_set_type = new_type_table_entry(TypeTableEntryIdErrorSet);
	8505	ZigType *err_set_type = new_type_table_entry(TypeTableEntryIdErrorSet);
8506	8506	buf_resize(&err_set_type->name, 0);
8507	8507	buf_appendf(&err_set_type->name, "error{");
8508	8508
...	...	@@ -8531,8 +8531,8 @@ static TypeTableEntry get_error_set_intersection(IrAnalyze ira, TypeTableEntry
8531	8531	}
8532	8532
8533	8533
8534		static ConstCastOnly types_match_const_cast_only(IrAnalyze ira, TypeTableEntry wanted_type,
8535		TypeTableEntry actual_type, AstNode source_node, bool wanted_is_mutable)
	8534	static ConstCastOnly types_match_const_cast_only(IrAnalyze ira, ZigType wanted_type,
	8535	ZigType actual_type, AstNode source_node, bool wanted_is_mutable)
8536	8536	{
8537	8537	CodeGen *g = ira->codegen;
8538	8538	ConstCastOnly result = {};
...	...	@@ -8595,8 +8595,8 @@ static ConstCastOnly types_match_const_cast_only(IrAnalyze *ira, TypeTableEntry
8595	8595
8596	8596	// slice const
8597	8597	if (is_slice(wanted_type) && is_slice(actual_type)) {
8598		TypeTableEntry *actual_ptr_type = actual_type->data.structure.fields[slice_ptr_index].type_entry;
8599		TypeTableEntry *wanted_ptr_type = wanted_type->data.structure.fields[slice_ptr_index].type_entry;
	8598	ZigType *actual_ptr_type = actual_type->data.structure.fields[slice_ptr_index].type_entry;
	8599	ZigType *wanted_ptr_type = wanted_type->data.structure.fields[slice_ptr_index].type_entry;
8600	8600	if ((!actual_ptr_type->data.pointer.is_const \|\| wanted_ptr_type->data.pointer.is_const) &&
8601	8601	(!actual_ptr_type->data.pointer.is_volatile \|\| wanted_ptr_type->data.pointer.is_volatile) &&
8602	8602	actual_ptr_type->data.pointer.bit_offset == wanted_ptr_type->data.pointer.bit_offset &&
...	...	@@ -8657,8 +8657,8 @@ static ConstCastOnly types_match_const_cast_only(IrAnalyze *ira, TypeTableEntry
8657	8657
8658	8658	// error set
8659	8659	if (wanted_type->id == TypeTableEntryIdErrorSet && actual_type->id == TypeTableEntryIdErrorSet) {
8660		TypeTableEntry *contained_set = actual_type;
8661		TypeTableEntry *container_set = wanted_type;
	8660	ZigType *contained_set = actual_type;
	8661	ZigType *container_set = wanted_type;
8662	8662
8663	8663	// if the container set is inferred, then this will always work.
8664	8664	if (container_set->data.error_set.infer_fn != nullptr) {
...	...	@@ -8797,7 +8797,7 @@ static void update_errors_helper(CodeGen g, ErrorTableEntry *errors, size_t
8797	8797	errors = reallocate(errors, old_errors_count, *errors_count);
8798	8798	}
8799	8799
8800		static TypeTableEntry ir_resolve_peer_types(IrAnalyze ira, AstNode source_node, TypeTableEntry expected_type, IrInstruction **instructions, size_t instruction_count) {
	8800	static ZigType ir_resolve_peer_types(IrAnalyze ira, AstNode source_node, ZigType expected_type, IrInstruction **instructions, size_t instruction_count) {
8801	8801	Error err;
8802	8802	assert(instruction_count >= 1);
8803	8803	IrInstruction *prev_inst = instructions[0];
...	...	@@ -8806,7 +8806,7 @@ static TypeTableEntry ir_resolve_peer_types(IrAnalyze ira, AstNode *source_nod
8806	8806	}
8807	8807	ErrorTableEntry **errors = nullptr;
8808	8808	size_t errors_count = 0;
8809		TypeTableEntry *err_set_type = nullptr;
	8809	ZigType *err_set_type = nullptr;
8810	8810	if (prev_inst->value.type->id == TypeTableEntryIdErrorSet) {
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;
...	...	@@ -8829,8 +8829,8 @@ static TypeTableEntry ir_resolve_peer_types(IrAnalyze ira, AstNode *source_nod
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];
8832		TypeTableEntry *cur_type = cur_inst->value.type;
8833		TypeTableEntry *prev_type = prev_inst->value.type;
	8832	ZigType *cur_type = cur_inst->value.type;
	8833	ZigType *prev_type = prev_inst->value.type;
8834	8834
8835	8835	if (type_is_invalid(cur_type)) {
8836	8836	return cur_type;
...	...	@@ -8916,7 +8916,7 @@ static TypeTableEntry ir_resolve_peer_types(IrAnalyze ira, AstNode *source_nod
8916	8916	prev_inst = cur_inst;
8917	8917	continue;
8918	8918	}
8919		TypeTableEntry *cur_err_set_type = cur_type->data.error_union.err_set_type;
	8919	ZigType *cur_err_set_type = cur_type->data.error_union.err_set_type;
8920	8920	if (!resolve_inferred_error_set(ira->codegen, cur_err_set_type, cur_inst->source_node)) {
8921	8921	return ira->codegen->builtin_types.entry_invalid;
8922	8922	}
...	...	@@ -9021,8 +9021,8 @@ static TypeTableEntry ir_resolve_peer_types(IrAnalyze ira, AstNode *source_nod
9021	9021	}
9022	9022
9023	9023	if (prev_type->id == TypeTableEntryIdErrorUnion && cur_type->id == TypeTableEntryIdErrorUnion) {
9024		TypeTableEntry *prev_payload_type = prev_type->data.error_union.payload_type;
9025		TypeTableEntry *cur_payload_type = cur_type->data.error_union.payload_type;
	9024	ZigType *prev_payload_type = prev_type->data.error_union.payload_type;
	9025	ZigType *cur_payload_type = cur_type->data.error_union.payload_type;
9026	9026
9027	9027	bool const_cast_prev = types_match_const_cast_only(ira, prev_payload_type, cur_payload_type,
9028	9028	source_node, false).id == ConstCastResultIdOk;
...	...	@@ -9034,8 +9034,8 @@ static TypeTableEntry ir_resolve_peer_types(IrAnalyze ira, AstNode *source_nod
9034	9034	prev_inst = cur_inst;
9035	9035	}
9036	9036
9037		TypeTableEntry *prev_err_set_type = (err_set_type == nullptr) ? prev_type->data.error_union.err_set_type : err_set_type;
9038		TypeTableEntry *cur_err_set_type = cur_type->data.error_union.err_set_type;
	9037	ZigType *prev_err_set_type = (err_set_type == nullptr) ? prev_type->data.error_union.err_set_type : err_set_type;
	9038	ZigType *cur_err_set_type = cur_type->data.error_union.err_set_type;
9039	9039
9040	9040	if (!resolve_inferred_error_set(ira->codegen, prev_err_set_type, cur_inst->source_node)) {
9041	9041	return ira->codegen->builtin_types.entry_invalid;
...	...	@@ -9152,7 +9152,7 @@ static TypeTableEntry ir_resolve_peer_types(IrAnalyze ira, AstNode *source_nod
9152	9152	source_node, false).id == ConstCastResultIdOk)
9153	9153	{
9154	9154	if (err_set_type != nullptr) {
9155		TypeTableEntry *cur_err_set_type = cur_type->data.error_union.err_set_type;
	9155	ZigType *cur_err_set_type = cur_type->data.error_union.err_set_type;
9156	9156	if (!resolve_inferred_error_set(ira->codegen, cur_err_set_type, cur_inst->source_node)) {
9157	9157	return ira->codegen->builtin_types.entry_invalid;
9158	9158	}
...	...	@@ -9293,12 +9293,12 @@ static TypeTableEntry ir_resolve_peer_types(IrAnalyze ira, AstNode *source_nod
9293	9293
9294	9294	if (convert_to_const_slice) {
9295	9295	assert(prev_inst->value.type->id == TypeTableEntryIdArray);
9296		TypeTableEntry *ptr_type = get_pointer_to_type_extra(
	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,
9299	9299	get_abi_alignment(ira->codegen, prev_inst->value.type->data.array.child_type),
9300	9300	0, 0);
9301		TypeTableEntry *slice_type = get_slice_type(ira->codegen, ptr_type);
	9301	ZigType *slice_type = get_slice_type(ira->codegen, ptr_type);
9302	9302	if (err_set_type != nullptr) {
9303	9303	return get_error_union_type(ira->codegen, err_set_type, slice_type);
9304	9304	} else {
...	...	@@ -9343,7 +9343,7 @@ static TypeTableEntry ir_resolve_peer_types(IrAnalyze ira, AstNode *source_nod
9343	9343	}
9344	9344	}
9345	9345
9346		static void ir_add_alloca(IrAnalyze ira, IrInstruction instruction, TypeTableEntry *type_entry) {
	9346	static void ir_add_alloca(IrAnalyze ira, IrInstruction instruction, ZigType *type_entry) {
9347	9347	if (type_has_bits(type_entry) && handle_is_ptr(type_entry)) {
9348	9348	FnTableEntry *fn_entry = exec_fn_entry(ira->new_irb.exec);
9349	9349	if (fn_entry != nullptr) {
...	...	@@ -9366,8 +9366,8 @@ static void copy_const_val(ConstExprValue dest, ConstExprValue src, bool same_
9366	9366
9367	9367	static bool eval_const_expr_implicit_cast(IrAnalyze ira, IrInstruction source_instr,
9368	9368	CastOp cast_op,
9369		ConstExprValue other_val, TypeTableEntry other_type,
9370		ConstExprValue const_val, TypeTableEntry new_type)
	9369	ConstExprValue other_val, ZigType other_type,
	9370	ConstExprValue const_val, ZigType new_type)
9371	9371	{
9372	9372	const_val->special = other_val->special;
9373	9373
...	...	@@ -9467,7 +9467,7 @@ static bool eval_const_expr_implicit_cast(IrAnalyze ira, IrInstruction source_
9467	9467	return true;
9468	9468	}
9469	9469	static IrInstruction ir_resolve_cast(IrAnalyze ira, IrInstruction source_instr, IrInstruction value,
9470		TypeTableEntry *wanted_type, CastOp cast_op, bool need_alloca)
	9470	ZigType *wanted_type, CastOp cast_op, bool need_alloca)
9471	9471	{
9472	9472	if ((instr_is_comptime(value) \|\| !type_has_bits(wanted_type)) &&
9473	9473	cast_op != CastOpResizeSlice && cast_op != CastOpBytesToSlice)
...	...	@@ -9491,7 +9491,7 @@ static IrInstruction ir_resolve_cast(IrAnalyze ira, IrInstruction *source_inst
9491	9491	}
9492	9492
9493	9493	static IrInstruction ir_resolve_ptr_of_array_to_unknown_len_ptr(IrAnalyze ira, IrInstruction *source_instr,
9494		IrInstruction value, TypeTableEntry wanted_type)
	9494	IrInstruction value, ZigType wanted_type)
9495	9495	{
9496	9496	assert(value->value.type->id == TypeTableEntryIdPointer);
9497	9497	wanted_type = adjust_ptr_align(ira->codegen, wanted_type, value->value.type->data.pointer.alignment);
...	...	@@ -9520,7 +9520,7 @@ static IrInstruction ir_resolve_ptr_of_array_to_unknown_len_ptr(IrAnalyze ira,
9520	9520	}
9521	9521
9522	9522	static IrInstruction ir_resolve_ptr_of_array_to_slice(IrAnalyze ira, IrInstruction *source_instr,
9523		IrInstruction value, TypeTableEntry wanted_type)
	9523	IrInstruction value, ZigType wanted_type)
9524	9524	{
9525	9525	wanted_type = adjust_slice_align(ira->codegen, wanted_type, value->value.type->data.pointer.alignment);
9526	9526
...	...	@@ -9530,7 +9530,7 @@ static IrInstruction ir_resolve_ptr_of_array_to_slice(IrAnalyze ira, IrInstruc
9530	9530	return ira->codegen->invalid_instruction;
9531	9531	if (pointee->special != ConstValSpecialRuntime) {
9532	9532	assert(value->value.type->id == TypeTableEntryIdPointer);
9533		TypeTableEntry *array_type = value->value.type->data.pointer.child_type;
	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;
9536	9536
...	...	@@ -9551,7 +9551,7 @@ static IrInstruction ir_resolve_ptr_of_array_to_slice(IrAnalyze ira, IrInstruc
9551	9551	return result;
9552	9552	}
9553	9553
9554		static bool is_container(TypeTableEntry *type) {
	9554	static bool is_container(ZigType *type) {
9555	9555	return type->id == TypeTableEntryIdStruct \|\|
9556	9556	type->id == TypeTableEntryIdEnum \|\|
9557	9557	type->id == TypeTableEntryIdUnion;
...	...	@@ -9630,7 +9630,7 @@ static void ir_finish_bb(IrAnalyze *ira) {
9630	9630	}
9631	9631	}
9632	9632
9633		static TypeTableEntry ir_unreach_error(IrAnalyze ira) {
	9633	static ZigType ir_unreach_error(IrAnalyze ira) {
9634	9634	ira->old_bb_index = SIZE_MAX;
9635	9635	ira->new_irb.exec->invalid = true;
9636	9636	return ira->codegen->builtin_types.entry_unreachable;
...	...	@@ -9653,7 +9653,7 @@ static bool ir_emit_backward_branch(IrAnalyze ira, IrInstruction source_instru
9653	9653	return true;
9654	9654	}
9655	9655
9656		static TypeTableEntry ir_inline_bb(IrAnalyze ira, IrInstruction source_instruction, IrBasicBlock old_bb) {
	9656	static ZigType ir_inline_bb(IrAnalyze ira, IrInstruction source_instruction, IrBasicBlock old_bb) {
9657	9657	if (old_bb->debug_id <= ira->old_irb.current_basic_block->debug_id) {
9658	9658	if (!ir_emit_backward_branch(ira, source_instruction))
9659	9659	return ir_unreach_error(ira);
...	...	@@ -9664,7 +9664,7 @@ static TypeTableEntry ir_inline_bb(IrAnalyze ira, IrInstruction *source_instru
9664	9664	return ira->codegen->builtin_types.entry_unreachable;
9665	9665	}
9666	9666
9667		static TypeTableEntry ir_finish_anal(IrAnalyze ira, TypeTableEntry *result_type) {
	9667	static ZigType ir_finish_anal(IrAnalyze ira, ZigType *result_type) {
9668	9668	if (result_type->id == TypeTableEntryIdUnreachable)
9669	9669	ir_finish_bb(ira);
9670	9670	return result_type;
...	...	@@ -9684,16 +9684,16 @@ static ConstExprValue ir_build_const_from(IrAnalyze ira, IrInstruction *old_in
9684	9684	return &new_instruction->value;
9685	9685	}
9686	9686
9687		static TypeTableEntry ir_analyze_void(IrAnalyze ira, IrInstruction *instruction) {
	9687	static ZigType ir_analyze_void(IrAnalyze ira, IrInstruction *instruction) {
9688	9688	ir_build_const_from(ira, instruction);
9689	9689	return ira->codegen->builtin_types.entry_void;
9690	9690	}
9691	9691
9692	9692	static IrInstruction ir_get_const_ptr(IrAnalyze ira, IrInstruction *instruction,
9693		ConstExprValue pointee, TypeTableEntry pointee_type,
	9693	ConstExprValue pointee, ZigType pointee_type,
9694	9694	ConstPtrMut ptr_mut, bool ptr_is_const, bool ptr_is_volatile, uint32_t ptr_align)
9695	9695	{
9696		TypeTableEntry *ptr_type = get_pointer_to_type_extra(ira->codegen, pointee_type,
	9696	ZigType *ptr_type = get_pointer_to_type_extra(ira->codegen, pointee_type,
9697	9697	ptr_is_const, ptr_is_volatile, PtrLenSingle, ptr_align, 0, 0);
9698	9698	IrInstruction *const_instr = ir_get_const(ira, instruction);
9699	9699	ConstExprValue *const_val = &const_instr->value;
...	...	@@ -9704,8 +9704,8 @@ static IrInstruction ir_get_const_ptr(IrAnalyze ira, IrInstruction *instructio
9704	9704	return const_instr;
9705	9705	}
9706	9706
9707		static TypeTableEntry ir_analyze_const_ptr(IrAnalyze ira, IrInstruction *instruction,
9708		ConstExprValue pointee, TypeTableEntry pointee_type,
	9707	static ZigType ir_analyze_const_ptr(IrAnalyze ira, IrInstruction *instruction,
	9708	ConstExprValue pointee, ZigType pointee_type,
9709	9709	ConstPtrMut ptr_mut, bool ptr_is_const, bool ptr_is_volatile)
9710	9710	{
9711	9711	IrInstruction *const_instr = ir_get_const_ptr(ira, instruction, pointee,
...	...	@@ -9715,7 +9715,7 @@ static TypeTableEntry ir_analyze_const_ptr(IrAnalyze ira, IrInstruction *instr
9715	9715	return const_instr->value.type;
9716	9716	}
9717	9717
9718		static TypeTableEntry ir_analyze_const_usize(IrAnalyze ira, IrInstruction *instruction, uint64_t value) {
	9718	static ZigType ir_analyze_const_usize(IrAnalyze ira, IrInstruction *instruction, uint64_t value) {
9719	9719	ConstExprValue *const_val = ir_build_const_from(ira, instruction);
9720	9720	bigint_init_unsigned(&const_val->data.x_bigint, value);
9721	9721	return ira->codegen->builtin_types.entry_usize;
...	...	@@ -9748,7 +9748,7 @@ static ConstExprValue ir_resolve_const(IrAnalyze ira, IrInstruction *value, Un
9748	9748	}
9749	9749
9750	9750	IrInstruction ir_eval_const_value(CodeGen codegen, Scope scope, AstNode node,
9751		TypeTableEntry expected_type, size_t backward_branch_count, size_t backward_branch_quota,
	9751	ZigType expected_type, size_t backward_branch_count, size_t backward_branch_quota,
9752	9752	FnTableEntry fn_entry, Buf c_import_buf, AstNode source_node, Buf exec_name,
9753	9753	IrExecutable *parent_exec)
9754	9754	{
...	...	@@ -9786,7 +9786,7 @@ IrInstruction ir_eval_const_value(CodeGen codegen, Scope scope, AstNode node
9786	9786	analyzed_executable->backward_branch_count = backward_branch_count;
9787	9787	analyzed_executable->backward_branch_quota = backward_branch_quota;
9788	9788	analyzed_executable->begin_scope = scope;
9789		TypeTableEntry *result_type = ir_analyze(codegen, ir_executable, analyzed_executable, expected_type, node);
	9789	ZigType *result_type = ir_analyze(codegen, ir_executable, analyzed_executable, expected_type, node);
9790	9790	if (type_is_invalid(result_type))
9791	9791	return codegen->invalid_instruction;
9792	9792
...	...	@@ -9799,7 +9799,7 @@ IrInstruction ir_eval_const_value(CodeGen codegen, Scope scope, AstNode node
9799	9799	return ir_exec_const_result(codegen, analyzed_executable);
9800	9800	}
9801	9801
9802		static TypeTableEntry ir_resolve_type(IrAnalyze ira, IrInstruction *type_value) {
	9802	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
...	...	@@ -9837,11 +9837,11 @@ static FnTableEntry ir_resolve_fn(IrAnalyze ira, IrInstruction *fn_value) {
9837	9837	return const_val->data.x_ptr.data.fn.fn_entry;
9838	9838	}
9839	9839
9840		static IrInstruction ir_analyze_maybe_wrap(IrAnalyze ira, IrInstruction source_instr, IrInstruction value, TypeTableEntry *wanted_type) {
	9840	static IrInstruction ir_analyze_maybe_wrap(IrAnalyze ira, IrInstruction source_instr, IrInstruction value, ZigType *wanted_type) {
9841	9841	assert(wanted_type->id == TypeTableEntryIdOptional);
9842	9842
9843	9843	if (instr_is_comptime(value)) {
9844		TypeTableEntry *payload_type = wanted_type->data.maybe.child_type;
	9844	ZigType *payload_type = wanted_type->data.maybe.child_type;
9845	9845	IrInstruction *casted_payload = ir_implicit_cast(ira, value, payload_type);
9846	9846	if (type_is_invalid(casted_payload->value.type))
9847	9847	return ira->codegen->invalid_instruction;
...	...	@@ -9870,12 +9870,12 @@ static IrInstruction ir_analyze_maybe_wrap(IrAnalyze ira, IrInstruction *sourc
9870	9870	}
9871	9871
9872	9872	static IrInstruction ir_analyze_err_wrap_payload(IrAnalyze ira, IrInstruction *source_instr,
9873		IrInstruction value, TypeTableEntry wanted_type)
	9873	IrInstruction value, ZigType wanted_type)
9874	9874	{
9875	9875	assert(wanted_type->id == TypeTableEntryIdErrorUnion);
9876	9876
9877	9877	if (instr_is_comptime(value)) {
9878		TypeTableEntry *payload_type = wanted_type->data.error_union.payload_type;
	9878	ZigType *payload_type = wanted_type->data.error_union.payload_type;
9879	9879	IrInstruction *casted_payload = ir_implicit_cast(ira, value, payload_type);
9880	9880	if (type_is_invalid(casted_payload->value.type))
9881	9881	return ira->codegen->invalid_instruction;
...	...	@@ -9901,7 +9901,7 @@ static IrInstruction ir_analyze_err_wrap_payload(IrAnalyze ira, IrInstruction
9901	9901	}
9902	9902
9903	9903	static IrInstruction ir_analyze_err_set_cast(IrAnalyze ira, IrInstruction source_instr, IrInstruction value,
9904		TypeTableEntry *wanted_type)
	9904	ZigType *wanted_type)
9905	9905	{
9906	9906	assert(value->value.type->id == TypeTableEntryIdErrorSet);
9907	9907	assert(wanted_type->id == TypeTableEntryIdErrorSet);
...	...	@@ -9943,7 +9943,7 @@ static IrInstruction ir_analyze_err_set_cast(IrAnalyze ira, IrInstruction *sou
9943	9943	return result;
9944	9944	}
9945	9945
9946		static IrInstruction ir_analyze_err_wrap_code(IrAnalyze ira, IrInstruction source_instr, IrInstruction value, TypeTableEntry *wanted_type) {
	9946	static IrInstruction ir_analyze_err_wrap_code(IrAnalyze ira, IrInstruction source_instr, IrInstruction value, ZigType *wanted_type) {
9947	9947	assert(wanted_type->id == TypeTableEntryIdErrorUnion);
9948	9948
9949	9949	IrInstruction *casted_value = ir_implicit_cast(ira, value, wanted_type->data.error_union.err_set_type);
...	...	@@ -9970,7 +9970,7 @@ static IrInstruction ir_analyze_err_wrap_code(IrAnalyze ira, IrInstruction *so
9970	9970	}
9971	9971
9972	9972	static IrInstruction ir_analyze_cast_ref(IrAnalyze ira, IrInstruction *source_instr,
9973		IrInstruction value, TypeTableEntry wanted_type)
	9973	IrInstruction value, ZigType wanted_type)
9974	9974	{
9975	9975	if (instr_is_comptime(value)) {
9976	9976	ConstExprValue *val = ir_resolve_const(ira, value, UndefBad);
...	...	@@ -9994,7 +9994,7 @@ static IrInstruction ir_analyze_cast_ref(IrAnalyze ira, IrInstruction *source_
9994	9994	source_instr->source_node, value, true, false);
9995	9995	new_instruction->value.type = wanted_type;
9996	9996
9997		TypeTableEntry *child_type = wanted_type->data.pointer.child_type;
	9997	ZigType *child_type = wanted_type->data.pointer.child_type;
9998	9998	if (type_has_bits(child_type)) {
9999	9999	FnTableEntry *fn_entry = exec_fn_entry(ira->new_irb.exec);
10000	10000	assert(fn_entry);
...	...	@@ -10005,7 +10005,7 @@ static IrInstruction ir_analyze_cast_ref(IrAnalyze ira, IrInstruction *source_
10005	10005	}
10006	10006	}
10007	10007
10008		static IrInstruction ir_analyze_null_to_maybe(IrAnalyze ira, IrInstruction source_instr, IrInstruction value, TypeTableEntry *wanted_type) {
	10008	static IrInstruction ir_analyze_null_to_maybe(IrAnalyze ira, IrInstruction source_instr, IrInstruction value, ZigType *wanted_type) {
10009	10009	assert(wanted_type->id == TypeTableEntryIdOptional);
10010	10010	assert(instr_is_comptime(value));
10011	10011
...	...	@@ -10039,7 +10039,7 @@ static IrInstruction ir_get_ref(IrAnalyze ira, IrInstruction *source_instructi
10039	10039	get_abi_alignment(ira->codegen, value->value.type));
10040	10040	}
10041	10041
10042		TypeTableEntry *ptr_type = get_pointer_to_type_extra(ira->codegen, value->value.type,
	10042	ZigType *ptr_type = get_pointer_to_type_extra(ira->codegen, value->value.type,
10043	10043	is_const, is_volatile, PtrLenSingle, get_abi_alignment(ira->codegen, value->value.type), 0, 0);
10044	10044	IrInstruction *new_instruction = ir_build_ref(&ira->new_irb, source_instruction->scope,
10045	10045	source_instruction->source_node, value, is_const, is_volatile);
...	...	@@ -10054,7 +10054,7 @@ static IrInstruction ir_get_ref(IrAnalyze ira, IrInstruction *source_instructi
10054	10054	}
10055	10055
10056	10056	static IrInstruction ir_analyze_array_to_slice(IrAnalyze ira, IrInstruction *source_instr,
10057		IrInstruction array_arg, TypeTableEntry wanted_type)
	10057	IrInstruction array_arg, ZigType wanted_type)
10058	10058	{
10059	10059	assert(is_slice(wanted_type));
10060	10060	// In this function we honor the const-ness of wanted_type, because
...	...	@@ -10068,7 +10068,7 @@ static IrInstruction ir_analyze_array_to_slice(IrAnalyze ira, IrInstruction *s
10068	10068	} else {
10069	10069	array = array_arg;
10070	10070	}
10071		TypeTableEntry *array_type = array->value.type;
	10071	ZigType *array_type = array->value.type;
10072	10072	assert(array_type->id == TypeTableEntryIdArray);
10073	10073
10074	10074	if (instr_is_comptime(array)) {
...	...	@@ -10100,12 +10100,12 @@ static IrInstruction ir_analyze_array_to_slice(IrAnalyze ira, IrInstruction *s
10100	10100	}
10101	10101
10102	10102	static IrInstruction ir_analyze_enum_to_int(IrAnalyze ira, IrInstruction *source_instr,
10103		IrInstruction target, TypeTableEntry wanted_type)
	10103	IrInstruction target, ZigType wanted_type)
10104	10104	{
10105	10105	Error err;
10106	10106	assert(wanted_type->id == TypeTableEntryIdInt);
10107	10107
10108		TypeTableEntry *actual_type = target->value.type;
	10108	ZigType *actual_type = target->value.type;
10109	10109	if ((err = ensure_complete_type(ira->codegen, actual_type)))
10110	10110	return ira->codegen->invalid_instruction;
10111	10111
...	...	@@ -10136,7 +10136,7 @@ static IrInstruction ir_analyze_enum_to_int(IrAnalyze ira, IrInstruction *sour
10136	10136	}
10137	10137
10138	10138	static IrInstruction ir_analyze_union_to_tag(IrAnalyze ira, IrInstruction *source_instr,
10139		IrInstruction target, TypeTableEntry wanted_type)
	10139	IrInstruction target, ZigType wanted_type)
10140	10140	{
10141	10141	assert(target->value.type->id == TypeTableEntryIdUnion);
10142	10142	assert(wanted_type->id == TypeTableEntryIdEnum);
...	...	@@ -10161,7 +10161,7 @@ static IrInstruction ir_analyze_union_to_tag(IrAnalyze ira, IrInstruction *sou
10161	10161	}
10162	10162
10163	10163	static IrInstruction ir_analyze_undefined_to_anything(IrAnalyze ira, IrInstruction *source_instr,
10164		IrInstruction target, TypeTableEntry wanted_type)
	10164	IrInstruction target, ZigType wanted_type)
10165	10165	{
10166	10166	IrInstruction *result = ir_create_const(&ira->new_irb, source_instr->scope,
10167	10167	source_instr->source_node, wanted_type);
...	...	@@ -10170,7 +10170,7 @@ static IrInstruction ir_analyze_undefined_to_anything(IrAnalyze ira, IrInstruc
10170	10170	}
10171	10171
10172	10172	static IrInstruction ir_analyze_enum_to_union(IrAnalyze ira, IrInstruction *source_instr,
10173		IrInstruction target, TypeTableEntry wanted_type)
	10173	IrInstruction target, ZigType wanted_type)
10174	10174	{
10175	10175	Error err;
10176	10176	assert(wanted_type->id == TypeTableEntryIdUnion);
...	...	@@ -10229,7 +10229,7 @@ static IrInstruction ir_analyze_enum_to_union(IrAnalyze ira, IrInstruction *so
10229	10229	}
10230	10230
10231	10231	static IrInstruction ir_analyze_widen_or_shorten(IrAnalyze ira, IrInstruction *source_instr,
10232		IrInstruction target, TypeTableEntry wanted_type)
	10232	IrInstruction target, ZigType wanted_type)
10233	10233	{
10234	10234	assert(wanted_type->id == TypeTableEntryIdInt \|\| wanted_type->id == TypeTableEntryIdFloat);
10235	10235
...	...	@@ -10270,12 +10270,12 @@ static IrInstruction ir_analyze_widen_or_shorten(IrAnalyze ira, IrInstruction
10270	10270	}
10271	10271
10272	10272	static IrInstruction ir_analyze_int_to_enum(IrAnalyze ira, IrInstruction *source_instr,
10273		IrInstruction target, TypeTableEntry wanted_type)
	10273	IrInstruction target, ZigType wanted_type)
10274	10274	{
10275	10275	Error err;
10276	10276	assert(wanted_type->id == TypeTableEntryIdEnum);
10277	10277
10278		TypeTableEntry *actual_type = target->value.type;
	10278	ZigType *actual_type = target->value.type;
10279	10279
10280	10280	if ((err = ensure_complete_type(ira->codegen, wanted_type)))
10281	10281	return ira->codegen->invalid_instruction;
...	...	@@ -10320,7 +10320,7 @@ static IrInstruction ir_analyze_int_to_enum(IrAnalyze ira, IrInstruction *sour
10320	10320	}
10321	10321
10322	10322	static IrInstruction ir_analyze_number_to_literal(IrAnalyze ira, IrInstruction *source_instr,
10323		IrInstruction target, TypeTableEntry wanted_type)
	10323	IrInstruction target, ZigType wanted_type)
10324	10324	{
10325	10325	ConstExprValue *val = ir_resolve_const(ira, target, UndefBad);
10326	10326	if (!val)
...	...	@@ -10339,7 +10339,7 @@ static IrInstruction ir_analyze_number_to_literal(IrAnalyze ira, IrInstruction
10339	10339	}
10340	10340
10341	10341	static IrInstruction ir_analyze_int_to_err(IrAnalyze ira, IrInstruction source_instr, IrInstruction target,
10342		TypeTableEntry *wanted_type)
	10342	ZigType *wanted_type)
10343	10343	{
10344	10344	assert(target->value.type->id == TypeTableEntryIdInt);
10345	10345	assert(!target->value.type->data.integral.is_signed);
...	...	@@ -10404,11 +10404,11 @@ static IrInstruction ir_analyze_int_to_err(IrAnalyze ira, IrInstruction *sourc
10404	10404	}
10405	10405
10406	10406	static IrInstruction ir_analyze_err_to_int(IrAnalyze ira, IrInstruction source_instr, IrInstruction target,
10407		TypeTableEntry *wanted_type)
	10407	ZigType *wanted_type)
10408	10408	{
10409	10409	assert(wanted_type->id == TypeTableEntryIdInt);
10410	10410
10411		TypeTableEntry *err_type = target->value.type;
	10411	ZigType *err_type = target->value.type;
10412	10412
10413	10413	if (instr_is_comptime(target)) {
10414	10414	ConstExprValue *val = ir_resolve_const(ira, target, UndefBad);
...	...	@@ -10442,7 +10442,7 @@ static IrInstruction ir_analyze_err_to_int(IrAnalyze ira, IrInstruction *sourc
10442	10442	return result;
10443	10443	}
10444	10444
10445		TypeTableEntry *err_set_type;
	10445	ZigType *err_set_type;
10446	10446	if (err_type->id == TypeTableEntryIdErrorUnion) {
10447	10447	err_set_type = err_type->data.error_union.err_set_type;
10448	10448	} else if (err_type->id == TypeTableEntryIdErrorSet) {
...	...	@@ -10484,11 +10484,11 @@ static IrInstruction ir_analyze_err_to_int(IrAnalyze ira, IrInstruction *sourc
10484	10484	}
10485	10485
10486	10486	static IrInstruction ir_analyze_ptr_to_array(IrAnalyze ira, IrInstruction source_instr, IrInstruction target,
10487		TypeTableEntry *wanted_type)
	10487	ZigType *wanted_type)
10488	10488	{
10489	10489	assert(wanted_type->id == TypeTableEntryIdPointer);
10490	10490	wanted_type = adjust_ptr_align(ira->codegen, wanted_type, target->value.type->data.pointer.alignment);
10491		TypeTableEntry *array_type = wanted_type->data.pointer.child_type;
	10491	ZigType *array_type = wanted_type->data.pointer.child_type;
10492	10492	assert(array_type->id == TypeTableEntryIdArray);
10493	10493	assert(array_type->data.array.len == 1);
10494	10494
...	...	@@ -10620,10 +10620,10 @@ static void report_recursive_error(IrAnalyze ira, AstNode source_node, ConstCa
10620	10620	}
10621	10621
10622	10622	static IrInstruction ir_analyze_cast(IrAnalyze ira, IrInstruction *source_instr,
10623		TypeTableEntry wanted_type, IrInstruction value)
	10623	ZigType wanted_type, IrInstruction value)
10624	10624	{
10625	10625	Error err;
10626		TypeTableEntry *actual_type = value->value.type;
	10626	ZigType *actual_type = value->value.type;
10627	10627	AstNode *source_node = source_instr->source_node;
10628	10628
10629	10629	if (type_is_invalid(wanted_type) \|\| type_is_invalid(actual_type)) {
...	...	@@ -10665,7 +10665,7 @@ static IrInstruction ir_analyze_cast(IrAnalyze ira, IrInstruction *source_inst
10665	10665
10666	10666	// cast from [N]T to []const T
10667	10667	if (is_slice(wanted_type) && actual_type->id == TypeTableEntryIdArray) {
10668		TypeTableEntry *ptr_type = wanted_type->data.structure.fields[slice_ptr_index].type_entry;
	10668	ZigType *ptr_type = wanted_type->data.structure.fields[slice_ptr_index].type_entry;
10669	10669	assert(ptr_type->id == TypeTableEntryIdPointer);
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,
...	...	@@ -10681,10 +10681,10 @@ static IrInstruction ir_analyze_cast(IrAnalyze ira, IrInstruction *source_inst
10681	10681	actual_type->data.pointer.is_const &&
10682	10682	actual_type->data.pointer.child_type->id == TypeTableEntryIdArray)
10683	10683	{
10684		TypeTableEntry *ptr_type = wanted_type->data.structure.fields[slice_ptr_index].type_entry;
	10684	ZigType *ptr_type = wanted_type->data.structure.fields[slice_ptr_index].type_entry;
10685	10685	assert(ptr_type->id == TypeTableEntryIdPointer);
10686	10686
10687		TypeTableEntry *array_type = actual_type->data.pointer.child_type;
	10687	ZigType *array_type = actual_type->data.pointer.child_type;
10688	10688
10689	10689	if ((ptr_type->data.pointer.is_const \|\| array_type->data.array.len == 0) &&
10690	10690	types_match_const_cast_only(ira, ptr_type->data.pointer.child_type, array_type->data.array.child_type,
...	...	@@ -10700,7 +10700,7 @@ static IrInstruction ir_analyze_cast(IrAnalyze ira, IrInstruction *source_inst
10700	10700	is_slice(wanted_type->data.pointer.child_type) &&
10701	10701	actual_type->id == TypeTableEntryIdArray)
10702	10702	{
10703		TypeTableEntry *ptr_type =
	10703	ZigType *ptr_type =
10704	10704	wanted_type->data.pointer.child_type->data.structure.fields[slice_ptr_index].type_entry;
10705	10705	assert(ptr_type->id == TypeTableEntryIdPointer);
10706	10706	if ((ptr_type->data.pointer.is_const \|\| actual_type->data.array.len == 0) &&
...	...	@@ -10724,7 +10724,7 @@ static IrInstruction ir_analyze_cast(IrAnalyze ira, IrInstruction *source_inst
10724	10724	is_slice(wanted_type->data.maybe.child_type) &&
10725	10725	actual_type->id == TypeTableEntryIdArray)
10726	10726	{
10727		TypeTableEntry *ptr_type =
	10727	ZigType *ptr_type =
10728	10728	wanted_type->data.maybe.child_type->data.structure.fields[slice_ptr_index].type_entry;
10729	10729	assert(ptr_type->id == TypeTableEntryIdPointer);
10730	10730	if ((ptr_type->data.pointer.is_const \|\| actual_type->data.array.len == 0) &&
...	...	@@ -10763,7 +10763,7 @@ static IrInstruction ir_analyze_cast(IrAnalyze ira, IrInstruction *source_inst
10763	10763	actual_type->data.pointer.ptr_len == PtrLenSingle &&
10764	10764	actual_type->data.pointer.child_type->id == TypeTableEntryIdArray)
10765	10765	{
10766		TypeTableEntry *slice_ptr_type = wanted_type->data.structure.fields[slice_ptr_index].type_entry;
	10766	ZigType *slice_ptr_type = wanted_type->data.structure.fields[slice_ptr_index].type_entry;
10767	10767	assert(slice_ptr_type->id == TypeTableEntryIdPointer);
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,
...	...	@@ -10777,7 +10777,7 @@ static IrInstruction ir_analyze_cast(IrAnalyze ira, IrInstruction *source_inst
10777	10777	// cast from T to ?T
10778	10778	// note that the T to ?T case is handled via the "ConstCastOnly" mechanism
10779	10779	if (wanted_type->id == TypeTableEntryIdOptional) {
10780		TypeTableEntry *wanted_child_type = wanted_type->data.maybe.child_type;
	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	{
...	...	@@ -10850,7 +10850,7 @@ static IrInstruction ir_analyze_cast(IrAnalyze ira, IrInstruction *source_inst
10850	10850	is_slice(wanted_type->data.error_union.payload_type) &&
10851	10851	actual_type->id == TypeTableEntryIdArray)
10852	10852	{
10853		TypeTableEntry *ptr_type =
	10853	ZigType *ptr_type =
10854	10854	wanted_type->data.error_union.payload_type->data.structure.fields[slice_ptr_index].type_entry;
10855	10855	assert(ptr_type->id == TypeTableEntryIdPointer);
10856	10856	if ((ptr_type->data.pointer.is_const \|\| actual_type->data.array.len == 0) &&
...	...	@@ -10881,7 +10881,7 @@ static IrInstruction ir_analyze_cast(IrAnalyze ira, IrInstruction *source_inst
10881	10881	wanted_type->data.error_union.payload_type->id == TypeTableEntryIdOptional &&
10882	10882	actual_type->id != TypeTableEntryIdOptional)
10883	10883	{
10884		TypeTableEntry *wanted_child_type = wanted_type->data.error_union.payload_type->data.maybe.child_type;
	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	10886	actual_type->id == TypeTableEntryIdNull \|\|
10887	10887	actual_type->id == TypeTableEntryIdComptimeInt \|\|
...	...	@@ -10983,7 +10983,7 @@ static IrInstruction ir_analyze_cast(IrAnalyze ira, IrInstruction *source_inst
10983	10983
10984	10984	// enum to &const union which has the enum as the tag type
10985	10985	if (actual_type->id == TypeTableEntryIdEnum && wanted_type->id == TypeTableEntryIdPointer) {
10986		TypeTableEntry *union_type = wanted_type->data.pointer.child_type;
	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)
10989	10989	{
...	...	@@ -11008,7 +11008,7 @@ static IrInstruction ir_analyze_cast(IrAnalyze ira, IrInstruction *source_inst
11008	11008	if (wanted_type->id == TypeTableEntryIdPointer && wanted_type->data.pointer.ptr_len == PtrLenSingle &&
11009	11009	actual_type->id == TypeTableEntryIdPointer && actual_type->data.pointer.ptr_len == PtrLenSingle)
11010	11010	{
11011		TypeTableEntry *array_type = wanted_type->data.pointer.child_type;
	11011	ZigType *array_type = wanted_type->data.pointer.child_type;
11012	11012	if (array_type->id == TypeTableEntryIdArray && 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,
...	...	@@ -11049,7 +11049,7 @@ static IrInstruction ir_analyze_cast(IrAnalyze ira, IrInstruction *source_inst
11049	11049
11050	11050	// cast from something to const pointer of it
11051	11051	if (!type_requires_comptime(actual_type)) {
11052		TypeTableEntry *const_ptr_actual = get_pointer_to_type(ira->codegen, actual_type, true);
	11052	ZigType *const_ptr_actual = get_pointer_to_type(ira->codegen, actual_type, true);
11053	11053	if (types_match_const_cast_only(ira, wanted_type, const_ptr_actual, source_node, false).id == ConstCastResultIdOk) {
11054	11054	return ir_analyze_cast_ref(ira, source_instr, value, wanted_type);
11055	11055	}
...	...	@@ -11063,7 +11063,7 @@ static IrInstruction ir_analyze_cast(IrAnalyze ira, IrInstruction *source_inst
11063	11063	return ira->codegen->invalid_instruction;
11064	11064	}
11065	11065
11066		static IrInstruction ir_implicit_cast(IrAnalyze ira, IrInstruction value, TypeTableEntry expected_type) {
	11066	static IrInstruction ir_implicit_cast(IrAnalyze ira, IrInstruction value, ZigType expected_type) {
11067	11067	assert(value);
11068	11068	assert(value != ira->codegen->invalid_instruction);
11069	11069	assert(!expected_type \|\| !type_is_invalid(expected_type));
...	...	@@ -11080,11 +11080,11 @@ static IrInstruction ir_implicit_cast(IrAnalyze ira, IrInstruction *value, Typ
11080	11080	}
11081	11081
11082	11082	static IrInstruction ir_get_deref(IrAnalyze ira, IrInstruction source_instruction, IrInstruction ptr) {
11083		TypeTableEntry *type_entry = ptr->value.type;
	11083	ZigType *type_entry = ptr->value.type;
11084	11084	if (type_is_invalid(type_entry)) {
11085	11085	return ira->codegen->invalid_instruction;
11086	11086	} else if (type_entry->id == TypeTableEntryIdPointer) {
11087		TypeTableEntry *child_type = type_entry->data.pointer.child_type;
	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 \|\|
11090	11090	ptr->value.data.x_ptr.mut == ConstPtrMutComptimeVar)
...	...	@@ -11114,7 +11114,7 @@ static IrInstruction ir_get_deref(IrAnalyze ira, IrInstruction *source_instruc
11114	11114	}
11115	11115	}
11116	11116
11117		static TypeTableEntry ir_analyze_ref(IrAnalyze ira, IrInstruction source_instruction, IrInstruction value,
	11117	static ZigType ir_analyze_ref(IrAnalyze ira, IrInstruction source_instruction, IrInstruction value,
11118	11118	bool is_const, bool is_volatile)
11119	11119	{
11120	11120	IrInstruction *result = ir_get_ref(ira, source_instruction, value, is_const, is_volatile);
...	...	@@ -11149,7 +11149,7 @@ static bool ir_resolve_align(IrAnalyze ira, IrInstruction value, uint32_t *out
11149	11149	return true;
11150	11150	}
11151	11151
11152		static bool ir_resolve_unsigned(IrAnalyze ira, IrInstruction value, TypeTableEntry int_type, uint64_t out) {
	11152	static bool ir_resolve_unsigned(IrAnalyze ira, IrInstruction value, ZigType int_type, uint64_t out) {
11153	11153	if (type_is_invalid(value->value.type))
11154	11154	return false;
11155	11155
...	...	@@ -11199,7 +11199,7 @@ static bool ir_resolve_atomic_order(IrAnalyze ira, IrInstruction value, Atomic
11199	11199
11200	11200	ConstExprValue *atomic_order_val = get_builtin_value(ira->codegen, "AtomicOrder");
11201	11201	assert(atomic_order_val->type->id == TypeTableEntryIdMetaType);
11202		TypeTableEntry *atomic_order_type = atomic_order_val->data.x_type;
	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);
11205	11205	if (type_is_invalid(casted_value->value.type))
...	...	@@ -11219,7 +11219,7 @@ static bool ir_resolve_atomic_rmw_op(IrAnalyze ira, IrInstruction value, Atomi
11219	11219
11220	11220	ConstExprValue *atomic_rmw_op_val = get_builtin_value(ira->codegen, "AtomicRmwOp");
11221	11221	assert(atomic_rmw_op_val->type->id == TypeTableEntryIdMetaType);
11222		TypeTableEntry *atomic_rmw_op_type = atomic_rmw_op_val->data.x_type;
	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);
11225	11225	if (type_is_invalid(casted_value->value.type))
...	...	@@ -11239,7 +11239,7 @@ static bool ir_resolve_global_linkage(IrAnalyze ira, IrInstruction value, Glob
11239	11239
11240	11240	ConstExprValue *global_linkage_val = get_builtin_value(ira->codegen, "GlobalLinkage");
11241	11241	assert(global_linkage_val->type->id == TypeTableEntryIdMetaType);
11242		TypeTableEntry *global_linkage_type = global_linkage_val->data.x_type;
	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);
11245	11245	if (type_is_invalid(casted_value->value.type))
...	...	@@ -11259,7 +11259,7 @@ static bool ir_resolve_float_mode(IrAnalyze ira, IrInstruction value, FloatMod
11259	11259
11260	11260	ConstExprValue *float_mode_val = get_builtin_value(ira->codegen, "FloatMode");
11261	11261	assert(float_mode_val->type->id == TypeTableEntryIdMetaType);
11262		TypeTableEntry *float_mode_type = float_mode_val->data.x_type;
	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);
11265	11265	if (type_is_invalid(casted_value->value.type))
...	...	@@ -11278,10 +11278,10 @@ static Buf ir_resolve_str(IrAnalyze ira, IrInstruction *value) {
11278	11278	if (type_is_invalid(value->value.type))
11279	11279	return nullptr;
11280	11280
11281		TypeTableEntry *ptr_type = get_pointer_to_type_extra(ira->codegen, ira->codegen->builtin_types.entry_u8,
	11281	ZigType *ptr_type = get_pointer_to_type_extra(ira->codegen, ira->codegen->builtin_types.entry_u8,
11282	11282	true, false, PtrLenUnknown,
11283	11283	get_abi_alignment(ira->codegen, ira->codegen->builtin_types.entry_u8), 0, 0);
11284		TypeTableEntry *str_type = get_slice_type(ira->codegen, ptr_type);
	11284	ZigType *str_type = get_slice_type(ira->codegen, ptr_type);
11285	11285	IrInstruction *casted_value = ir_implicit_cast(ira, value, str_type);
11286	11286	if (type_is_invalid(casted_value->value.type))
11287	11287	return nullptr;
...	...	@@ -11314,7 +11314,7 @@ static Buf ir_resolve_str(IrAnalyze ira, IrInstruction *value) {
11314	11314	return result;
11315	11315	}
11316	11316
11317		static TypeTableEntry ir_analyze_instruction_add_implicit_return_type(IrAnalyze ira,
	11317	static ZigType ir_analyze_instruction_add_implicit_return_type(IrAnalyze ira,
11318	11318	IrInstructionAddImplicitReturnType *instruction)
11319	11319	{
11320	11320	IrInstruction *value = instruction->value->other;
...	...	@@ -11328,7 +11328,7 @@ static TypeTableEntry *ir_analyze_instruction_add_implicit_return_type(IrAnalyze
11328	11328	return out_val->type;
11329	11329	}
11330	11330
11331		static TypeTableEntry ir_analyze_instruction_return(IrAnalyze ira,
	11331	static ZigType ir_analyze_instruction_return(IrAnalyze ira,
11332	11332	IrInstructionReturn *return_instruction)
11333	11333	{
11334	11334	IrInstruction *value = return_instruction->value->other;
...	...	@@ -11353,13 +11353,13 @@ static TypeTableEntry ir_analyze_instruction_return(IrAnalyze ira,
11353	11353	return ir_finish_anal(ira, result->value.type);
11354	11354	}
11355	11355
11356		static TypeTableEntry ir_analyze_instruction_const(IrAnalyze ira, IrInstructionConst *const_instruction) {
	11356	static ZigType ir_analyze_instruction_const(IrAnalyze ira, IrInstructionConst *const_instruction) {
11357	11357	ConstExprValue *out_val = ir_build_const_from(ira, &const_instruction->base);
11358	11358	*out_val = const_instruction->base.value;
11359	11359	return const_instruction->base.value.type;
11360	11360	}
11361	11361
11362		static TypeTableEntry ir_analyze_bin_op_bool(IrAnalyze ira, IrInstructionBinOp *bin_op_instruction) {
	11362	static ZigType ir_analyze_bin_op_bool(IrAnalyze ira, IrInstructionBinOp *bin_op_instruction) {
11363	11363	IrInstruction *op1 = bin_op_instruction->op1->other;
11364	11364	if (type_is_invalid(op1->value.type))
11365	11365	return ira->codegen->builtin_types.entry_invalid;
...	...	@@ -11368,7 +11368,7 @@ static TypeTableEntry ir_analyze_bin_op_bool(IrAnalyze ira, IrInstructionBinOp
11368	11368	if (type_is_invalid(op2->value.type))
11369	11369	return ira->codegen->builtin_types.entry_invalid;
11370	11370
11371		TypeTableEntry *bool_type = ira->codegen->builtin_types.entry_bool;
	11371	ZigType *bool_type = ira->codegen->builtin_types.entry_bool;
11372	11372
11373	11373	IrInstruction *casted_op1 = ir_implicit_cast(ira, op1, bool_type);
11374	11374	if (casted_op1 == ira->codegen->invalid_instruction)
...	...	@@ -11433,7 +11433,7 @@ static bool optional_value_is_null(ConstExprValue *val) {
11433	11433	}
11434	11434	}
11435	11435
11436		static TypeTableEntry ir_analyze_bin_op_cmp(IrAnalyze ira, IrInstructionBinOp *bin_op_instruction) {
	11436	static ZigType ir_analyze_bin_op_cmp(IrAnalyze ira, IrInstructionBinOp *bin_op_instruction) {
11437	11437	Error err;
11438	11438	IrInstruction *op1 = bin_op_instruction->op1->other;
11439	11439	IrInstruction *op2 = bin_op_instruction->op2->other;
...	...	@@ -11486,7 +11486,7 @@ static TypeTableEntry ir_analyze_bin_op_cmp(IrAnalyze ira, IrInstructionBinOp
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;
11488	11488	}
11489		TypeTableEntry *intersect_type = get_error_set_intersection(ira, op1->value.type, op2->value.type, source_node);
	11489	ZigType *intersect_type = get_error_set_intersection(ira, op1->value.type, op2->value.type, source_node);
11490	11490	if (type_is_invalid(intersect_type)) {
11491	11491	return ira->codegen->builtin_types.entry_invalid;
11492	11492	}
...	...	@@ -11567,7 +11567,7 @@ static TypeTableEntry ir_analyze_bin_op_cmp(IrAnalyze ira, IrInstructionBinOp
11567	11567	}
11568	11568
11569	11569	IrInstruction *instructions[] = {op1, op2};
11570		TypeTableEntry *resolved_type = ir_resolve_peer_types(ira, source_node, nullptr, instructions, 2);
	11570	ZigType *resolved_type = ir_resolve_peer_types(ira, source_node, nullptr, instructions, 2);
11571	11571	if (type_is_invalid(resolved_type))
11572	11572	return resolved_type;
11573	11573	if ((err = type_ensure_zero_bits_known(ira->codegen, resolved_type)))
...	...	@@ -11705,7 +11705,7 @@ static TypeTableEntry ir_analyze_bin_op_cmp(IrAnalyze ira, IrInstructionBinOp
11705	11705	return ira->codegen->builtin_types.entry_bool;
11706	11706	}
11707	11707
11708		static int ir_eval_math_op(TypeTableEntry type_entry, ConstExprValue op1_val,
	11708	static int ir_eval_math_op(ZigType type_entry, ConstExprValue op1_val,
11709	11709	IrBinOp op_id, ConstExprValue op2_val, ConstExprValue out_val)
11710	11710	{
11711	11711	bool is_int;
...	...	@@ -11885,7 +11885,7 @@ static int ir_eval_math_op(TypeTableEntry type_entry, ConstExprValue op1_val,
11885	11885	return 0;
11886	11886	}
11887	11887
11888		static TypeTableEntry ir_analyze_bit_shift(IrAnalyze ira, IrInstructionBinOp *bin_op_instruction) {
	11888	static ZigType ir_analyze_bit_shift(IrAnalyze ira, IrInstructionBinOp *bin_op_instruction) {
11889	11889	IrInstruction *op1 = bin_op_instruction->op1->other;
11890	11890	if (type_is_invalid(op1->value.type))
11891	11891	return ira->codegen->builtin_types.entry_invalid;
...	...	@@ -11917,7 +11917,7 @@ static TypeTableEntry ir_analyze_bit_shift(IrAnalyze ira, IrInstructionBinOp *
11917	11917	return ira->codegen->builtin_types.entry_invalid;
11918	11918	}
11919	11919	} else {
11920		TypeTableEntry *shift_amt_type = get_smallest_unsigned_int_type(ira->codegen,
	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	11923	op2->value.type->id == TypeTableEntryIdComptimeInt) {
...	...	@@ -11985,7 +11985,7 @@ static TypeTableEntry ir_analyze_bit_shift(IrAnalyze ira, IrInstructionBinOp *
11985	11985	return op1->value.type;
11986	11986	}
11987	11987
11988		static TypeTableEntry ir_analyze_bin_op_math(IrAnalyze ira, IrInstructionBinOp *bin_op_instruction) {
	11988	static ZigType ir_analyze_bin_op_math(IrAnalyze ira, IrInstructionBinOp *bin_op_instruction) {
11989	11989	IrInstruction *op1 = bin_op_instruction->op1->other;
11990	11990	if (type_is_invalid(op1->value.type))
11991	11991	return ira->codegen->builtin_types.entry_invalid;
...	...	@@ -12012,7 +12012,7 @@ static TypeTableEntry ir_analyze_bin_op_math(IrAnalyze ira, IrInstructionBinOp
12012	12012	}
12013	12013
12014	12014	IrInstruction *instructions[] = {op1, op2};
12015		TypeTableEntry *resolved_type = ir_resolve_peer_types(ira, bin_op_instruction->base.source_node, nullptr, instructions, 2);
	12015	ZigType *resolved_type = ir_resolve_peer_types(ira, bin_op_instruction->base.source_node, nullptr, instructions, 2);
12016	12016	if (type_is_invalid(resolved_type))
12017	12017	return resolved_type;
12018	12018
...	...	@@ -12206,14 +12206,14 @@ static TypeTableEntry ir_analyze_bin_op_math(IrAnalyze ira, IrInstructionBinOp
12206	12206	}
12207	12207
12208	12208
12209		static TypeTableEntry ir_analyze_array_cat(IrAnalyze ira, IrInstructionBinOp *instruction) {
	12209	static ZigType ir_analyze_array_cat(IrAnalyze ira, IrInstructionBinOp *instruction) {
12210	12210	IrInstruction *op1 = instruction->op1->other;
12211		TypeTableEntry *op1_type = op1->value.type;
	12211	ZigType *op1_type = op1->value.type;
12212	12212	if (type_is_invalid(op1_type))
12213	12213	return ira->codegen->builtin_types.entry_invalid;
12214	12214
12215	12215	IrInstruction *op2 = instruction->op2->other;
12216		TypeTableEntry *op2_type = op2->value.type;
	12216	ZigType *op2_type = op2->value.type;
12217	12217	if (type_is_invalid(op2_type))
12218	12218	return ira->codegen->builtin_types.entry_invalid;
12219	12219
...	...	@@ -12228,7 +12228,7 @@ static TypeTableEntry ir_analyze_array_cat(IrAnalyze ira, IrInstructionBinOp *
12228	12228	ConstExprValue *op1_array_val;
12229	12229	size_t op1_array_index;
12230	12230	size_t op1_array_end;
12231		TypeTableEntry *child_type;
	12231	ZigType *child_type;
12232	12232	if (op1_type->id == TypeTableEntryIdArray) {
12233	12233	child_type = op1_type->data.array.child_type;
12234	12234	op1_array_val = op1_val;
...	...	@@ -12244,7 +12244,7 @@ static TypeTableEntry ir_analyze_array_cat(IrAnalyze ira, IrInstructionBinOp *
12244	12244	op1_array_index = op1_val->data.x_ptr.data.base_array.elem_index;
12245	12245	op1_array_end = op1_array_val->type->data.array.len - 1;
12246	12246	} else if (is_slice(op1_type)) {
12247		TypeTableEntry *ptr_type = op1_type->data.structure.fields[slice_ptr_index].type_entry;
	12247	ZigType *ptr_type = op1_type->data.structure.fields[slice_ptr_index].type_entry;
12248	12248	child_type = ptr_type->data.pointer.child_type;
12249	12249	ConstExprValue *ptr_val = &op1_val->data.x_struct.fields[slice_ptr_index];
12250	12250	assert(ptr_val->data.x_ptr.special == ConstPtrSpecialBaseArray);
...	...	@@ -12285,7 +12285,7 @@ static TypeTableEntry ir_analyze_array_cat(IrAnalyze ira, IrInstructionBinOp *
12285	12285	op2_array_index = op2_val->data.x_ptr.data.base_array.elem_index;
12286	12286	op2_array_end = op2_array_val->type->data.array.len - 1;
12287	12287	} else if (is_slice(op2_type)) {
12288		TypeTableEntry *ptr_type = op2_type->data.structure.fields[slice_ptr_index].type_entry;
	12288	ZigType *ptr_type = op2_type->data.structure.fields[slice_ptr_index].type_entry;
12289	12289	if (ptr_type->data.pointer.child_type != child_type) {
12290	12290	ir_add_error(ira, op2, buf_sprintf("expected array of type '%s', found '%s'",
12291	12291	buf_ptr(&child_type->name),
...	...	@@ -12305,7 +12305,7 @@ static TypeTableEntry ir_analyze_array_cat(IrAnalyze ira, IrInstructionBinOp *
12305	12305
12306	12306	ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
12307	12307
12308		TypeTableEntry *result_type;
	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	12311	if (op1_type->id == TypeTableEntryIdArray \|\| op2_type->id == TypeTableEntryIdArray) {
...	...	@@ -12313,7 +12313,7 @@ static TypeTableEntry ir_analyze_array_cat(IrAnalyze ira, IrInstructionBinOp *
12313	12313
12314	12314	out_array_val = out_val;
12315	12315	} else if (is_slice(op1_type) \|\| is_slice(op2_type)) {
12316		TypeTableEntry *ptr_type = get_pointer_to_type_extra(ira->codegen, child_type,
	12316	ZigType *ptr_type = get_pointer_to_type_extra(ira->codegen, child_type,
12317	12317	true, false, PtrLenUnknown, get_abi_alignment(ira->codegen, child_type), 0, 0);
12318	12318	result_type = get_slice_type(ira->codegen, ptr_type);
12319	12319	out_array_val = create_const_vals(1);
...	...	@@ -12374,7 +12374,7 @@ static TypeTableEntry ir_analyze_array_cat(IrAnalyze ira, IrInstructionBinOp *
12374	12374	return result_type;
12375	12375	}
12376	12376
12377		static TypeTableEntry ir_analyze_array_mult(IrAnalyze ira, IrInstructionBinOp *instruction) {
	12377	static ZigType ir_analyze_array_mult(IrAnalyze ira, IrInstructionBinOp *instruction) {
12378	12378	IrInstruction *op1 = instruction->op1->other;
12379	12379	if (type_is_invalid(op1->value.type))
12380	12380	return ira->codegen->builtin_types.entry_invalid;
...	...	@@ -12391,7 +12391,7 @@ static TypeTableEntry ir_analyze_array_mult(IrAnalyze ira, IrInstructionBinOp
12391	12391	if (!ir_resolve_usize(ira, op2, &mult_amt))
12392	12392	return ira->codegen->builtin_types.entry_invalid;
12393	12393
12394		TypeTableEntry *array_type = op1->value.type;
	12394	ZigType *array_type = op1->value.type;
12395	12395	if (array_type->id != TypeTableEntryIdArray) {
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;
...	...	@@ -12410,7 +12410,7 @@ static TypeTableEntry ir_analyze_array_mult(IrAnalyze ira, IrInstructionBinOp
12410	12410	if (array_val->data.x_array.special == ConstArraySpecialUndef) {
12411	12411	out_val->data.x_array.special = ConstArraySpecialUndef;
12412	12412
12413		TypeTableEntry *child_type = array_type->data.array.child_type;
	12413	ZigType *child_type = array_type->data.array.child_type;
12414	12414	return get_array_type(ira->codegen, child_type, new_array_len);
12415	12415	}
12416	12416
...	...	@@ -12425,16 +12425,16 @@ static TypeTableEntry ir_analyze_array_mult(IrAnalyze ira, IrInstructionBinOp
12425	12425	}
12426	12426	assert(i == new_array_len);
12427	12427
12428		TypeTableEntry *child_type = array_type->data.array.child_type;
	12428	ZigType *child_type = array_type->data.array.child_type;
12429	12429	return get_array_type(ira->codegen, child_type, new_array_len);
12430	12430	}
12431	12431
12432		static TypeTableEntry ir_analyze_merge_error_sets(IrAnalyze ira, IrInstructionBinOp *instruction) {
12433		TypeTableEntry *op1_type = ir_resolve_type(ira, instruction->op1->other);
	12432	static ZigType ir_analyze_merge_error_sets(IrAnalyze ira, IrInstructionBinOp *instruction) {
	12433	ZigType *op1_type = ir_resolve_type(ira, instruction->op1->other);
12434	12434	if (type_is_invalid(op1_type))
12435	12435	return ira->codegen->builtin_types.entry_invalid;
12436	12436
12437		TypeTableEntry *op2_type = ir_resolve_type(ira, instruction->op2->other);
	12437	ZigType *op2_type = ir_resolve_type(ira, instruction->op2->other);
12438	12438	if (type_is_invalid(op2_type))
12439	12439	return ira->codegen->builtin_types.entry_invalid;
12440	12440
...	...	@@ -12460,7 +12460,7 @@ static TypeTableEntry ir_analyze_merge_error_sets(IrAnalyze ira, IrInstruction
12460	12460	assert(errors[error_entry->value] == nullptr);
12461	12461	errors[error_entry->value] = error_entry;
12462	12462	}
12463		TypeTableEntry *result_type = get_error_set_union(ira->codegen, errors, op1_type, op2_type);
	12463	ZigType *result_type = get_error_set_union(ira->codegen, errors, op1_type, op2_type);
12464	12464	free(errors);
12465	12465
12466	12466
...	...	@@ -12469,7 +12469,7 @@ static TypeTableEntry ir_analyze_merge_error_sets(IrAnalyze ira, IrInstruction
12469	12469	return ira->codegen->builtin_types.entry_type;
12470	12470	}
12471	12471
12472		static TypeTableEntry ir_analyze_instruction_bin_op(IrAnalyze ira, IrInstructionBinOp *bin_op_instruction) {
	12472	static ZigType ir_analyze_instruction_bin_op(IrAnalyze ira, IrInstructionBinOp *bin_op_instruction) {
12473	12473	IrBinOp op_id = bin_op_instruction->op_id;
12474	12474	switch (op_id) {
12475	12475	case IrBinOpInvalid:
...	...	@@ -12516,7 +12516,7 @@ static TypeTableEntry ir_analyze_instruction_bin_op(IrAnalyze ira, IrInstructi
12516	12516	zig_unreachable();
12517	12517	}
12518	12518
12519		static TypeTableEntry ir_analyze_instruction_decl_var(IrAnalyze ira, IrInstructionDeclVar *decl_var_instruction) {
	12519	static ZigType ir_analyze_instruction_decl_var(IrAnalyze ira, IrInstructionDeclVar *decl_var_instruction) {
12520	12520	Error err;
12521	12521	VariableTableEntry *var = decl_var_instruction->var;
12522	12522
...	...	@@ -12526,11 +12526,11 @@ static TypeTableEntry ir_analyze_instruction_decl_var(IrAnalyze ira, IrInstruc
12526	12526	return var->value->type;
12527	12527	}
12528	12528
12529		TypeTableEntry *explicit_type = nullptr;
	12529	ZigType *explicit_type = nullptr;
12530	12530	IrInstruction *var_type = nullptr;
12531	12531	if (decl_var_instruction->var_type != nullptr) {
12532	12532	var_type = decl_var_instruction->var_type->other;
12533		TypeTableEntry *proposed_type = ir_resolve_type(ira, var_type);
	12533	ZigType *proposed_type = ir_resolve_type(ira, var_type);
12534	12534	explicit_type = validate_var_type(ira->codegen, var_type->source_node, proposed_type);
12535	12535	if (type_is_invalid(explicit_type)) {
12536	12536	var->value->type = ira->codegen->builtin_types.entry_invalid;
...	...	@@ -12545,7 +12545,7 @@ static TypeTableEntry ir_analyze_instruction_decl_var(IrAnalyze ira, IrInstruc
12545	12545
12546	12546	bool var_class_requires_const = false;
12547	12547
12548		TypeTableEntry *result_type = casted_init_value->value.type;
	12548	ZigType *result_type = casted_init_value->value.type;
12549	12549	if (type_is_invalid(result_type)) {
12550	12550	result_type = ira->codegen->builtin_types.entry_invalid;
12551	12551	} else {
...	...	@@ -12651,7 +12651,7 @@ static TypeTableEntry ir_analyze_instruction_decl_var(IrAnalyze ira, IrInstruc
12651	12651	return ira->codegen->builtin_types.entry_void;
12652	12652	}
12653	12653
12654		static TypeTableEntry ir_analyze_instruction_export(IrAnalyze ira, IrInstructionExport *instruction) {
	12654	static ZigType ir_analyze_instruction_export(IrAnalyze ira, IrInstructionExport *instruction) {
12655	12655	IrInstruction *name = instruction->name->other;
12656	12656	Buf *symbol_name = ir_resolve_str(ira, name);
12657	12657	if (symbol_name == nullptr) {
...	...	@@ -12731,7 +12731,7 @@ static TypeTableEntry ir_analyze_instruction_export(IrAnalyze ira, IrInstructi
12731	12731	}
12732	12732	break;
12733	12733	case TypeTableEntryIdMetaType: {
12734		TypeTableEntry *type_value = target->value.data.x_type;
	12734	ZigType *type_value = target->value.data.x_type;
12735	12735	switch (type_value->id) {
12736	12736	case TypeTableEntryIdInvalid:
12737	12737	zig_unreachable();
...	...	@@ -12826,12 +12826,12 @@ static bool exec_has_err_ret_trace(CodeGen g, IrExecutable exec) {
12826	12826	return fn_entry != nullptr && fn_entry->calls_or_awaits_errorable_fn && g->have_err_ret_tracing;
12827	12827	}
12828	12828
12829		static TypeTableEntry ir_analyze_instruction_error_return_trace(IrAnalyze ira,
	12829	static ZigType ir_analyze_instruction_error_return_trace(IrAnalyze ira,
12830	12830	IrInstructionErrorReturnTrace *instruction)
12831	12831	{
12832	12832	if (instruction->optional == IrInstructionErrorReturnTrace::Null) {
12833		TypeTableEntry *ptr_to_stack_trace_type = get_ptr_to_stack_trace_type(ira->codegen);
12834		TypeTableEntry *optional_type = get_optional_type(ira->codegen, ptr_to_stack_trace_type);
	12833	ZigType *ptr_to_stack_trace_type = get_ptr_to_stack_trace_type(ira->codegen);
	12834	ZigType *optional_type = get_optional_type(ira->codegen, ptr_to_stack_trace_type);
12835	12835	if (!exec_has_err_ret_trace(ira->codegen, ira->new_irb.exec)) {
12836	12836	ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
12837	12837	assert(get_codegen_ptr_type(optional_type) != nullptr);
...	...	@@ -12852,14 +12852,14 @@ static TypeTableEntry ir_analyze_instruction_error_return_trace(IrAnalyze ira,
12852	12852	}
12853	12853	}
12854	12854
12855		static TypeTableEntry ir_analyze_instruction_error_union(IrAnalyze ira,
	12855	static ZigType ir_analyze_instruction_error_union(IrAnalyze ira,
12856	12856	IrInstructionErrorUnion *instruction)
12857	12857	{
12858		TypeTableEntry *err_set_type = ir_resolve_type(ira, instruction->err_set->other);
	12858	ZigType *err_set_type = ir_resolve_type(ira, instruction->err_set->other);
12859	12859	if (type_is_invalid(err_set_type))
12860	12860	return ira->codegen->builtin_types.entry_invalid;
12861	12861
12862		TypeTableEntry *payload_type = ir_resolve_type(ira, instruction->payload->other);
	12862	ZigType *payload_type = ir_resolve_type(ira, instruction->payload->other);
12863	12863	if (type_is_invalid(payload_type))
12864	12864	return ira->codegen->builtin_types.entry_invalid;
12865	12865
...	...	@@ -12870,7 +12870,7 @@ static TypeTableEntry ir_analyze_instruction_error_union(IrAnalyze ira,
12870	12870	return ira->codegen->builtin_types.entry_invalid;
12871	12871	}
12872	12872
12873		TypeTableEntry *result_type = get_error_union_type(ira->codegen, err_set_type, payload_type);
	12873	ZigType *result_type = get_error_union_type(ira->codegen, err_set_type, payload_type);
12874	12874
12875	12875	ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
12876	12876	out_val->data.x_type = result_type;
...	...	@@ -12913,38 +12913,38 @@ IrInstruction ir_get_implicit_allocator(IrAnalyze ira, IrInstruction *source_i
12913	12913	zig_unreachable();
12914	12914	}
12915	12915
12916		static IrInstruction ir_analyze_async_call(IrAnalyze ira, IrInstructionCall call_instruction, FnTableEntry fn_entry, TypeTableEntry *fn_type,
	12916	static IrInstruction ir_analyze_async_call(IrAnalyze ira, IrInstructionCall call_instruction, FnTableEntry fn_entry, ZigType *fn_type,
12917	12917	IrInstruction fn_ref, IrInstruction casted_args, size_t arg_count, IrInstruction async_allocator_inst)
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	12921	assert(async_allocator_inst->value.type->id == TypeTableEntryIdPointer);
12922		TypeTableEntry *container_type = async_allocator_inst->value.type->data.pointer.child_type;
	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);
12925	12925	if (type_is_invalid(field_ptr_inst->value.type)) {
12926	12926	return ira->codegen->invalid_instruction;
12927	12927	}
12928		TypeTableEntry *ptr_to_alloc_fn_type = field_ptr_inst->value.type;
	12928	ZigType *ptr_to_alloc_fn_type = field_ptr_inst->value.type;
12929	12929	assert(ptr_to_alloc_fn_type->id == TypeTableEntryIdPointer);
12930	12930
12931		TypeTableEntry *alloc_fn_type = ptr_to_alloc_fn_type->data.pointer.child_type;
	12931	ZigType *alloc_fn_type = ptr_to_alloc_fn_type->data.pointer.child_type;
12932	12932	if (alloc_fn_type->id != TypeTableEntryIdFn) {
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		TypeTableEntry *alloc_fn_return_type = alloc_fn_type->data.fn.fn_type_id.return_type;
	12938	ZigType *alloc_fn_return_type = alloc_fn_type->data.fn.fn_type_id.return_type;
12939	12939	if (alloc_fn_return_type->id != TypeTableEntryIdErrorUnion) {
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;
12943	12943	}
12944		TypeTableEntry *alloc_fn_error_set_type = alloc_fn_return_type->data.error_union.err_set_type;
12945		TypeTableEntry *return_type = fn_type->data.fn.fn_type_id.return_type;
12946		TypeTableEntry *promise_type = get_promise_type(ira->codegen, return_type);
12947		TypeTableEntry *async_return_type = get_error_union_type(ira->codegen, alloc_fn_error_set_type, promise_type);
	12944	ZigType *alloc_fn_error_set_type = alloc_fn_return_type->data.error_union.err_set_type;
	12945	ZigType *return_type = fn_type->data.fn.fn_type_id.return_type;
	12946	ZigType *promise_type = get_promise_type(ira->codegen, return_type);
	12947	ZigType *async_return_type = get_error_union_type(ira->codegen, alloc_fn_error_set_type, promise_type);
12948	12948
12949	12949	IrInstruction *result = ir_build_call(&ira->new_irb, call_instruction->base.scope, call_instruction->base.source_node,
12950	12950	fn_entry, fn_ref, arg_count, casted_args, false, FnInlineAuto, true, async_allocator_inst, nullptr);
...	...	@@ -12961,7 +12961,7 @@ static bool ir_analyze_fn_call_inline_arg(IrAnalyze ira, AstNode fn_proto_node
12961	12961	IrInstruction *casted_arg;
12962	12962	if (param_decl_node->data.param_decl.var_token == nullptr) {
12963	12963	AstNode *param_type_node = param_decl_node->data.param_decl.type;
12964		TypeTableEntry param_type = analyze_type_expr(ira->codegen, exec_scope, param_type_node);
	12964	ZigType param_type = analyze_type_expr(ira->codegen, exec_scope, param_type_node);
12965	12965	if (type_is_invalid(param_type))
12966	12966	return false;
12967	12967
...	...	@@ -13001,7 +13001,7 @@ static bool ir_analyze_fn_call_generic_arg(IrAnalyze ira, AstNode fn_proto_nod
13001	13001	} else {
13002	13002	if (param_decl_node->data.param_decl.var_token == nullptr) {
13003	13003	AstNode *param_type_node = param_decl_node->data.param_decl.type;
13004		TypeTableEntry param_type = analyze_type_expr(ira->codegen, child_scope, param_type_node);
	13004	ZigType param_type = analyze_type_expr(ira->codegen, child_scope, param_type_node);
13005	13005	if (type_is_invalid(param_type))
13006	13006	return false;
13007	13007
...	...	@@ -13156,8 +13156,8 @@ no_mem_slot:
13156	13156	return var_ptr_instruction;
13157	13157	}
13158	13158
13159		static TypeTableEntry ir_analyze_fn_call(IrAnalyze ira, IrInstructionCall *call_instruction,
13160		FnTableEntry fn_entry, TypeTableEntry fn_type, IrInstruction *fn_ref,
	13159	static ZigType ir_analyze_fn_call(IrAnalyze ira, IrInstructionCall *call_instruction,
	13160	FnTableEntry fn_entry, ZigType fn_type, IrInstruction *fn_ref,
13161	13161	IrInstruction *first_arg_ptr, bool comptime_fn_call, FnInline fn_inline)
13162	13162	{
13163	13163	Error err;
...	...	@@ -13249,7 +13249,7 @@ static TypeTableEntry ir_analyze_fn_call(IrAnalyze ira, IrInstructionCall *cal
13249	13249
13250	13250	bool first_arg_known_bare = false;
13251	13251	if (fn_type_id->next_param_index >= 1) {
13252		TypeTableEntry *param_type = fn_type_id->param_info[next_proto_i].type;
	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	13255	first_arg_known_bare = param_type->id != TypeTableEntryIdPointer;
...	...	@@ -13285,11 +13285,11 @@ static TypeTableEntry ir_analyze_fn_call(IrAnalyze ira, IrInstructionCall *cal
13285	13285	}
13286	13286
13287	13287	AstNode *return_type_node = fn_proto_node->data.fn_proto.return_type;
13288		TypeTableEntry *specified_return_type = analyze_type_expr(ira->codegen, exec_scope, return_type_node);
	13288	ZigType *specified_return_type = analyze_type_expr(ira->codegen, exec_scope, return_type_node);
13289	13289	if (type_is_invalid(specified_return_type))
13290	13290	return ira->codegen->builtin_types.entry_invalid;
13291		TypeTableEntry *return_type;
13292		TypeTableEntry *inferred_err_set_type = nullptr;
	13291	ZigType *return_type;
	13292	ZigType *inferred_err_set_type = nullptr;
13293	13293	if (fn_proto_node->data.fn_proto.auto_err_set) {
13294	13294	inferred_err_set_type = get_auto_err_set_type(ira->codegen, fn_entry);
13295	13295	return_type = get_error_union_type(ira->codegen, inferred_err_set_type, specified_return_type);
...	...	@@ -13320,7 +13320,7 @@ static TypeTableEntry ir_analyze_fn_call(IrAnalyze ira, IrInstructionCall *cal
13320	13320	inferred_err_set_type->data.error_set.errors = allocate<ErrorTableEntry *>(1);
13321	13321	inferred_err_set_type->data.error_set.errors[0] = result->value.data.x_err_union.err;
13322	13322	}
13323		TypeTableEntry *fn_inferred_err_set_type = result->value.type->data.error_union.err_set_type;
	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	13326	} else if (result->value.type->id == TypeTableEntryIdErrorSet) {
...	...	@@ -13344,10 +13344,10 @@ static TypeTableEntry ir_analyze_fn_call(IrAnalyze ira, IrInstructionCall *cal
13344	13344
13345	13345	IrInstruction *casted_new_stack = nullptr;
13346	13346	if (call_instruction->new_stack != nullptr) {
13347		TypeTableEntry *u8_ptr = get_pointer_to_type_extra(ira->codegen, ira->codegen->builtin_types.entry_u8,
	13347	ZigType *u8_ptr = get_pointer_to_type_extra(ira->codegen, ira->codegen->builtin_types.entry_u8,
13348	13348	false, false, PtrLenUnknown,
13349	13349	get_abi_alignment(ira->codegen, ira->codegen->builtin_types.entry_u8), 0, 0);
13350		TypeTableEntry *u8_slice = get_slice_type(ira->codegen, u8_ptr);
	13350	ZigType *u8_slice = get_slice_type(ira->codegen, u8_ptr);
13351	13351	IrInstruction *new_stack = call_instruction->new_stack->other;
13352	13352	if (type_is_invalid(new_stack->value.type))
13353	13353	return ira->codegen->builtin_types.entry_invalid;
...	...	@@ -13405,7 +13405,7 @@ static TypeTableEntry ir_analyze_fn_call(IrAnalyze ira, IrInstructionCall *cal
13405	13405
13406	13406	bool first_arg_known_bare = false;
13407	13407	if (fn_type_id->next_param_index >= 1) {
13408		TypeTableEntry *param_type = fn_type_id->param_info[next_proto_i].type;
	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	13411	first_arg_known_bare = param_type->id != TypeTableEntryIdPointer;
...	...	@@ -13515,11 +13515,11 @@ static TypeTableEntry ir_analyze_fn_call(IrAnalyze ira, IrInstructionCall *cal
13515	13515
13516	13516	if (fn_proto_node->data.fn_proto.return_var_token == nullptr) {
13517	13517	AstNode *return_type_node = fn_proto_node->data.fn_proto.return_type;
13518		TypeTableEntry *specified_return_type = analyze_type_expr(ira->codegen, impl_fn->child_scope, return_type_node);
	13518	ZigType *specified_return_type = analyze_type_expr(ira->codegen, impl_fn->child_scope, return_type_node);
13519	13519	if (type_is_invalid(specified_return_type))
13520	13520	return ira->codegen->builtin_types.entry_invalid;
13521	13521	if (fn_proto_node->data.fn_proto.auto_err_set) {
13522		TypeTableEntry *inferred_err_set_type = get_auto_err_set_type(ira->codegen, impl_fn);
	13522	ZigType *inferred_err_set_type = get_auto_err_set_type(ira->codegen, impl_fn);
13523	13523	inst_fn_type_id.return_type = get_error_union_type(ira->codegen, inferred_err_set_type, specified_return_type);
13524	13524	} else {
13525	13525	inst_fn_type_id.return_type = specified_return_type;
...	...	@@ -13537,7 +13537,7 @@ static TypeTableEntry ir_analyze_fn_call(IrAnalyze ira, IrInstructionCall *cal
13537	13537	if (call_instruction->is_async) {
13538	13538	AstNode *async_allocator_type_node = fn_proto_node->data.fn_proto.async_allocator_type;
13539	13539	if (async_allocator_type_node != nullptr) {
13540		TypeTableEntry *async_allocator_type = analyze_type_expr(ira->codegen, impl_fn->child_scope, async_allocator_type_node);
	13540	ZigType *async_allocator_type = analyze_type_expr(ira->codegen, impl_fn->child_scope, async_allocator_type_node);
13541	13541	if (type_is_invalid(async_allocator_type))
13542	13542	return ira->codegen->builtin_types.entry_invalid;
13543	13543	inst_fn_type_id.async_allocator_type = async_allocator_type;
...	...	@@ -13581,7 +13581,7 @@ static TypeTableEntry ir_analyze_fn_call(IrAnalyze ira, IrInstructionCall *cal
13581	13581	ira->codegen->fn_defs.append(impl_fn);
13582	13582	}
13583	13583
13584		TypeTableEntry *return_type = impl_fn->type_entry->data.fn.fn_type_id.return_type;
	13584	ZigType *return_type = impl_fn->type_entry->data.fn.fn_type_id.return_type;
13585	13585	if (fn_type_can_fail(&impl_fn->type_entry->data.fn.fn_type_id)) {
13586	13586	parent_fn_entry->calls_or_awaits_errorable_fn = true;
13587	13587	}
...	...	@@ -13618,7 +13618,7 @@ static TypeTableEntry ir_analyze_fn_call(IrAnalyze ira, IrInstructionCall *cal
13618	13618	if (first_arg_ptr) {
13619	13619	assert(first_arg_ptr->value.type->id == TypeTableEntryIdPointer);
13620	13620
13621		TypeTableEntry *param_type = fn_type_id->param_info[next_arg_index].type;
	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
...	...	@@ -13646,7 +13646,7 @@ static TypeTableEntry ir_analyze_fn_call(IrAnalyze ira, IrInstructionCall *cal
13646	13646	return ira->codegen->builtin_types.entry_invalid;
13647	13647	IrInstruction *casted_arg;
13648	13648	if (next_arg_index < src_param_count) {
13649		TypeTableEntry *param_type = fn_type_id->param_info[next_arg_index].type;
	13649	ZigType *param_type = fn_type_id->param_info[next_arg_index].type;
13650	13650	if (type_is_invalid(param_type))
13651	13651	return ira->codegen->builtin_types.entry_invalid;
13652	13652	casted_arg = ir_implicit_cast(ira, old_arg, param_type);
...	...	@@ -13662,7 +13662,7 @@ static TypeTableEntry ir_analyze_fn_call(IrAnalyze ira, IrInstructionCall *cal
13662	13662
13663	13663	assert(next_arg_index == call_param_count);
13664	13664
13665		TypeTableEntry *return_type = fn_type_id->return_type;
	13665	ZigType *return_type = fn_type_id->return_type;
13666	13666	if (type_is_invalid(return_type))
13667	13667	return ira->codegen->builtin_types.entry_invalid;
13668	13668
...	...	@@ -13703,7 +13703,7 @@ static TypeTableEntry ir_analyze_fn_call(IrAnalyze ira, IrInstructionCall *cal
13703	13703	return ir_finish_anal(ira, return_type);
13704	13704	}
13705	13705
13706		static TypeTableEntry ir_analyze_instruction_call(IrAnalyze ira, IrInstructionCall *call_instruction) {
	13706	static ZigType ir_analyze_instruction_call(IrAnalyze ira, IrInstructionCall *call_instruction) {
13707	13707	IrInstruction *fn_ref = call_instruction->fn_ref->other;
13708	13708	if (type_is_invalid(fn_ref->value.type))
13709	13709	return ira->codegen->builtin_types.entry_invalid;
...	...	@@ -13713,7 +13713,7 @@ static TypeTableEntry ir_analyze_instruction_call(IrAnalyze ira, IrInstruction
13713	13713
13714	13714	if (is_comptime \|\| instr_is_comptime(fn_ref)) {
13715	13715	if (fn_ref->value.type->id == TypeTableEntryIdMetaType) {
13716		TypeTableEntry *dest_type = ir_resolve_type(ira, fn_ref);
	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;
13719	13719
...	...	@@ -13793,12 +13793,12 @@ static Error ir_read_const_ptr(IrAnalyze ira, AstNode source_node,
13793	13793	return ErrorNone;
13794	13794	}
13795	13795
13796		static TypeTableEntry ir_analyze_dereference(IrAnalyze ira, IrInstructionUnOp *un_op_instruction) {
	13796	static ZigType ir_analyze_dereference(IrAnalyze ira, IrInstructionUnOp *un_op_instruction) {
13797	13797	Error err;
13798	13798	IrInstruction *value = un_op_instruction->value->other;
13799	13799
13800		TypeTableEntry *ptr_type = value->value.type;
13801		TypeTableEntry *child_type;
	13800	ZigType *ptr_type = value->value.type;
	13801	ZigType *child_type;
13802	13802	if (type_is_invalid(ptr_type)) {
13803	13803	return ira->codegen->builtin_types.entry_invalid;
13804	13804	} else if (ptr_type->id == TypeTableEntryIdPointer) {
...	...	@@ -13835,10 +13835,10 @@ static TypeTableEntry ir_analyze_dereference(IrAnalyze ira, IrInstructionUnOp
13835	13835	return child_type;
13836	13836	}
13837	13837
13838		static TypeTableEntry ir_analyze_maybe(IrAnalyze ira, IrInstructionUnOp *un_op_instruction) {
	13838	static ZigType ir_analyze_maybe(IrAnalyze ira, IrInstructionUnOp *un_op_instruction) {
13839	13839	Error err;
13840	13840	IrInstruction *value = un_op_instruction->value->other;
13841		TypeTableEntry *type_entry = ir_resolve_type(ira, value);
	13841	ZigType *type_entry = ir_resolve_type(ira, value);
13842	13842	if (type_is_invalid(type_entry))
13843	13843	return ira->codegen->builtin_types.entry_invalid;
13844	13844	if ((err = ensure_complete_type(ira->codegen, type_entry)))
...	...	@@ -13884,9 +13884,9 @@ static TypeTableEntry ir_analyze_maybe(IrAnalyze ira, IrInstructionUnOp *un_op
13884	13884	zig_unreachable();
13885	13885	}
13886	13886
13887		static TypeTableEntry ir_analyze_negation(IrAnalyze ira, IrInstructionUnOp *un_op_instruction) {
	13887	static ZigType ir_analyze_negation(IrAnalyze ira, IrInstructionUnOp *un_op_instruction) {
13888	13888	IrInstruction *value = un_op_instruction->value->other;
13889		TypeTableEntry *expr_type = value->value.type;
	13889	ZigType *expr_type = value->value.type;
13890	13890	if (type_is_invalid(expr_type))
13891	13891	return ira->codegen->builtin_types.entry_invalid;
13892	13892
...	...	@@ -13931,9 +13931,9 @@ static TypeTableEntry ir_analyze_negation(IrAnalyze ira, IrInstructionUnOp *un
13931	13931	return ira->codegen->builtin_types.entry_invalid;
13932	13932	}
13933	13933
13934		static TypeTableEntry ir_analyze_bin_not(IrAnalyze ira, IrInstructionUnOp *instruction) {
	13934	static ZigType ir_analyze_bin_not(IrAnalyze ira, IrInstructionUnOp *instruction) {
13935	13935	IrInstruction *value = instruction->value->other;
13936		TypeTableEntry *expr_type = value->value.type;
	13936	ZigType *expr_type = value->value.type;
13937	13937	if (type_is_invalid(expr_type))
13938	13938	return ira->codegen->builtin_types.entry_invalid;
13939	13939
...	...	@@ -13958,7 +13958,7 @@ static TypeTableEntry ir_analyze_bin_not(IrAnalyze ira, IrInstructionUnOp *ins
13958	13958	return ira->codegen->builtin_types.entry_invalid;
13959	13959	}
13960	13960
13961		static TypeTableEntry ir_analyze_instruction_un_op(IrAnalyze ira, IrInstructionUnOp *un_op_instruction) {
	13961	static ZigType ir_analyze_instruction_un_op(IrAnalyze ira, IrInstructionUnOp *un_op_instruction) {
13962	13962	IrUnOp op_id = un_op_instruction->op_id;
13963	13963	switch (op_id) {
13964	13964	case IrUnOpInvalid:
...	...	@@ -13976,7 +13976,7 @@ static TypeTableEntry ir_analyze_instruction_un_op(IrAnalyze ira, IrInstructio
13976	13976	zig_unreachable();
13977	13977	}
13978	13978
13979		static TypeTableEntry ir_analyze_instruction_br(IrAnalyze ira, IrInstructionBr *br_instruction) {
	13979	static ZigType ir_analyze_instruction_br(IrAnalyze ira, IrInstructionBr *br_instruction) {
13980	13980	IrBasicBlock *old_dest_block = br_instruction->dest_block;
13981	13981
13982	13982	bool is_comptime;
...	...	@@ -13994,7 +13994,7 @@ static TypeTableEntry ir_analyze_instruction_br(IrAnalyze ira, IrInstructionBr
13994	13994	return ir_finish_anal(ira, ira->codegen->builtin_types.entry_unreachable);
13995	13995	}
13996	13996
13997		static TypeTableEntry ir_analyze_instruction_cond_br(IrAnalyze ira, IrInstructionCondBr *cond_br_instruction) {
	13997	static ZigType ir_analyze_instruction_cond_br(IrAnalyze ira, IrInstructionCondBr *cond_br_instruction) {
13998	13998	IrInstruction *condition = cond_br_instruction->condition->other;
13999	13999	if (type_is_invalid(condition->value.type))
14000	14000	return ir_unreach_error(ira);
...	...	@@ -14022,7 +14022,7 @@ static TypeTableEntry ir_analyze_instruction_cond_br(IrAnalyze ira, IrInstruct
14022	14022	return ir_finish_anal(ira, ira->codegen->builtin_types.entry_unreachable);
14023	14023	}
14024	14024
14025		TypeTableEntry *bool_type = ira->codegen->builtin_types.entry_bool;
	14025	ZigType *bool_type = ira->codegen->builtin_types.entry_bool;
14026	14026	IrInstruction *casted_condition = ir_implicit_cast(ira, condition, bool_type);
14027	14027	if (casted_condition == ira->codegen->invalid_instruction)
14028	14028	return ir_unreach_error(ira);
...	...	@@ -14041,14 +14041,14 @@ static TypeTableEntry ir_analyze_instruction_cond_br(IrAnalyze ira, IrInstruct
14041	14041	return ir_finish_anal(ira, ira->codegen->builtin_types.entry_unreachable);
14042	14042	}
14043	14043
14044		static TypeTableEntry ir_analyze_instruction_unreachable(IrAnalyze ira,
	14044	static ZigType ir_analyze_instruction_unreachable(IrAnalyze ira,
14045	14045	IrInstructionUnreachable *unreachable_instruction)
14046	14046	{
14047	14047	ir_build_unreachable_from(&ira->new_irb, &unreachable_instruction->base);
14048	14048	return ir_finish_anal(ira, ira->codegen->builtin_types.entry_unreachable);
14049	14049	}
14050	14050
14051		static TypeTableEntry ir_analyze_instruction_phi(IrAnalyze ira, IrInstructionPhi *phi_instruction) {
	14051	static ZigType ir_analyze_instruction_phi(IrAnalyze ira, IrInstructionPhi *phi_instruction) {
14052	14052	if (ira->const_predecessor_bb) {
14053	14053	for (size_t i = 0; i < phi_instruction->incoming_count; i += 1) {
14054	14054	IrBasicBlock *predecessor = phi_instruction->incoming_blocks[i];
...	...	@@ -14105,7 +14105,7 @@ static TypeTableEntry ir_analyze_instruction_phi(IrAnalyze ira, IrInstructionP
14105	14105	return first_value->value.type;
14106	14106	}
14107	14107
14108		TypeTableEntry *resolved_type = ir_resolve_peer_types(ira, phi_instruction->base.source_node, nullptr,
	14108	ZigType *resolved_type = ir_resolve_peer_types(ira, phi_instruction->base.source_node, nullptr,
14109	14109	new_incoming_values.items, new_incoming_values.length);
14110	14110	if (type_is_invalid(resolved_type))
14111	14111	return resolved_type;
...	...	@@ -14157,7 +14157,7 @@ static TypeTableEntry ir_analyze_instruction_phi(IrAnalyze ira, IrInstructionP
14157	14157	return resolved_type;
14158	14158	}
14159	14159
14160		static TypeTableEntry ir_analyze_var_ptr(IrAnalyze ira, IrInstruction *instruction,
	14160	static ZigType ir_analyze_var_ptr(IrAnalyze ira, IrInstruction *instruction,
14161	14161	VariableTableEntry *var)
14162	14162	{
14163	14163	IrInstruction *result = ir_get_var_ptr(ira, instruction, var);
...	...	@@ -14165,12 +14165,12 @@ static TypeTableEntry ir_analyze_var_ptr(IrAnalyze ira, IrInstruction *instruc
14165	14165	return result->value.type;
14166	14166	}
14167	14167
14168		static TypeTableEntry ir_analyze_instruction_var_ptr(IrAnalyze ira, IrInstructionVarPtr *var_ptr_instruction) {
	14168	static ZigType ir_analyze_instruction_var_ptr(IrAnalyze ira, IrInstructionVarPtr *var_ptr_instruction) {
14169	14169	VariableTableEntry *var = var_ptr_instruction->var;
14170	14170	return ir_analyze_var_ptr(ira, &var_ptr_instruction->base, var);
14171	14171	}
14172	14172
14173		static TypeTableEntry adjust_ptr_align(CodeGen g, TypeTableEntry *ptr_type, uint32_t new_align) {
	14173	static ZigType adjust_ptr_align(CodeGen g, ZigType *ptr_type, uint32_t new_align) {
14174	14174	assert(ptr_type->id == TypeTableEntryIdPointer);
14175	14175	return get_pointer_to_type_extra(g,
14176	14176	ptr_type->data.pointer.child_type,
...	...	@@ -14180,14 +14180,14 @@ static TypeTableEntry adjust_ptr_align(CodeGen g, TypeTableEntry *ptr_type, ui
14180	14180	ptr_type->data.pointer.bit_offset, ptr_type->data.pointer.unaligned_bit_count);
14181	14181	}
14182	14182
14183		static TypeTableEntry adjust_slice_align(CodeGen g, TypeTableEntry *slice_type, uint32_t new_align) {
	14183	static ZigType adjust_slice_align(CodeGen g, ZigType *slice_type, uint32_t new_align) {
14184	14184	assert(is_slice(slice_type));
14185		TypeTableEntry *ptr_type = adjust_ptr_align(g, slice_type->data.structure.fields[slice_ptr_index].type_entry,
	14185	ZigType *ptr_type = adjust_ptr_align(g, slice_type->data.structure.fields[slice_ptr_index].type_entry,
14186	14186	new_align);
14187	14187	return get_slice_type(g, ptr_type);
14188	14188	}
14189	14189
14190		static TypeTableEntry adjust_ptr_len(CodeGen g, TypeTableEntry *ptr_type, PtrLen ptr_len) {
	14190	static ZigType adjust_ptr_len(CodeGen g, ZigType *ptr_type, PtrLen ptr_len) {
14191	14191	assert(ptr_type->id == TypeTableEntryIdPointer);
14192	14192	return get_pointer_to_type_extra(g,
14193	14193	ptr_type->data.pointer.child_type,
...	...	@@ -14197,7 +14197,7 @@ static TypeTableEntry adjust_ptr_len(CodeGen g, TypeTableEntry *ptr_type, PtrL
14197	14197	ptr_type->data.pointer.bit_offset, ptr_type->data.pointer.unaligned_bit_count);
14198	14198	}
14199	14199
14200		static TypeTableEntry ir_analyze_instruction_elem_ptr(IrAnalyze ira, IrInstructionElemPtr *elem_ptr_instruction) {
	14200	static ZigType ir_analyze_instruction_elem_ptr(IrAnalyze ira, IrInstructionElemPtr *elem_ptr_instruction) {
14201	14201	Error err;
14202	14202	IrInstruction *array_ptr = elem_ptr_instruction->array_ptr->other;
14203	14203	if (type_is_invalid(array_ptr->value.type))
...	...	@@ -14209,14 +14209,14 @@ static TypeTableEntry ir_analyze_instruction_elem_ptr(IrAnalyze ira, IrInstruc
14209	14209	if (type_is_invalid(elem_index->value.type))
14210	14210	return ira->codegen->builtin_types.entry_invalid;
14211	14211
14212		TypeTableEntry *ptr_type = orig_array_ptr_val->type;
	14212	ZigType *ptr_type = orig_array_ptr_val->type;
14213	14213	assert(ptr_type->id == TypeTableEntryIdPointer);
14214	14214
14215		TypeTableEntry *array_type = ptr_type->data.pointer.child_type;
	14215	ZigType *array_type = ptr_type->data.pointer.child_type;
14216	14216
14217	14217	// At first return_type will be the pointer type we want to return, except with an optimistic alignment.
14218	14218	// We will adjust return_type's alignment before returning it.
14219		TypeTableEntry *return_type;
	14219	ZigType *return_type;
14220	14220
14221	14221	if (type_is_invalid(array_type)) {
14222	14222	return array_type;
...	...	@@ -14240,7 +14240,7 @@ static TypeTableEntry ir_analyze_instruction_elem_ptr(IrAnalyze ira, IrInstruc
14240	14240	buf_sprintf("index 0 outside array of size 0"));
14241	14241	return ira->codegen->builtin_types.entry_invalid;
14242	14242	}
14243		TypeTableEntry *child_type = array_type->data.array.child_type;
	14243	ZigType *child_type = array_type->data.array.child_type;
14244	14244	if (ptr_type->data.pointer.unaligned_bit_count == 0) {
14245	14245	return_type = get_pointer_to_type_extra(ira->codegen, child_type,
14246	14246	ptr_type->data.pointer.is_const, ptr_type->data.pointer.is_volatile,
...	...	@@ -14306,7 +14306,7 @@ static TypeTableEntry ir_analyze_instruction_elem_ptr(IrAnalyze ira, IrInstruc
14306	14306	return ira->codegen->builtin_types.entry_invalid;
14307	14307	}
14308	14308
14309		TypeTableEntry *usize = ira->codegen->builtin_types.entry_usize;
	14309	ZigType *usize = ira->codegen->builtin_types.entry_usize;
14310	14310	IrInstruction *casted_elem_index = ir_implicit_cast(ira, elem_index, usize);
14311	14311	if (casted_elem_index == ira->codegen->invalid_instruction)
14312	14312	return ira->codegen->builtin_types.entry_invalid;
...	...	@@ -14496,8 +14496,8 @@ static TypeTableEntry ir_analyze_instruction_elem_ptr(IrAnalyze ira, IrInstruc
14496	14496	}
14497	14497
14498	14498	static IrInstruction ir_analyze_container_member_access_inner(IrAnalyze ira,
14499		TypeTableEntry bare_struct_type, Buf field_name, IrInstruction *source_instr,
14500		IrInstruction container_ptr, TypeTableEntry container_type)
	14499	ZigType bare_struct_type, Buf field_name, IrInstruction *source_instr,
	14500	IrInstruction container_ptr, ZigType container_type)
14501	14501	{
14502	14502	if (!is_slice(bare_struct_type)) {
14503	14503	ScopeDecls *container_scope = get_container_scope(bare_struct_type);
...	...	@@ -14536,11 +14536,11 @@ static IrInstruction ir_analyze_container_member_access_inner(IrAnalyze ira,
14536	14536	}
14537	14537
14538	14538	static IrInstruction ir_analyze_container_field_ptr(IrAnalyze ira, Buf *field_name,
14539		IrInstruction source_instr, IrInstruction container_ptr, TypeTableEntry *container_type)
	14539	IrInstruction source_instr, IrInstruction container_ptr, ZigType *container_type)
14540	14540	{
14541	14541	Error err;
14542	14542
14543		TypeTableEntry *bare_type = container_ref_type(container_type);
	14543	ZigType *bare_type = container_ref_type(container_type);
14544	14544	if ((err = ensure_complete_type(ira->codegen, bare_type)))
14545	14545	return ira->codegen->invalid_instruction;
14546	14546
...	...	@@ -14568,7 +14568,7 @@ static IrInstruction ir_analyze_container_field_ptr(IrAnalyze ira, Buf *field_
14568	14568	if (type_is_invalid(struct_val->type))
14569	14569	return ira->codegen->invalid_instruction;
14570	14570	ConstExprValue *field_val = &struct_val->data.x_struct.fields[field->src_index];
14571		TypeTableEntry *ptr_type = get_pointer_to_type_extra(ira->codegen, field_val->type,
	14571	ZigType *ptr_type = get_pointer_to_type_extra(ira->codegen, field_val->type,
14572	14572	is_const, is_volatile, PtrLenSingle, align_bytes,
14573	14573	(uint32_t)(ptr_bit_offset + field->packed_bits_offset),
14574	14574	(uint32_t)unaligned_bit_count_for_result_type);
...	...	@@ -14625,7 +14625,7 @@ static IrInstruction ir_analyze_container_field_ptr(IrAnalyze ira, Buf *field_
14625	14625
14626	14626	ConstExprValue *payload_val = union_val->data.x_union.payload;
14627	14627
14628		TypeTableEntry *field_type = field->type_entry;
	14628	ZigType *field_type = field->type_entry;
14629	14629	if (field_type->id == TypeTableEntryIdVoid) {
14630	14630	assert(payload_val == nullptr);
14631	14631	payload_val = create_const_vals(1);
...	...	@@ -14633,7 +14633,7 @@ static IrInstruction ir_analyze_container_field_ptr(IrAnalyze ira, Buf *field_
14633	14633	payload_val->type = field_type;
14634	14634	}
14635	14635
14636		TypeTableEntry *ptr_type = get_pointer_to_type_extra(ira->codegen, field_type,
	14636	ZigType *ptr_type = get_pointer_to_type_extra(ira->codegen, field_type,
14637	14637	is_const, is_volatile,
14638	14638	PtrLenSingle,
14639	14639	get_abi_alignment(ira->codegen, field_type), 0, 0);
...	...	@@ -14680,7 +14680,7 @@ static void add_link_lib_symbol(IrAnalyze ira, Buf lib_name, Buf *symbol_name,
14680	14680	}
14681	14681
14682	14682
14683		static TypeTableEntry ir_analyze_decl_ref(IrAnalyze ira, IrInstruction source_instruction, Tld tld) {
	14683	static ZigType ir_analyze_decl_ref(IrAnalyze ira, IrInstruction source_instruction, Tld tld) {
14684	14684	bool pointer_only = false;
14685	14685	resolve_top_level_decl(ira->codegen, tld, pointer_only, source_instruction->source_node);
14686	14686	if (tld->resolution == TldResolutionInvalid)
...	...	@@ -14731,7 +14731,7 @@ static TypeTableEntry ir_analyze_decl_ref(IrAnalyze ira, IrInstruction *source
14731	14731	zig_unreachable();
14732	14732	}
14733	14733
14734		static ErrorTableEntry find_err_table_entry(TypeTableEntry err_set_type, Buf *field_name) {
	14734	static ErrorTableEntry find_err_table_entry(ZigType err_set_type, Buf *field_name) {
14735	14735	assert(err_set_type->id == TypeTableEntryIdErrorSet);
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];
...	...	@@ -14742,13 +14742,13 @@ static ErrorTableEntry find_err_table_entry(TypeTableEntry err_set_type, Buf *
14742	14742	return nullptr;
14743	14743	}
14744	14744
14745		static TypeTableEntry ir_analyze_instruction_field_ptr(IrAnalyze ira, IrInstructionFieldPtr *field_ptr_instruction) {
	14745	static ZigType ir_analyze_instruction_field_ptr(IrAnalyze ira, IrInstructionFieldPtr *field_ptr_instruction) {
14746	14746	Error err;
14747	14747	IrInstruction *container_ptr = field_ptr_instruction->container_ptr->other;
14748	14748	if (type_is_invalid(container_ptr->value.type))
14749	14749	return ira->codegen->builtin_types.entry_invalid;
14750	14750
14751		TypeTableEntry *container_type = container_ptr->value.type->data.pointer.child_type;
	14751	ZigType *container_type = container_ptr->value.type->data.pointer.child_type;
14752	14752	assert(container_ptr->value.type->id == TypeTableEntryIdPointer);
14753	14753
14754	14754	Buf *field_name = field_ptr_instruction->field_name_buffer;
...	...	@@ -14767,7 +14767,7 @@ static TypeTableEntry ir_analyze_instruction_field_ptr(IrAnalyze ira, IrInstru
14767	14767	} else if (is_container_ref(container_type)) {
14768	14768	assert(container_ptr->value.type->id == TypeTableEntryIdPointer);
14769	14769	if (container_type->id == TypeTableEntryIdPointer) {
14770		TypeTableEntry *bare_type = container_ref_type(container_type);
	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);
14773	14773	ir_link_new_instruction(result, &field_ptr_instruction->base);
...	...	@@ -14786,7 +14786,7 @@ static TypeTableEntry ir_analyze_instruction_field_ptr(IrAnalyze ira, IrInstru
14786	14786	init_const_usize(ira->codegen, len_val, container_type->data.array.len);
14787	14787	}
14788	14788
14789		TypeTableEntry *usize = ira->codegen->builtin_types.entry_usize;
	14789	ZigType *usize = ira->codegen->builtin_types.entry_usize;
14790	14790	bool ptr_is_const = true;
14791	14791	bool ptr_is_volatile = false;
14792	14792	return ir_analyze_const_ptr(ira, &field_ptr_instruction->base, len_val,
...	...	@@ -14812,7 +14812,7 @@ static TypeTableEntry ir_analyze_instruction_field_ptr(IrAnalyze ira, IrInstru
14812	14812	size_t len = child_val->data.x_arg_tuple.end_index - child_val->data.x_arg_tuple.start_index;
14813	14813	init_const_usize(ira->codegen, len_val, len);
14814	14814
14815		TypeTableEntry *usize = ira->codegen->builtin_types.entry_usize;
	14815	ZigType *usize = ira->codegen->builtin_types.entry_usize;
14816	14816	bool ptr_is_const = true;
14817	14817	bool ptr_is_volatile = false;
14818	14818	return ir_analyze_const_ptr(ira, &field_ptr_instruction->base, len_val,
...	...	@@ -14832,7 +14832,7 @@ static TypeTableEntry ir_analyze_instruction_field_ptr(IrAnalyze ira, IrInstru
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;
14835		TypeTableEntry *child_type = child_val->data.x_type;
	14835	ZigType *child_type = child_val->data.x_type;
14836	14836
14837	14837	if (type_is_invalid(child_type)) {
14838	14838	return ira->codegen->builtin_types.entry_invalid;
...	...	@@ -14842,7 +14842,7 @@ static TypeTableEntry ir_analyze_instruction_field_ptr(IrAnalyze ira, IrInstru
14842	14842	bool ptr_is_volatile = false;
14843	14843	TypeStructField *ptr_field = &child_type->data.structure.fields[slice_ptr_index];
14844	14844	assert(ptr_field->type_entry->id == TypeTableEntryIdPointer);
14845		TypeTableEntry *child_type = ptr_field->type_entry->data.pointer.child_type;
	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,
...	...	@@ -14877,7 +14877,7 @@ static TypeTableEntry ir_analyze_instruction_field_ptr(IrAnalyze ira, IrInstru
14877	14877	return ira->codegen->builtin_types.entry_invalid;
14878	14878	TypeUnionField *field = find_union_type_field(child_type, field_name);
14879	14879	if (field) {
14880		TypeTableEntry *enum_type = child_type->data.unionation.tag_type;
	14880	ZigType *enum_type = child_type->data.unionation.tag_type;
14881	14881	bool ptr_is_const = true;
14882	14882	bool ptr_is_volatile = false;
14883	14883	return ir_analyze_const_ptr(ira, &field_ptr_instruction->base,
...	...	@@ -14891,7 +14891,7 @@ static TypeTableEntry ir_analyze_instruction_field_ptr(IrAnalyze ira, IrInstru
14891	14891	return ira->codegen->builtin_types.entry_invalid;
14892	14892	} else if (child_type->id == TypeTableEntryIdErrorSet) {
14893	14893	ErrorTableEntry *err_entry;
14894		TypeTableEntry *err_set_type;
	14894	ZigType *err_set_type;
14895	14895	if (type_is_global_error_set(child_type)) {
14896	14896	auto existing_entry = ira->codegen->error_table.maybe_get(field_name);
14897	14897	if (existing_entry) {
...	...	@@ -15131,7 +15131,7 @@ static TypeTableEntry ir_analyze_instruction_field_ptr(IrAnalyze ira, IrInstru
15131	15131	}
15132	15132	}
15133	15133
15134		static TypeTableEntry ir_analyze_instruction_load_ptr(IrAnalyze ira, IrInstructionLoadPtr *load_ptr_instruction) {
	15134	static ZigType ir_analyze_instruction_load_ptr(IrAnalyze ira, IrInstructionLoadPtr *load_ptr_instruction) {
15135	15135	IrInstruction *ptr = load_ptr_instruction->ptr->other;
15136	15136	if (type_is_invalid(ptr->value.type))
15137	15137	return ira->codegen->builtin_types.entry_invalid;
...	...	@@ -15142,7 +15142,7 @@ static TypeTableEntry ir_analyze_instruction_load_ptr(IrAnalyze ira, IrInstruc
15142	15142	return result->value.type;
15143	15143	}
15144	15144
15145		static TypeTableEntry ir_analyze_instruction_store_ptr(IrAnalyze ira, IrInstructionStorePtr *store_ptr_instruction) {
	15145	static ZigType ir_analyze_instruction_store_ptr(IrAnalyze ira, IrInstructionStorePtr *store_ptr_instruction) {
15146	15146	IrInstruction *ptr = store_ptr_instruction->ptr->other;
15147	15147	if (type_is_invalid(ptr->value.type))
15148	15148	return ptr->value.type;
...	...	@@ -15166,7 +15166,7 @@ static TypeTableEntry ir_analyze_instruction_store_ptr(IrAnalyze ira, IrInstru
15166	15166	return ira->codegen->builtin_types.entry_invalid;
15167	15167	}
15168	15168
15169		TypeTableEntry *child_type = ptr->value.type->data.pointer.child_type;
	15169	ZigType *child_type = ptr->value.type->data.pointer.child_type;
15170	15170	IrInstruction *casted_value = ir_implicit_cast(ira, value, child_type);
15171	15171	if (casted_value == ira->codegen->invalid_instruction)
15172	15172	return ira->codegen->builtin_types.entry_invalid;
...	...	@@ -15202,9 +15202,9 @@ static TypeTableEntry ir_analyze_instruction_store_ptr(IrAnalyze ira, IrInstru
15202	15202	return ira->codegen->builtin_types.entry_void;
15203	15203	}
15204	15204
15205		static TypeTableEntry ir_analyze_instruction_typeof(IrAnalyze ira, IrInstructionTypeOf *typeof_instruction) {
	15205	static ZigType ir_analyze_instruction_typeof(IrAnalyze ira, IrInstructionTypeOf *typeof_instruction) {
15206	15206	IrInstruction *expr_value = typeof_instruction->value->other;
15207		TypeTableEntry *type_entry = expr_value->value.type;
	15207	ZigType *type_entry = expr_value->value.type;
15208	15208	if (type_is_invalid(type_entry))
15209	15209	return ira->codegen->builtin_types.entry_invalid;
15210	15210	switch (type_entry->id) {
...	...	@@ -15246,15 +15246,15 @@ static TypeTableEntry ir_analyze_instruction_typeof(IrAnalyze ira, IrInstructi
15246	15246	zig_unreachable();
15247	15247	}
15248	15248
15249		static TypeTableEntry ir_analyze_instruction_to_ptr_type(IrAnalyze ira,
	15249	static ZigType ir_analyze_instruction_to_ptr_type(IrAnalyze ira,
15250	15250	IrInstructionToPtrType *to_ptr_type_instruction)
15251	15251	{
15252	15252	IrInstruction *value = to_ptr_type_instruction->value->other;
15253		TypeTableEntry *type_entry = value->value.type;
	15253	ZigType *type_entry = value->value.type;
15254	15254	if (type_is_invalid(type_entry))
15255	15255	return type_entry;
15256	15256
15257		TypeTableEntry *ptr_type;
	15257	ZigType *ptr_type;
15258	15258	if (type_entry->id == TypeTableEntryIdArray) {
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)) {
...	...	@@ -15275,11 +15275,11 @@ static TypeTableEntry ir_analyze_instruction_to_ptr_type(IrAnalyze ira,
15275	15275	return ira->codegen->builtin_types.entry_type;
15276	15276	}
15277	15277
15278		static TypeTableEntry ir_analyze_instruction_ptr_type_child(IrAnalyze ira,
	15278	static ZigType ir_analyze_instruction_ptr_type_child(IrAnalyze ira,
15279	15279	IrInstructionPtrTypeChild *ptr_type_child_instruction)
15280	15280	{
15281	15281	IrInstruction *type_value = ptr_type_child_instruction->value->other;
15282		TypeTableEntry *type_entry = ir_resolve_type(ira, type_value);
	15282	ZigType *type_entry = ir_resolve_type(ira, type_value);
15283	15283	if (type_is_invalid(type_entry))
15284	15284	return type_entry;
15285	15285
...	...	@@ -15294,7 +15294,7 @@ static TypeTableEntry ir_analyze_instruction_ptr_type_child(IrAnalyze ira,
15294	15294	return ira->codegen->builtin_types.entry_type;
15295	15295	}
15296	15296
15297		static TypeTableEntry ir_analyze_instruction_set_cold(IrAnalyze ira, IrInstructionSetCold *instruction) {
	15297	static ZigType ir_analyze_instruction_set_cold(IrAnalyze ira, IrInstructionSetCold *instruction) {
15298	15298	if (ira->new_irb.exec->is_inline) {
15299	15299	// ignore setCold when running functions at compile time
15300	15300	ir_build_const_from(ira, &instruction->base);
...	...	@@ -15324,7 +15324,7 @@ static TypeTableEntry ir_analyze_instruction_set_cold(IrAnalyze ira, IrInstruc
15324	15324	ir_build_const_from(ira, &instruction->base);
15325	15325	return ira->codegen->builtin_types.entry_void;
15326	15326	}
15327		static TypeTableEntry ir_analyze_instruction_set_runtime_safety(IrAnalyze ira,
	15327	static ZigType ir_analyze_instruction_set_runtime_safety(IrAnalyze ira,
15328	15328	IrInstructionSetRuntimeSafety *set_runtime_safety_instruction)
15329	15329	{
15330	15330	if (ira->new_irb.exec->is_inline) {
...	...	@@ -15381,11 +15381,11 @@ static TypeTableEntry ir_analyze_instruction_set_runtime_safety(IrAnalyze ira,
15381	15381	return ira->codegen->builtin_types.entry_void;
15382	15382	}
15383	15383
15384		static TypeTableEntry ir_analyze_instruction_set_float_mode(IrAnalyze ira,
	15384	static ZigType ir_analyze_instruction_set_float_mode(IrAnalyze ira,
15385	15385	IrInstructionSetFloatMode *instruction)
15386	15386	{
15387	15387	IrInstruction *target_instruction = instruction->scope_value->other;
15388		TypeTableEntry *target_type = target_instruction->value.type;
	15388	ZigType *target_type = target_instruction->value.type;
15389	15389	if (type_is_invalid(target_type))
15390	15390	return ira->codegen->builtin_types.entry_invalid;
15391	15391	ConstExprValue *target_val = ir_resolve_const(ira, target_instruction, UndefBad);
...	...	@@ -15412,7 +15412,7 @@ static TypeTableEntry ir_analyze_instruction_set_float_mode(IrAnalyze ira,
15412	15412	fast_math_set_node_ptr = &target_fn->def_scope->fast_math_set_node;
15413	15413	} else if (target_type->id == TypeTableEntryIdMetaType) {
15414	15414	ScopeDecls *decls_scope;
15415		TypeTableEntry *type_arg = target_val->data.x_type;
	15415	ZigType *type_arg = target_val->data.x_type;
15416	15416	if (type_arg->id == TypeTableEntryIdStruct) {
15417	15417	decls_scope = type_arg->data.structure.decls_scope;
15418	15418	} else if (type_arg->id == TypeTableEntryIdEnum) {
...	...	@@ -15452,7 +15452,7 @@ static TypeTableEntry ir_analyze_instruction_set_float_mode(IrAnalyze ira,
15452	15452	return ira->codegen->builtin_types.entry_void;
15453	15453	}
15454	15454
15455		static TypeTableEntry ir_analyze_instruction_slice_type(IrAnalyze ira,
	15455	static ZigType ir_analyze_instruction_slice_type(IrAnalyze ira,
15456	15456	IrInstructionSliceType *slice_type_instruction)
15457	15457	{
15458	15458	Error err;
...	...	@@ -15462,7 +15462,7 @@ static TypeTableEntry ir_analyze_instruction_slice_type(IrAnalyze ira,
15462	15462	return ira->codegen->builtin_types.entry_invalid;
15463	15463	}
15464	15464
15465		TypeTableEntry *child_type = ir_resolve_type(ira, slice_type_instruction->child_type->other);
	15465	ZigType *child_type = ir_resolve_type(ira, slice_type_instruction->child_type->other);
15466	15466	if (type_is_invalid(child_type))
15467	15467	return ira->codegen->builtin_types.entry_invalid;
15468	15468
...	...	@@ -15509,9 +15509,9 @@ static TypeTableEntry ir_analyze_instruction_slice_type(IrAnalyze ira,
15509	15509	{
15510	15510	if ((err = type_ensure_zero_bits_known(ira->codegen, child_type)))
15511	15511	return ira->codegen->builtin_types.entry_invalid;
15512		TypeTableEntry *slice_ptr_type = get_pointer_to_type_extra(ira->codegen, child_type,
	15512	ZigType *slice_ptr_type = get_pointer_to_type_extra(ira->codegen, child_type,
15513	15513	is_const, is_volatile, PtrLenUnknown, align_bytes, 0, 0);
15514		TypeTableEntry *result_type = get_slice_type(ira->codegen, slice_ptr_type);
	15514	ZigType *result_type = get_slice_type(ira->codegen, slice_ptr_type);
15515	15515	ConstExprValue *out_val = ir_build_const_from(ira, &slice_type_instruction->base);
15516	15516	out_val->data.x_type = result_type;
15517	15517	return ira->codegen->builtin_types.entry_type;
...	...	@@ -15520,7 +15520,7 @@ static TypeTableEntry ir_analyze_instruction_slice_type(IrAnalyze ira,
15520	15520	zig_unreachable();
15521	15521	}
15522	15522
15523		static TypeTableEntry ir_analyze_instruction_asm(IrAnalyze ira, IrInstructionAsm *asm_instruction) {
	15523	static ZigType ir_analyze_instruction_asm(IrAnalyze ira, IrInstructionAsm *asm_instruction) {
15524	15524	assert(asm_instruction->base.source_node->type == NodeTypeAsmExpr);
15525	15525
15526	15526	AstNodeAsmExpr *asm_expr = &asm_instruction->base.source_node->data.asm_expr;
...	...	@@ -15550,7 +15550,7 @@ static TypeTableEntry ir_analyze_instruction_asm(IrAnalyze ira, IrInstructionA
15550	15550	IrInstruction *input_list = allocate<IrInstruction >(asm_expr->input_list.length);
15551	15551	IrInstruction *output_types = allocate<IrInstruction >(asm_expr->output_list.length);
15552	15552
15553		TypeTableEntry *return_type = ira->codegen->builtin_types.entry_void;
	15553	ZigType *return_type = ira->codegen->builtin_types.entry_void;
15554	15554	for (size_t i = 0; i < asm_expr->output_list.length; i += 1) {
15555	15555	AsmOutput *asm_output = asm_expr->output_list.at(i);
15556	15556	if (asm_output->return_type) {
...	...	@@ -15572,7 +15572,7 @@ static TypeTableEntry ir_analyze_instruction_asm(IrAnalyze ira, IrInstructionA
15572	15572	return return_type;
15573	15573	}
15574	15574
15575		static TypeTableEntry ir_analyze_instruction_array_type(IrAnalyze ira,
	15575	static ZigType ir_analyze_instruction_array_type(IrAnalyze ira,
15576	15576	IrInstructionArrayType *array_type_instruction)
15577	15577	{
15578	15578	Error err;
...	...	@@ -15583,7 +15583,7 @@ static TypeTableEntry ir_analyze_instruction_array_type(IrAnalyze ira,
15583	15583	return ira->codegen->builtin_types.entry_invalid;
15584	15584
15585	15585	IrInstruction *child_type_value = array_type_instruction->child_type->other;
15586		TypeTableEntry *child_type = ir_resolve_type(ira, child_type_value);
	15586	ZigType *child_type = ir_resolve_type(ira, child_type_value);
15587	15587	if (type_is_invalid(child_type))
15588	15588	return ira->codegen->builtin_types.entry_invalid;
15589	15589	switch (child_type->id) {
...	...	@@ -15620,7 +15620,7 @@ static TypeTableEntry ir_analyze_instruction_array_type(IrAnalyze ira,
15620	15620	{
15621	15621	if ((err = ensure_complete_type(ira->codegen, child_type)))
15622	15622	return ira->codegen->builtin_types.entry_invalid;
15623		TypeTableEntry *result_type = get_array_type(ira->codegen, child_type, size);
	15623	ZigType *result_type = get_array_type(ira->codegen, child_type, size);
15624	15624	ConstExprValue *out_val = ir_build_const_from(ira, &array_type_instruction->base);
15625	15625	out_val->data.x_type = result_type;
15626	15626	return ira->codegen->builtin_types.entry_type;
...	...	@@ -15629,13 +15629,13 @@ static TypeTableEntry ir_analyze_instruction_array_type(IrAnalyze ira,
15629	15629	zig_unreachable();
15630	15630	}
15631	15631
15632		static TypeTableEntry ir_analyze_instruction_promise_type(IrAnalyze ira, IrInstructionPromiseType *instruction) {
15633		TypeTableEntry *promise_type;
	15632	static ZigType ir_analyze_instruction_promise_type(IrAnalyze ira, IrInstructionPromiseType *instruction) {
	15633	ZigType *promise_type;
15634	15634
15635	15635	if (instruction->payload_type == nullptr) {
15636	15636	promise_type = ira->codegen->builtin_types.entry_promise;
15637	15637	} else {
15638		TypeTableEntry *payload_type = ir_resolve_type(ira, instruction->payload_type->other);
	15638	ZigType *payload_type = ir_resolve_type(ira, instruction->payload_type->other);
15639	15639	if (type_is_invalid(payload_type))
15640	15640	return ira->codegen->builtin_types.entry_invalid;
15641	15641
...	...	@@ -15647,12 +15647,12 @@ static TypeTableEntry ir_analyze_instruction_promise_type(IrAnalyze ira, IrIns
15647	15647	return ira->codegen->builtin_types.entry_type;
15648	15648	}
15649	15649
15650		static TypeTableEntry ir_analyze_instruction_size_of(IrAnalyze ira,
	15650	static ZigType ir_analyze_instruction_size_of(IrAnalyze ira,
15651	15651	IrInstructionSizeOf *size_of_instruction)
15652	15652	{
15653	15653	Error err;
15654	15654	IrInstruction *type_value = size_of_instruction->type_value->other;
15655		TypeTableEntry *type_entry = ir_resolve_type(ira, type_value);
	15655	ZigType *type_entry = ir_resolve_type(ira, type_value);
15656	15656
15657	15657	if ((err = ensure_complete_type(ira->codegen, type_entry)))
15658	15658	return ira->codegen->builtin_types.entry_invalid;
...	...	@@ -15698,12 +15698,12 @@ static TypeTableEntry ir_analyze_instruction_size_of(IrAnalyze ira,
15698	15698	zig_unreachable();
15699	15699	}
15700	15700
15701		static TypeTableEntry ir_analyze_instruction_test_non_null(IrAnalyze ira, IrInstructionTestNonNull *instruction) {
	15701	static ZigType ir_analyze_instruction_test_non_null(IrAnalyze ira, IrInstructionTestNonNull *instruction) {
15702	15702	IrInstruction *value = instruction->value->other;
15703	15703	if (type_is_invalid(value->value.type))
15704	15704	return ira->codegen->builtin_types.entry_invalid;
15705	15705
15706		TypeTableEntry *type_entry = value->value.type;
	15706	ZigType *type_entry = value->value.type;
15707	15707
15708	15708	if (type_entry->id == TypeTableEntryIdOptional) {
15709	15709	if (instr_is_comptime(value)) {
...	...	@@ -15729,17 +15729,17 @@ static TypeTableEntry ir_analyze_instruction_test_non_null(IrAnalyze ira, IrIn
15729	15729	}
15730	15730	}
15731	15731
15732		static TypeTableEntry ir_analyze_instruction_unwrap_maybe(IrAnalyze ira,
	15732	static ZigType ir_analyze_instruction_unwrap_maybe(IrAnalyze ira,
15733	15733	IrInstructionUnwrapOptional *unwrap_maybe_instruction)
15734	15734	{
15735	15735	IrInstruction *value = unwrap_maybe_instruction->value->other;
15736	15736	if (type_is_invalid(value->value.type))
15737	15737	return ira->codegen->builtin_types.entry_invalid;
15738	15738
15739		TypeTableEntry *ptr_type = value->value.type;
	15739	ZigType *ptr_type = value->value.type;
15740	15740	assert(ptr_type->id == TypeTableEntryIdPointer);
15741	15741
15742		TypeTableEntry *type_entry = ptr_type->data.pointer.child_type;
	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	15745	} else if (type_entry->id != TypeTableEntryIdOptional) {
...	...	@@ -15747,8 +15747,8 @@ static TypeTableEntry ir_analyze_instruction_unwrap_maybe(IrAnalyze ira,
15747	15747	buf_sprintf("expected optional type, found '%s'", buf_ptr(&type_entry->name)));
15748	15748	return ira->codegen->builtin_types.entry_invalid;
15749	15749	}
15750		TypeTableEntry *child_type = type_entry->data.maybe.child_type;
15751		TypeTableEntry *result_type = get_pointer_to_type_extra(ira->codegen, child_type,
	15750	ZigType *child_type = type_entry->data.maybe.child_type;
	15751	ZigType *result_type = get_pointer_to_type_extra(ira->codegen, child_type,
15752	15752	ptr_type->data.pointer.is_const, ptr_type->data.pointer.is_volatile,
15753	15753	PtrLenSingle,
15754	15754	get_abi_alignment(ira->codegen, child_type), 0, 0);
...	...	@@ -15783,12 +15783,12 @@ static TypeTableEntry ir_analyze_instruction_unwrap_maybe(IrAnalyze ira,
15783	15783	return result_type;
15784	15784	}
15785	15785
15786		static TypeTableEntry ir_analyze_instruction_ctz(IrAnalyze ira, IrInstructionCtz *ctz_instruction) {
	15786	static ZigType ir_analyze_instruction_ctz(IrAnalyze ira, IrInstructionCtz *ctz_instruction) {
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	15790	} else if (value->value.type->id == TypeTableEntryIdInt) {
15791		TypeTableEntry *return_type = get_smallest_unsigned_int_type(ira->codegen,
	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) {
15794	15794	size_t result = bigint_ctz(&value->value.data.x_bigint,
...	...	@@ -15807,12 +15807,12 @@ static TypeTableEntry ir_analyze_instruction_ctz(IrAnalyze ira, IrInstructionC
15807	15807	}
15808	15808	}
15809	15809
15810		static TypeTableEntry ir_analyze_instruction_clz(IrAnalyze ira, IrInstructionClz *clz_instruction) {
	15810	static ZigType ir_analyze_instruction_clz(IrAnalyze ira, IrInstructionClz *clz_instruction) {
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	15814	} else if (value->value.type->id == TypeTableEntryIdInt) {
15815		TypeTableEntry *return_type = get_smallest_unsigned_int_type(ira->codegen,
	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) {
15818	15818	size_t result = bigint_clz(&value->value.data.x_bigint,
...	...	@@ -15831,7 +15831,7 @@ static TypeTableEntry ir_analyze_instruction_clz(IrAnalyze ira, IrInstructionC
15831	15831	}
15832	15832	}
15833	15833
15834		static TypeTableEntry ir_analyze_instruction_pop_count(IrAnalyze ira, IrInstructionPopCount *instruction) {
	15834	static ZigType ir_analyze_instruction_pop_count(IrAnalyze ira, IrInstructionPopCount *instruction) {
15835	15835	IrInstruction *value = instruction->value->other;
15836	15836	if (type_is_invalid(value->value.type))
15837	15837	return ira->codegen->builtin_types.entry_invalid;
...	...	@@ -15895,7 +15895,7 @@ static IrInstruction ir_analyze_union_tag(IrAnalyze ira, IrInstruction *source
15895	15895	return ira->codegen->invalid_instruction;
15896	15896	}
15897	15897
15898		TypeTableEntry *tag_type = value->value.type->data.unionation.tag_type;
	15898	ZigType *tag_type = value->value.type->data.unionation.tag_type;
15899	15899	assert(tag_type->id == TypeTableEntryIdEnum);
15900	15900
15901	15901	if (instr_is_comptime(value)) {
...	...	@@ -15916,7 +15916,7 @@ static IrInstruction ir_analyze_union_tag(IrAnalyze ira, IrInstruction *source
15916	15916	return result;
15917	15917	}
15918	15918
15919		static TypeTableEntry ir_analyze_instruction_switch_br(IrAnalyze ira,
	15919	static ZigType ir_analyze_instruction_switch_br(IrAnalyze ira,
15920	15920	IrInstructionSwitchBr *switch_br_instruction)
15921	15921	{
15922	15922	IrInstruction *target_value = switch_br_instruction->target_value->other;
...	...	@@ -16024,7 +16024,7 @@ static TypeTableEntry ir_analyze_instruction_switch_br(IrAnalyze ira,
16024	16024	return ir_finish_anal(ira, ira->codegen->builtin_types.entry_unreachable);
16025	16025	}
16026	16026
16027		static TypeTableEntry ir_analyze_instruction_switch_target(IrAnalyze ira,
	16027	static ZigType ir_analyze_instruction_switch_target(IrAnalyze ira,
16028	16028	IrInstructionSwitchTarget *switch_target_instruction)
16029	16029	{
16030	16030	Error err;
...	...	@@ -16034,7 +16034,7 @@ static TypeTableEntry ir_analyze_instruction_switch_target(IrAnalyze ira,
16034	16034
16035	16035	if (target_value_ptr->value.type->id == TypeTableEntryIdMetaType) {
16036	16036	assert(instr_is_comptime(target_value_ptr));
16037		TypeTableEntry *ptr_type = target_value_ptr->value.data.x_type;
	16037	ZigType *ptr_type = target_value_ptr->value.data.x_type;
16038	16038	assert(ptr_type->id == TypeTableEntryIdPointer);
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;
...	...	@@ -16047,7 +16047,7 @@ static TypeTableEntry ir_analyze_instruction_switch_target(IrAnalyze ira,
16047	16047	return ira->codegen->builtin_types.entry_invalid;
16048	16048	}
16049	16049
16050		TypeTableEntry *target_type = target_value_ptr->value.type->data.pointer.child_type;
	16050	ZigType *target_type = target_value_ptr->value.type->data.pointer.child_type;
16051	16051	ConstExprValue *pointee_val = nullptr;
16052	16052	if (instr_is_comptime(target_value_ptr)) {
16053	16053	pointee_val = ir_const_ptr_pointee(ira, &target_value_ptr->value, target_value_ptr->source_node);
...	...	@@ -16095,7 +16095,7 @@ static TypeTableEntry ir_analyze_instruction_switch_target(IrAnalyze ira,
16095	16095	buf_sprintf("consider 'union(enum)' here"));
16096	16096	return ira->codegen->builtin_types.entry_invalid;
16097	16097	}
16098		TypeTableEntry *tag_type = target_type->data.unionation.tag_type;
	16098	ZigType *tag_type = target_type->data.unionation.tag_type;
16099	16099	assert(tag_type != nullptr);
16100	16100	assert(tag_type->id == TypeTableEntryIdEnum);
16101	16101	if (pointee_val) {
...	...	@@ -16160,7 +16160,7 @@ static TypeTableEntry ir_analyze_instruction_switch_target(IrAnalyze ira,
16160	16160	zig_unreachable();
16161	16161	}
16162	16162
16163		static TypeTableEntry ir_analyze_instruction_switch_var(IrAnalyze ira, IrInstructionSwitchVar *instruction) {
	16163	static ZigType ir_analyze_instruction_switch_var(IrAnalyze ira, IrInstructionSwitchVar *instruction) {
16164	16164	IrInstruction *target_value_ptr = instruction->target_value_ptr->other;
16165	16165	if (type_is_invalid(target_value_ptr->value.type))
16166	16166	return ira->codegen->builtin_types.entry_invalid;
...	...	@@ -16170,7 +16170,7 @@ static TypeTableEntry ir_analyze_instruction_switch_var(IrAnalyze ira, IrInstr
16170	16170	return ira->codegen->builtin_types.entry_invalid;
16171	16171
16172	16172	assert(target_value_ptr->value.type->id == TypeTableEntryIdPointer);
16173		TypeTableEntry *target_type = target_value_ptr->value.type->data.pointer.child_type;
	16173	ZigType *target_type = target_value_ptr->value.type->data.pointer.child_type;
16174	16174	if (target_type->id == TypeTableEntryIdUnion) {
16175	16175	ConstExprValue *prong_val = ir_resolve_const(ira, prong_value, UndefBad);
16176	16176	if (!prong_val)
...	...	@@ -16205,14 +16205,14 @@ static TypeTableEntry ir_analyze_instruction_switch_var(IrAnalyze ira, IrInstr
16205	16205	}
16206	16206	}
16207	16207
16208		static TypeTableEntry ir_analyze_instruction_union_tag(IrAnalyze ira, IrInstructionUnionTag *instruction) {
	16208	static ZigType ir_analyze_instruction_union_tag(IrAnalyze ira, IrInstructionUnionTag *instruction) {
16209	16209	IrInstruction *value = instruction->value->other;
16210	16210	IrInstruction *new_instruction = ir_analyze_union_tag(ira, &instruction->base, value);
16211	16211	ir_link_new_instruction(new_instruction, &instruction->base);
16212	16212	return new_instruction->value.type;
16213	16213	}
16214	16214
16215		static TypeTableEntry ir_analyze_instruction_import(IrAnalyze ira, IrInstructionImport *import_instruction) {
	16215	static ZigType ir_analyze_instruction_import(IrAnalyze ira, IrInstructionImport *import_instruction) {
16216	16216	IrInstruction *name_value = import_instruction->name->other;
16217	16217	Buf *import_target_str = ir_resolve_str(ira, name_value);
16218	16218	if (!import_target_str)
...	...	@@ -16278,11 +16278,11 @@ static TypeTableEntry ir_analyze_instruction_import(IrAnalyze ira, IrInstructi
16278	16278
16279	16279	}
16280	16280
16281		static TypeTableEntry ir_analyze_instruction_array_len(IrAnalyze ira,
	16281	static ZigType ir_analyze_instruction_array_len(IrAnalyze ira,
16282	16282	IrInstructionArrayLen *array_len_instruction)
16283	16283	{
16284	16284	IrInstruction *array_value = array_len_instruction->array_value->other;
16285		TypeTableEntry *type_entry = array_value->value.type;
	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	16288	} else if (type_entry->id == TypeTableEntryIdArray) {
...	...	@@ -16309,13 +16309,13 @@ static TypeTableEntry ir_analyze_instruction_array_len(IrAnalyze ira,
16309	16309	}
16310	16310	}
16311	16311
16312		static TypeTableEntry ir_analyze_instruction_ref(IrAnalyze ira, IrInstructionRef *ref_instruction) {
	16312	static ZigType ir_analyze_instruction_ref(IrAnalyze ira, IrInstructionRef *ref_instruction) {
16313	16313	IrInstruction *value = ref_instruction->value->other;
16314	16314	return ir_analyze_ref(ira, &ref_instruction->base, value, ref_instruction->is_const, ref_instruction->is_volatile);
16315	16315	}
16316	16316
16317		static TypeTableEntry ir_analyze_container_init_fields_union(IrAnalyze ira, IrInstruction *instruction,
16318		TypeTableEntry container_type, size_t instr_field_count, IrInstructionContainerInitFieldsField fields)
	16317	static ZigType ir_analyze_container_init_fields_union(IrAnalyze ira, IrInstruction *instruction,
	16318	ZigType container_type, size_t instr_field_count, IrInstructionContainerInitFieldsField fields)
16319	16319	{
16320	16320	Error err;
16321	16321	assert(container_type->id == TypeTableEntryIdUnion);
...	...	@@ -16380,8 +16380,8 @@ static TypeTableEntry ir_analyze_container_init_fields_union(IrAnalyze ira, Ir
16380	16380	return container_type;
16381	16381	}
16382	16382
16383		static TypeTableEntry ir_analyze_container_init_fields(IrAnalyze ira, IrInstruction *instruction,
16384		TypeTableEntry container_type, size_t instr_field_count, IrInstructionContainerInitFieldsField fields)
	16383	static ZigType ir_analyze_container_init_fields(IrAnalyze ira, IrInstruction *instruction,
	16384	ZigType container_type, size_t instr_field_count, IrInstructionContainerInitFieldsField fields)
16385	16385	{
16386	16386	Error err;
16387	16387	if (container_type->id == TypeTableEntryIdUnion) {
...	...	@@ -16500,7 +16500,7 @@ static TypeTableEntry ir_analyze_container_init_fields(IrAnalyze ira, IrInstru
16500	16500	return container_type;
16501	16501	}
16502	16502
16503		static TypeTableEntry ir_analyze_instruction_container_init_list(IrAnalyze ira,
	16503	static ZigType ir_analyze_instruction_container_init_list(IrAnalyze ira,
16504	16504	IrInstructionContainerInitList *instruction)
16505	16505	{
16506	16506	IrInstruction *container_type_value = instruction->container_type->other;
...	...	@@ -16509,7 +16509,7 @@ static TypeTableEntry ir_analyze_instruction_container_init_list(IrAnalyze ira
16509	16509
16510	16510	size_t elem_count = instruction->item_count;
16511	16511	if (container_type_value->value.type->id == TypeTableEntryIdMetaType) {
16512		TypeTableEntry *container_type = ir_resolve_type(ira, container_type_value);
	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
...	...	@@ -16518,11 +16518,11 @@ static TypeTableEntry ir_analyze_instruction_container_init_list(IrAnalyze ira
16518	16518	0, nullptr);
16519	16519	} else if (is_slice(container_type) \|\| container_type->id == TypeTableEntryIdArray) {
16520	16520	// array is same as slice init but we make a compile error if the length is wrong
16521		TypeTableEntry *child_type;
	16521	ZigType *child_type;
16522	16522	if (container_type->id == TypeTableEntryIdArray) {
16523	16523	child_type = container_type->data.array.child_type;
16524	16524	if (container_type->data.array.len != elem_count) {
16525		TypeTableEntry *literal_type = get_array_type(ira->codegen, child_type, elem_count);
	16525	ZigType *literal_type = get_array_type(ira->codegen, child_type, elem_count);
16526	16526
16527	16527	ir_add_error(ira, &instruction->base,
16528	16528	buf_sprintf("expected %s literal, found %s literal",
...	...	@@ -16530,12 +16530,12 @@ static TypeTableEntry ir_analyze_instruction_container_init_list(IrAnalyze ira
16530	16530	return ira->codegen->builtin_types.entry_invalid;
16531	16531	}
16532	16532	} else {
16533		TypeTableEntry *pointer_type = container_type->data.structure.fields[slice_ptr_index].type_entry;
	16533	ZigType *pointer_type = container_type->data.structure.fields[slice_ptr_index].type_entry;
16534	16534	assert(pointer_type->id == TypeTableEntryIdPointer);
16535	16535	child_type = pointer_type->data.pointer.child_type;
16536	16536	}
16537	16537
16538		TypeTableEntry *fixed_size_array_type = get_array_type(ira->codegen, child_type, elem_count);
	16538	ZigType *fixed_size_array_type = get_array_type(ira->codegen, child_type, elem_count);
16539	16539
16540	16540	ConstExprValue const_val = {};
16541	16541	const_val.special = ConstValSpecialStatic;
...	...	@@ -16618,9 +16618,9 @@ static TypeTableEntry ir_analyze_instruction_container_init_list(IrAnalyze ira
16618	16618	}
16619	16619	}
16620	16620
16621		static TypeTableEntry ir_analyze_instruction_container_init_fields(IrAnalyze ira, IrInstructionContainerInitFields *instruction) {
	16621	static ZigType ir_analyze_instruction_container_init_fields(IrAnalyze ira, IrInstructionContainerInitFields *instruction) {
16622	16622	IrInstruction *container_type_value = instruction->container_type->other;
16623		TypeTableEntry *container_type = ir_resolve_type(ira, container_type_value);
	16623	ZigType *container_type = ir_resolve_type(ira, container_type_value);
16624	16624	if (type_is_invalid(container_type))
16625	16625	return ira->codegen->builtin_types.entry_invalid;
16626	16626
...	...	@@ -16628,10 +16628,10 @@ static TypeTableEntry ir_analyze_instruction_container_init_fields(IrAnalyze i
16628	16628	instruction->field_count, instruction->fields);
16629	16629	}
16630	16630
16631		static TypeTableEntry ir_analyze_min_max(IrAnalyze ira, IrInstruction *source_instruction,
	16631	static ZigType ir_analyze_min_max(IrAnalyze ira, IrInstruction *source_instruction,
16632	16632	IrInstruction *target_type_value, bool is_max)
16633	16633	{
16634		TypeTableEntry *target_type = ir_resolve_type(ira, target_type_value);
	16634	ZigType *target_type = ir_resolve_type(ira, target_type_value);
16635	16635	if (type_is_invalid(target_type))
16636	16636	return ira->codegen->builtin_types.entry_invalid;
16637	16637	switch (target_type->id) {
...	...	@@ -16684,19 +16684,19 @@ static TypeTableEntry ir_analyze_min_max(IrAnalyze ira, IrInstruction *source_
16684	16684	zig_unreachable();
16685	16685	}
16686	16686
16687		static TypeTableEntry ir_analyze_instruction_min_value(IrAnalyze ira,
	16687	static ZigType ir_analyze_instruction_min_value(IrAnalyze ira,
16688	16688	IrInstructionMinValue *instruction)
16689	16689	{
16690	16690	return ir_analyze_min_max(ira, &instruction->base, instruction->value->other, false);
16691	16691	}
16692	16692
16693		static TypeTableEntry ir_analyze_instruction_max_value(IrAnalyze ira,
	16693	static ZigType ir_analyze_instruction_max_value(IrAnalyze ira,
16694	16694	IrInstructionMaxValue *instruction)
16695	16695	{
16696	16696	return ir_analyze_min_max(ira, &instruction->base, instruction->value->other, true);
16697	16697	}
16698	16698
16699		static TypeTableEntry ir_analyze_instruction_compile_err(IrAnalyze ira,
	16699	static ZigType ir_analyze_instruction_compile_err(IrAnalyze ira,
16700	16700	IrInstructionCompileErr *instruction)
16701	16701	{
16702	16702	IrInstruction *msg_value = instruction->msg->other;
...	...	@@ -16720,7 +16720,7 @@ static TypeTableEntry ir_analyze_instruction_compile_err(IrAnalyze ira,
16720	16720	return ira->codegen->builtin_types.entry_invalid;
16721	16721	}
16722	16722
16723		static TypeTableEntry ir_analyze_instruction_compile_log(IrAnalyze ira, IrInstructionCompileLog *instruction) {
	16723	static ZigType ir_analyze_instruction_compile_log(IrAnalyze ira, IrInstructionCompileLog *instruction) {
16724	16724	Buf buf = BUF_INIT;
16725	16725	fprintf(stderr, "\| ");
16726	16726	for (size_t i = 0; i < instruction->msg_count; i += 1) {
...	...	@@ -16740,7 +16740,7 @@ static TypeTableEntry ir_analyze_instruction_compile_log(IrAnalyze ira, IrInst
16740	16740	return ira->codegen->builtin_types.entry_void;
16741	16741	}
16742	16742
16743		static TypeTableEntry ir_analyze_instruction_err_name(IrAnalyze ira, IrInstructionErrName *instruction) {
	16743	static ZigType ir_analyze_instruction_err_name(IrAnalyze ira, IrInstructionErrName *instruction) {
16744	16744	IrInstruction *value = instruction->value->other;
16745	16745	if (type_is_invalid(value->value.type))
16746	16746	return ira->codegen->builtin_types.entry_invalid;
...	...	@@ -16749,9 +16749,9 @@ static TypeTableEntry ir_analyze_instruction_err_name(IrAnalyze ira, IrInstruc
16749	16749	if (type_is_invalid(casted_value->value.type))
16750	16750	return ira->codegen->builtin_types.entry_invalid;
16751	16751
16752		TypeTableEntry *u8_ptr_type = get_pointer_to_type_extra(ira->codegen, ira->codegen->builtin_types.entry_u8,
	16752	ZigType *u8_ptr_type = get_pointer_to_type_extra(ira->codegen, ira->codegen->builtin_types.entry_u8,
16753	16753	true, false, PtrLenUnknown, get_abi_alignment(ira->codegen, ira->codegen->builtin_types.entry_u8), 0, 0);
16754		TypeTableEntry *str_type = get_slice_type(ira->codegen, u8_ptr_type);
	16754	ZigType *str_type = get_slice_type(ira->codegen, u8_ptr_type);
16755	16755	if (casted_value->value.special == ConstValSpecialStatic) {
16756	16756	ErrorTableEntry *err = casted_value->value.data.x_err_set;
16757	16757	if (!err->cached_error_name_val) {
...	...	@@ -16768,7 +16768,7 @@ static TypeTableEntry ir_analyze_instruction_err_name(IrAnalyze ira, IrInstruc
16768	16768	return str_type;
16769	16769	}
16770	16770
16771		static TypeTableEntry ir_analyze_instruction_enum_tag_name(IrAnalyze ira, IrInstructionTagName *instruction) {
	16771	static ZigType ir_analyze_instruction_enum_tag_name(IrAnalyze ira, IrInstructionTagName *instruction) {
16772	16772	Error err;
16773	16773	IrInstruction *target = instruction->target->other;
16774	16774	if (type_is_invalid(target->value.type))
...	...	@@ -16789,7 +16789,7 @@ static TypeTableEntry ir_analyze_instruction_enum_tag_name(IrAnalyze ira, IrIn
16789	16789	IrInstruction *result = ir_build_tag_name(&ira->new_irb, instruction->base.scope,
16790	16790	instruction->base.source_node, target);
16791	16791	ir_link_new_instruction(result, &instruction->base);
16792		TypeTableEntry *u8_ptr_type = get_pointer_to_type_extra(
	16792	ZigType *u8_ptr_type = get_pointer_to_type_extra(
16793	16793	ira->codegen, ira->codegen->builtin_types.entry_u8,
16794	16794	true, false, PtrLenUnknown,
16795	16795	get_abi_alignment(ira->codegen, ira->codegen->builtin_types.entry_u8),
...	...	@@ -16798,12 +16798,12 @@ static TypeTableEntry ir_analyze_instruction_enum_tag_name(IrAnalyze ira, IrIn
16798	16798	return result->value.type;
16799	16799	}
16800	16800
16801		static TypeTableEntry ir_analyze_instruction_field_parent_ptr(IrAnalyze ira,
	16801	static ZigType ir_analyze_instruction_field_parent_ptr(IrAnalyze ira,
16802	16802	IrInstructionFieldParentPtr *instruction)
16803	16803	{
16804	16804	Error err;
16805	16805	IrInstruction *type_value = instruction->type_value->other;
16806		TypeTableEntry *container_type = ir_resolve_type(ira, type_value);
	16806	ZigType *container_type = ir_resolve_type(ira, type_value);
16807	16807	if (type_is_invalid(container_type))
16808	16808	return ira->codegen->builtin_types.entry_invalid;
16809	16809
...	...	@@ -16843,7 +16843,7 @@ static TypeTableEntry ir_analyze_instruction_field_parent_ptr(IrAnalyze ira,
16843	16843	uint32_t field_ptr_align = is_packed ? 1 : get_abi_alignment(ira->codegen, field->type_entry);
16844	16844	uint32_t parent_ptr_align = is_packed ? 1 : get_abi_alignment(ira->codegen, container_type);
16845	16845
16846		TypeTableEntry *field_ptr_type = get_pointer_to_type_extra(ira->codegen, field->type_entry,
	16846	ZigType *field_ptr_type = get_pointer_to_type_extra(ira->codegen, field->type_entry,
16847	16847	field_ptr->value.type->data.pointer.is_const,
16848	16848	field_ptr->value.type->data.pointer.is_volatile,
16849	16849	PtrLenSingle,
...	...	@@ -16852,7 +16852,7 @@ static TypeTableEntry ir_analyze_instruction_field_parent_ptr(IrAnalyze ira,
16852	16852	if (type_is_invalid(casted_field_ptr->value.type))
16853	16853	return ira->codegen->builtin_types.entry_invalid;
16854	16854
16855		TypeTableEntry *result_type = get_pointer_to_type_extra(ira->codegen, container_type,
	16855	ZigType *result_type = get_pointer_to_type_extra(ira->codegen, container_type,
16856	16856	casted_field_ptr->value.type->data.pointer.is_const,
16857	16857	casted_field_ptr->value.type->data.pointer.is_volatile,
16858	16858	PtrLenSingle,
...	...	@@ -16891,12 +16891,12 @@ static TypeTableEntry ir_analyze_instruction_field_parent_ptr(IrAnalyze ira,
16891	16891	return result_type;
16892	16892	}
16893	16893
16894		static TypeTableEntry ir_analyze_instruction_offset_of(IrAnalyze ira,
	16894	static ZigType ir_analyze_instruction_offset_of(IrAnalyze ira,
16895	16895	IrInstructionOffsetOf *instruction)
16896	16896	{
16897	16897	Error err;
16898	16898	IrInstruction *type_value = instruction->type_value->other;
16899		TypeTableEntry *container_type = ir_resolve_type(ira, type_value);
	16899	ZigType *container_type = ir_resolve_type(ira, type_value);
16900	16900	if (type_is_invalid(container_type))
16901	16901	return ira->codegen->builtin_types.entry_invalid;
16902	16902
...	...	@@ -16934,7 +16934,7 @@ static TypeTableEntry ir_analyze_instruction_offset_of(IrAnalyze ira,
16934	16934	return ira->codegen->builtin_types.entry_num_lit_int;
16935	16935	}
16936	16936
16937		static void ensure_field_index(TypeTableEntry type, const char field_name, size_t index)
	16937	static void ensure_field_index(ZigType type, const char field_name, size_t index)
16938	16938	{
16939	16939	Buf *field_name_buf;
16940	16940
...	...	@@ -16945,10 +16945,10 @@ static void ensure_field_index(TypeTableEntry type, const char field_name, siz
16945	16945	(buf_deinit(field_name_buf), true));
16946	16946	}
16947	16947
16948		static TypeTableEntry ir_type_info_get_type(IrAnalyze ira, const char type_name, TypeTableEntry root) {
	16948	static ZigType ir_type_info_get_type(IrAnalyze ira, const char type_name, ZigType root) {
16949	16949	Error err;
16950	16950	static ConstExprValue *type_info_var = nullptr;
16951		static TypeTableEntry *type_info_type = nullptr;
	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	16954	assert(type_info_var->type->id == TypeTableEntryIdMetaType);
...	...	@@ -16963,7 +16963,7 @@ static TypeTableEntry ir_type_info_get_type(IrAnalyze ira, const char *type_na
16963	16963	else if (type_name == nullptr)
16964	16964	return root;
16965	16965
16966		TypeTableEntry *root_type = (root == nullptr) ? type_info_type : root;
	16966	ZigType *root_type = (root == nullptr) ? type_info_type : root;
16967	16967
16968	16968	ScopeDecls *type_info_scope = get_container_scope(root_type);
16969	16969	assert(type_info_scope != nullptr);
...	...	@@ -16986,7 +16986,7 @@ static TypeTableEntry ir_type_info_get_type(IrAnalyze ira, const char *type_na
16986	16986
16987	16987	static Error ir_make_type_info_defs(IrAnalyze ira, ConstExprValue out_val, ScopeDecls *decls_scope) {
16988	16988	Error err;
16989		TypeTableEntry *type_info_definition_type = ir_type_info_get_type(ira, "Definition", nullptr);
	16989	ZigType *type_info_definition_type = ir_type_info_get_type(ira, "Definition", nullptr);
16990	16990	if ((err = ensure_complete_type(ira->codegen, type_info_definition_type)))
16991	16991	return err;
16992	16992
...	...	@@ -16994,15 +16994,15 @@ static Error ir_make_type_info_defs(IrAnalyze ira, ConstExprValue out_val, Sco
16994	16994	ensure_field_index(type_info_definition_type, "is_pub", 1);
16995	16995	ensure_field_index(type_info_definition_type, "data", 2);
16996	16996
16997		TypeTableEntry *type_info_definition_data_type = ir_type_info_get_type(ira, "Data", type_info_definition_type);
	16997	ZigType *type_info_definition_data_type = ir_type_info_get_type(ira, "Data", type_info_definition_type);
16998	16998	if ((err = ensure_complete_type(ira->codegen, type_info_definition_data_type)))
16999	16999	return err;
17000	17000
17001		TypeTableEntry *type_info_fn_def_type = ir_type_info_get_type(ira, "FnDef", type_info_definition_data_type);
	17001	ZigType *type_info_fn_def_type = ir_type_info_get_type(ira, "FnDef", type_info_definition_data_type);
17002	17002	if ((err = ensure_complete_type(ira->codegen, type_info_fn_def_type)))
17003	17003	return err;
17004	17004
17005		TypeTableEntry *type_info_fn_def_inline_type = ir_type_info_get_type(ira, "Inline", type_info_fn_def_type);
	17005	ZigType *type_info_fn_def_inline_type = ir_type_info_get_type(ira, "Inline", type_info_fn_def_type);
17006	17006	if ((err = ensure_complete_type(ira->codegen, type_info_fn_def_inline_type)))
17007	17007	return err;
17008	17008
...	...	@@ -17153,7 +17153,7 @@ static Error ir_make_type_info_defs(IrAnalyze ira, ConstExprValue out_val, Sco
17153	17153	// lib_name: ?[]const u8
17154	17154	ensure_field_index(fn_def_val->type, "lib_name", 6);
17155	17155	fn_def_fields[6].special = ConstValSpecialStatic;
17156		TypeTableEntry *u8_ptr = get_pointer_to_type_extra(
	17156	ZigType *u8_ptr = get_pointer_to_type_extra(
17157	17157	ira->codegen, ira->codegen->builtin_types.entry_u8,
17158	17158	true, false, PtrLenUnknown,
17159	17159	get_abi_alignment(ira->codegen, ira->codegen->builtin_types.entry_u8),
...	...	@@ -17205,7 +17205,7 @@ static Error ir_make_type_info_defs(IrAnalyze ira, ConstExprValue out_val, Sco
17205	17205	}
17206	17206	case TldIdContainer:
17207	17207	{
17208		TypeTableEntry type_entry = ((TldContainer )curr_entry->value)->type_entry;
	17208	ZigType type_entry = ((TldContainer )curr_entry->value)->type_entry;
17209	17209	if ((err = ensure_complete_type(ira->codegen, type_entry)))
17210	17210	return ErrorSemanticAnalyzeFail;
17211	17211
...	...	@@ -17232,8 +17232,8 @@ static Error ir_make_type_info_defs(IrAnalyze ira, ConstExprValue out_val, Sco
17232	17232	return ErrorNone;
17233	17233	}
17234	17234
17235		static ConstExprValue create_ptr_like_type_info(IrAnalyze ira, TypeTableEntry *ptr_type_entry) {
17236		TypeTableEntry *attrs_type;
	17235	static ConstExprValue create_ptr_like_type_info(IrAnalyze ira, ZigType *ptr_type_entry) {
	17236	ZigType *attrs_type;
17237	17237	uint32_t size_enum_index;
17238	17238	if (is_slice(ptr_type_entry)) {
17239	17239	attrs_type = ptr_type_entry->data.structure.fields[slice_ptr_index].type_entry;
...	...	@@ -17245,7 +17245,7 @@ static ConstExprValue create_ptr_like_type_info(IrAnalyze ira, TypeTableEntry
17245	17245	zig_unreachable();
17246	17246	}
17247	17247
17248		TypeTableEntry *type_info_pointer_type = ir_type_info_get_type(ira, "Pointer", nullptr);
	17248	ZigType *type_info_pointer_type = ir_type_info_get_type(ira, "Pointer", nullptr);
17249	17249	assertNoError(ensure_complete_type(ira->codegen, type_info_pointer_type));
17250	17250
17251	17251	ConstExprValue *result = create_const_vals(1);
...	...	@@ -17257,7 +17257,7 @@ static ConstExprValue create_ptr_like_type_info(IrAnalyze ira, TypeTableEntry
17257	17257
17258	17258	// size: Size
17259	17259	ensure_field_index(result->type, "size", 0);
17260		TypeTableEntry *type_info_pointer_size_type = ir_type_info_get_type(ira, "Size", type_info_pointer_type);
	17260	ZigType *type_info_pointer_size_type = ir_type_info_get_type(ira, "Size", type_info_pointer_type);
17261	17261	assertNoError(ensure_complete_type(ira->codegen, type_info_pointer_size_type));
17262	17262	fields[0].special = ConstValSpecialStatic;
17263	17263	fields[0].type = type_info_pointer_size_type;
...	...	@@ -17288,7 +17288,7 @@ static ConstExprValue create_ptr_like_type_info(IrAnalyze ira, TypeTableEntry
17288	17288	};
17289	17289
17290	17290	static void make_enum_field_val(IrAnalyze ira, ConstExprValue enum_field_val, TypeEnumField *enum_field,
17291		TypeTableEntry *type_info_enum_field_type)
	17291	ZigType *type_info_enum_field_type)
17292	17292	{
17293	17293	enum_field_val->special = ConstValSpecialStatic;
17294	17294	enum_field_val->type = type_info_enum_field_type;
...	...	@@ -17305,7 +17305,7 @@ static void make_enum_field_val(IrAnalyze ira, ConstExprValue enum_field_val,
17305	17305	enum_field_val->data.x_struct.fields = inner_fields;
17306	17306	}
17307	17307
17308		static Error ir_make_type_info_value(IrAnalyze ira, TypeTableEntry type_entry, ConstExprValue **out) {
	17308	static Error ir_make_type_info_value(IrAnalyze ira, ZigType type_entry, ConstExprValue **out) {
17309	17309	Error err;
17310	17310	assert(type_entry != nullptr);
17311	17311	assert(!type_is_invalid(type_entry));
...	...	@@ -17478,7 +17478,7 @@ static Error ir_make_type_info_value(IrAnalyze ira, TypeTableEntry type_entry,
17478	17478	// fields: []TypeInfo.EnumField
17479	17479	ensure_field_index(result->type, "fields", 2);
17480	17480
17481		TypeTableEntry *type_info_enum_field_type = ir_type_info_get_type(ira, "EnumField", nullptr);
	17481	ZigType *type_info_enum_field_type = ir_type_info_get_type(ira, "EnumField", nullptr);
17482	17482	uint32_t enum_field_count = type_entry->data.enumeration.src_field_count;
17483	17483
17484	17484	ConstExprValue *enum_field_array = create_const_vals(1);
...	...	@@ -17518,7 +17518,7 @@ static Error ir_make_type_info_value(IrAnalyze ira, TypeTableEntry type_entry,
17518	17518	// errors: []TypeInfo.Error
17519	17519	ensure_field_index(result->type, "errors", 0);
17520	17520
17521		TypeTableEntry *type_info_error_type = ir_type_info_get_type(ira, "Error", nullptr);
	17521	ZigType *type_info_error_type = ir_type_info_get_type(ira, "Error", nullptr);
17522	17522	uint32_t error_count = type_entry->data.error_set.err_count;
17523	17523	ConstExprValue *error_array = create_const_vals(1);
17524	17524	error_array->special = ConstValSpecialStatic;
...	...	@@ -17612,7 +17612,7 @@ static Error ir_make_type_info_value(IrAnalyze ira, TypeTableEntry type_entry,
17612	17612	// fields: []TypeInfo.UnionField
17613	17613	ensure_field_index(result->type, "fields", 2);
17614	17614
17615		TypeTableEntry *type_info_union_field_type = ir_type_info_get_type(ira, "UnionField", nullptr);
	17615	ZigType *type_info_union_field_type = ir_type_info_get_type(ira, "UnionField", nullptr);
17616	17616	uint32_t union_field_count = type_entry->data.unionation.src_field_count;
17617	17617
17618	17618	ConstExprValue *union_field_array = create_const_vals(1);
...	...	@@ -17624,7 +17624,7 @@ static Error ir_make_type_info_value(IrAnalyze ira, TypeTableEntry type_entry,
17624	17624
17625	17625	init_const_slice(ira->codegen, &fields[2], union_field_array, 0, union_field_count, false);
17626	17626
17627		TypeTableEntry *type_info_enum_field_type = ir_type_info_get_type(ira, "EnumField", nullptr);
	17627	ZigType *type_info_enum_field_type = ir_type_info_get_type(ira, "EnumField", nullptr);
17628	17628
17629	17629	for (uint32_t union_field_index = 0; union_field_index < union_field_count; union_field_index++) {
17630	17630	TypeUnionField *union_field = &type_entry->data.unionation.fields[union_field_index];
...	...	@@ -17685,7 +17685,7 @@ static Error ir_make_type_info_value(IrAnalyze ira, TypeTableEntry type_entry,
17685	17685	// fields: []TypeInfo.StructField
17686	17686	ensure_field_index(result->type, "fields", 1);
17687	17687
17688		TypeTableEntry *type_info_struct_field_type = ir_type_info_get_type(ira, "StructField", nullptr);
	17688	ZigType *type_info_struct_field_type = ir_type_info_get_type(ira, "StructField", nullptr);
17689	17689	uint32_t struct_field_count = type_entry->data.structure.src_field_count;
17690	17690
17691	17691	ConstExprValue *struct_field_array = create_const_vals(1);
...	...	@@ -17790,7 +17790,7 @@ static Error ir_make_type_info_value(IrAnalyze ira, TypeTableEntry type_entry,
17790	17790	fields[4].data.x_optional = async_alloc_type;
17791	17791	}
17792	17792	// args: []TypeInfo.FnArg
17793		TypeTableEntry *type_info_fn_arg_type = ir_type_info_get_type(ira, "FnArg", nullptr);
	17793	ZigType *type_info_fn_arg_type = ir_type_info_get_type(ira, "FnArg", nullptr);
17794	17794	size_t fn_arg_count = type_entry->data.fn.fn_type_id.param_count -
17795	17795	(is_varargs && type_entry->data.fn.fn_type_id.cc != CallingConventionC);
17796	17796
...	...	@@ -17844,7 +17844,7 @@ static Error ir_make_type_info_value(IrAnalyze ira, TypeTableEntry type_entry,
17844	17844	}
17845	17845	case TypeTableEntryIdBoundFn:
17846	17846	{
17847		TypeTableEntry *fn_type = type_entry->data.bound_fn.fn_type;
	17847	ZigType *fn_type = type_entry->data.bound_fn.fn_type;
17848	17848	assert(fn_type->id == TypeTableEntryIdFn);
17849	17849	if ((err = ir_make_type_info_value(ira, fn_type, &result)))
17850	17850	return err;
...	...	@@ -17859,16 +17859,16 @@ static Error ir_make_type_info_value(IrAnalyze ira, TypeTableEntry type_entry,
17859	17859	return ErrorNone;
17860	17860	}
17861	17861
17862		static TypeTableEntry ir_analyze_instruction_type_info(IrAnalyze ira,
	17862	static ZigType ir_analyze_instruction_type_info(IrAnalyze ira,
17863	17863	IrInstructionTypeInfo *instruction)
17864	17864	{
17865	17865	Error err;
17866	17866	IrInstruction *type_value = instruction->type_value->other;
17867		TypeTableEntry *type_entry = ir_resolve_type(ira, type_value);
	17867	ZigType *type_entry = ir_resolve_type(ira, type_value);
17868	17868	if (type_is_invalid(type_entry))
17869	17869	return ira->codegen->builtin_types.entry_invalid;
17870	17870
17871		TypeTableEntry *result_type = ir_type_info_get_type(ira, nullptr, nullptr);
	17871	ZigType *result_type = ir_type_info_get_type(ira, nullptr, nullptr);
17872	17872
17873	17873	ConstExprValue *payload;
17874	17874	if ((err = ir_make_type_info_value(ira, type_entry, &payload)))
...	...	@@ -17888,24 +17888,24 @@ static TypeTableEntry ir_analyze_instruction_type_info(IrAnalyze ira,
17888	17888	return result_type;
17889	17889	}
17890	17890
17891		static TypeTableEntry ir_analyze_instruction_type_id(IrAnalyze ira,
	17891	static ZigType ir_analyze_instruction_type_id(IrAnalyze ira,
17892	17892	IrInstructionTypeId *instruction)
17893	17893	{
17894	17894	IrInstruction *type_value = instruction->type_value->other;
17895		TypeTableEntry *type_entry = ir_resolve_type(ira, type_value);
	17895	ZigType *type_entry = ir_resolve_type(ira, type_value);
17896	17896	if (type_is_invalid(type_entry))
17897	17897	return ira->codegen->builtin_types.entry_invalid;
17898	17898
17899	17899	ConstExprValue *var_value = get_builtin_value(ira->codegen, "TypeId");
17900	17900	assert(var_value->type->id == TypeTableEntryIdMetaType);
17901		TypeTableEntry *result_type = var_value->data.x_type;
	17901	ZigType *result_type = var_value->data.x_type;
17902	17902
17903	17903	ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
17904	17904	bigint_init_unsigned(&out_val->data.x_enum_tag, type_id_index(type_entry));
17905	17905	return result_type;
17906	17906	}
17907	17907
17908		static TypeTableEntry ir_analyze_instruction_set_eval_branch_quota(IrAnalyze ira,
	17908	static ZigType ir_analyze_instruction_set_eval_branch_quota(IrAnalyze ira,
17909	17909	IrInstructionSetEvalBranchQuota *instruction)
17910	17910	{
17911	17911	if (ira->new_irb.exec->parent_exec != nullptr && !ira->new_irb.exec->is_generic_instantiation) {
...	...	@@ -17926,9 +17926,9 @@ static TypeTableEntry ir_analyze_instruction_set_eval_branch_quota(IrAnalyze i
17926	17926	return ira->codegen->builtin_types.entry_void;
17927	17927	}
17928	17928
17929		static TypeTableEntry ir_analyze_instruction_type_name(IrAnalyze ira, IrInstructionTypeName *instruction) {
	17929	static ZigType ir_analyze_instruction_type_name(IrAnalyze ira, IrInstructionTypeName *instruction) {
17930	17930	IrInstruction *type_value = instruction->type_value->other;
17931		TypeTableEntry *type_entry = ir_resolve_type(ira, type_value);
	17931	ZigType *type_entry = ir_resolve_type(ira, type_value);
17932	17932	if (type_is_invalid(type_entry))
17933	17933	return ira->codegen->builtin_types.entry_invalid;
17934	17934
...	...	@@ -17940,7 +17940,7 @@ static TypeTableEntry ir_analyze_instruction_type_name(IrAnalyze ira, IrInstru
17940	17940	return out_val->type;
17941	17941	}
17942	17942
17943		static TypeTableEntry ir_analyze_instruction_c_import(IrAnalyze ira, IrInstructionCImport *instruction) {
	17943	static ZigType ir_analyze_instruction_c_import(IrAnalyze ira, IrInstructionCImport *instruction) {
17944	17944	AstNode *node = instruction->base.source_node;
17945	17945	assert(node->type == NodeTypeFnCallExpr);
17946	17946	AstNode *block_node = node->data.fn_call_expr.params.at(0);
...	...	@@ -17948,7 +17948,7 @@ static TypeTableEntry ir_analyze_instruction_c_import(IrAnalyze ira, IrInstruc
17948	17948	ScopeCImport *cimport_scope = create_cimport_scope(node, instruction->base.scope);
17949	17949
17950	17950	// Execute the C import block like an inline function
17951		TypeTableEntry *void_type = ira->codegen->builtin_types.entry_void;
	17951	ZigType *void_type = ira->codegen->builtin_types.entry_void;
17952	17952	IrInstruction *result = ir_eval_const_value(ira->codegen, &cimport_scope->base, block_node, void_type,
17953	17953	ira->new_irb.exec->backward_branch_count, ira->new_irb.exec->backward_branch_quota, nullptr,
17954	17954	&cimport_scope->buf, block_node, nullptr, nullptr);
...	...	@@ -17999,7 +17999,7 @@ static TypeTableEntry ir_analyze_instruction_c_import(IrAnalyze ira, IrInstruc
17999	17999	return ira->codegen->builtin_types.entry_namespace;
18000	18000	}
18001	18001
18002		static TypeTableEntry ir_analyze_instruction_c_include(IrAnalyze ira, IrInstructionCInclude *instruction) {
	18002	static ZigType ir_analyze_instruction_c_include(IrAnalyze ira, IrInstructionCInclude *instruction) {
18003	18003	IrInstruction *name_value = instruction->name->other;
18004	18004	if (type_is_invalid(name_value->value.type))
18005	18005	return ira->codegen->builtin_types.entry_invalid;
...	...	@@ -18018,7 +18018,7 @@ static TypeTableEntry ir_analyze_instruction_c_include(IrAnalyze ira, IrInstru
18018	18018	return ira->codegen->builtin_types.entry_void;
18019	18019	}
18020	18020
18021		static TypeTableEntry ir_analyze_instruction_c_define(IrAnalyze ira, IrInstructionCDefine *instruction) {
	18021	static ZigType ir_analyze_instruction_c_define(IrAnalyze ira, IrInstructionCDefine *instruction) {
18022	18022	IrInstruction *name = instruction->name->other;
18023	18023	if (type_is_invalid(name->value.type))
18024	18024	return ira->codegen->builtin_types.entry_invalid;
...	...	@@ -18045,7 +18045,7 @@ static TypeTableEntry ir_analyze_instruction_c_define(IrAnalyze ira, IrInstruc
18045	18045	return ira->codegen->builtin_types.entry_void;
18046	18046	}
18047	18047
18048		static TypeTableEntry ir_analyze_instruction_c_undef(IrAnalyze ira, IrInstructionCUndef *instruction) {
	18048	static ZigType ir_analyze_instruction_c_undef(IrAnalyze ira, IrInstructionCUndef *instruction) {
18049	18049	IrInstruction *name = instruction->name->other;
18050	18050	if (type_is_invalid(name->value.type))
18051	18051	return ira->codegen->builtin_types.entry_invalid;
...	...	@@ -18064,7 +18064,7 @@ static TypeTableEntry ir_analyze_instruction_c_undef(IrAnalyze ira, IrInstruct
18064	18064	return ira->codegen->builtin_types.entry_void;
18065	18065	}
18066	18066
18067		static TypeTableEntry ir_analyze_instruction_embed_file(IrAnalyze ira, IrInstructionEmbedFile *instruction) {
	18067	static ZigType ir_analyze_instruction_embed_file(IrAnalyze ira, IrInstructionEmbedFile *instruction) {
18068	18068	IrInstruction *name = instruction->name->other;
18069	18069	if (type_is_invalid(name->value.type))
18070	18070	return ira->codegen->builtin_types.entry_invalid;
...	...	@@ -18106,8 +18106,8 @@ static TypeTableEntry ir_analyze_instruction_embed_file(IrAnalyze ira, IrInstr
18106	18106	return get_array_type(ira->codegen, ira->codegen->builtin_types.entry_u8, buf_len(file_contents));
18107	18107	}
18108	18108
18109		static TypeTableEntry ir_analyze_instruction_cmpxchg(IrAnalyze ira, IrInstructionCmpxchg *instruction) {
18110		TypeTableEntry *operand_type = ir_resolve_atomic_operand_type(ira, instruction->type_value->other);
	18109	static ZigType ir_analyze_instruction_cmpxchg(IrAnalyze ira, IrInstructionCmpxchg *instruction) {
	18110	ZigType *operand_type = ir_resolve_atomic_operand_type(ira, instruction->type_value->other);
18111	18111	if (type_is_invalid(operand_type))
18112	18112	return ira->codegen->builtin_types.entry_invalid;
18113	18113
...	...	@@ -18116,7 +18116,7 @@ static TypeTableEntry ir_analyze_instruction_cmpxchg(IrAnalyze ira, IrInstruct
18116	18116	return ira->codegen->builtin_types.entry_invalid;
18117	18117
18118	18118	// TODO let this be volatile
18119		TypeTableEntry *ptr_type = get_pointer_to_type(ira->codegen, operand_type, false);
	18119	ZigType *ptr_type = get_pointer_to_type(ira->codegen, operand_type, false);
18120	18120	IrInstruction *casted_ptr = ir_implicit_cast(ira, ptr, ptr_type);
18121	18121	if (type_is_invalid(casted_ptr->value.type))
18122	18122	return ira->codegen->builtin_types.entry_invalid;
...	...	@@ -18187,7 +18187,7 @@ static TypeTableEntry ir_analyze_instruction_cmpxchg(IrAnalyze ira, IrInstruct
18187	18187	return result->value.type;
18188	18188	}
18189	18189
18190		static TypeTableEntry ir_analyze_instruction_fence(IrAnalyze ira, IrInstructionFence *instruction) {
	18190	static ZigType ir_analyze_instruction_fence(IrAnalyze ira, IrInstructionFence *instruction) {
18191	18191	IrInstruction *order_value = instruction->order_value->other;
18192	18192	if (type_is_invalid(order_value->value.type))
18193	18193	return ira->codegen->builtin_types.entry_invalid;
...	...	@@ -18200,9 +18200,9 @@ static TypeTableEntry ir_analyze_instruction_fence(IrAnalyze ira, IrInstructio
18200	18200	return ira->codegen->builtin_types.entry_void;
18201	18201	}
18202	18202
18203		static TypeTableEntry ir_analyze_instruction_truncate(IrAnalyze ira, IrInstructionTruncate *instruction) {
	18203	static ZigType ir_analyze_instruction_truncate(IrAnalyze ira, IrInstructionTruncate *instruction) {
18204	18204	IrInstruction *dest_type_value = instruction->dest_type->other;
18205		TypeTableEntry *dest_type = ir_resolve_type(ira, dest_type_value);
	18205	ZigType *dest_type = ir_resolve_type(ira, dest_type_value);
18206	18206	if (type_is_invalid(dest_type))
18207	18207	return ira->codegen->builtin_types.entry_invalid;
18208	18208
...	...	@@ -18214,7 +18214,7 @@ static TypeTableEntry ir_analyze_instruction_truncate(IrAnalyze ira, IrInstruc
18214	18214	}
18215	18215
18216	18216	IrInstruction *target = instruction->target->other;
18217		TypeTableEntry *src_type = target->value.type;
	18217	ZigType *src_type = target->value.type;
18218	18218	if (type_is_invalid(src_type))
18219	18219	return ira->codegen->builtin_types.entry_invalid;
18220	18220
...	...	@@ -18248,8 +18248,8 @@ static TypeTableEntry ir_analyze_instruction_truncate(IrAnalyze ira, IrInstruc
18248	18248	return dest_type;
18249	18249	}
18250	18250
18251		static TypeTableEntry ir_analyze_instruction_int_cast(IrAnalyze ira, IrInstructionIntCast *instruction) {
18252		TypeTableEntry *dest_type = ir_resolve_type(ira, instruction->dest_type->other);
	18251	static ZigType ir_analyze_instruction_int_cast(IrAnalyze ira, IrInstructionIntCast *instruction) {
	18252	ZigType *dest_type = ir_resolve_type(ira, instruction->dest_type->other);
18253	18253	if (type_is_invalid(dest_type))
18254	18254	return ira->codegen->builtin_types.entry_invalid;
18255	18255
...	...	@@ -18289,8 +18289,8 @@ static TypeTableEntry ir_analyze_instruction_int_cast(IrAnalyze ira, IrInstruc
18289	18289	return dest_type;
18290	18290	}
18291	18291
18292		static TypeTableEntry ir_analyze_instruction_float_cast(IrAnalyze ira, IrInstructionFloatCast *instruction) {
18293		TypeTableEntry *dest_type = ir_resolve_type(ira, instruction->dest_type->other);
	18292	static ZigType ir_analyze_instruction_float_cast(IrAnalyze ira, IrInstructionFloatCast *instruction) {
	18293	ZigType *dest_type = ir_resolve_type(ira, instruction->dest_type->other);
18294	18294	if (type_is_invalid(dest_type))
18295	18295	return ira->codegen->builtin_types.entry_invalid;
18296	18296
...	...	@@ -18337,8 +18337,8 @@ static TypeTableEntry ir_analyze_instruction_float_cast(IrAnalyze ira, IrInstr
18337	18337	return dest_type;
18338	18338	}
18339	18339
18340		static TypeTableEntry ir_analyze_instruction_err_set_cast(IrAnalyze ira, IrInstructionErrSetCast *instruction) {
18341		TypeTableEntry *dest_type = ir_resolve_type(ira, instruction->dest_type->other);
	18340	static ZigType ir_analyze_instruction_err_set_cast(IrAnalyze ira, IrInstructionErrSetCast *instruction) {
	18341	ZigType *dest_type = ir_resolve_type(ira, instruction->dest_type->other);
18342	18342	if (type_is_invalid(dest_type))
18343	18343	return ira->codegen->builtin_types.entry_invalid;
18344	18344
...	...	@@ -18365,8 +18365,8 @@ static TypeTableEntry ir_analyze_instruction_err_set_cast(IrAnalyze ira, IrIns
18365	18365	return dest_type;
18366	18366	}
18367	18367
18368		static TypeTableEntry ir_analyze_instruction_from_bytes(IrAnalyze ira, IrInstructionFromBytes *instruction) {
18369		TypeTableEntry *dest_child_type = ir_resolve_type(ira, instruction->dest_child_type->other);
	18368	static ZigType ir_analyze_instruction_from_bytes(IrAnalyze ira, IrInstructionFromBytes *instruction) {
	18369	ZigType *dest_child_type = ir_resolve_type(ira, instruction->dest_child_type->other);
18370	18370	if (type_is_invalid(dest_child_type))
18371	18371	return ira->codegen->builtin_types.entry_invalid;
18372	18372
...	...	@@ -18382,7 +18382,7 @@ static TypeTableEntry ir_analyze_instruction_from_bytes(IrAnalyze ira, IrInstr
18382	18382	src_ptr_volatile = target->value.type->data.pointer.is_volatile;
18383	18383	src_ptr_align = target->value.type->data.pointer.alignment;
18384	18384	} else if (is_slice(target->value.type)) {
18385		TypeTableEntry *src_ptr_type = target->value.type->data.structure.fields[slice_ptr_index].type_entry;
	18385	ZigType *src_ptr_type = target->value.type->data.structure.fields[slice_ptr_index].type_entry;
18386	18386	src_ptr_const = src_ptr_type->data.pointer.is_const;
18387	18387	src_ptr_volatile = src_ptr_type->data.pointer.is_volatile;
18388	18388	src_ptr_align = src_ptr_type->data.pointer.alignment;
...	...	@@ -18392,15 +18392,15 @@ static TypeTableEntry ir_analyze_instruction_from_bytes(IrAnalyze ira, IrInstr
18392	18392	src_ptr_align = get_abi_alignment(ira->codegen, target->value.type);
18393	18393	}
18394	18394
18395		TypeTableEntry *dest_ptr_type = get_pointer_to_type_extra(ira->codegen, dest_child_type,
	18395	ZigType *dest_ptr_type = get_pointer_to_type_extra(ira->codegen, dest_child_type,
18396	18396	src_ptr_const, src_ptr_volatile, PtrLenUnknown,
18397	18397	src_ptr_align, 0, 0);
18398		TypeTableEntry *dest_slice_type = get_slice_type(ira->codegen, dest_ptr_type);
	18398	ZigType *dest_slice_type = get_slice_type(ira->codegen, dest_ptr_type);
18399	18399
18400		TypeTableEntry *u8_ptr = get_pointer_to_type_extra(ira->codegen, ira->codegen->builtin_types.entry_u8,
	18400	ZigType *u8_ptr = get_pointer_to_type_extra(ira->codegen, ira->codegen->builtin_types.entry_u8,
18401	18401	src_ptr_const, src_ptr_volatile, PtrLenUnknown,
18402	18402	src_ptr_align, 0, 0);
18403		TypeTableEntry *u8_slice = get_slice_type(ira->codegen, u8_ptr);
	18403	ZigType *u8_slice = get_slice_type(ira->codegen, u8_ptr);
18404	18404
18405	18405	IrInstruction *casted_value = ir_implicit_cast(ira, target, u8_slice);
18406	18406	if (type_is_invalid(casted_value->value.type))
...	...	@@ -18445,7 +18445,7 @@ static TypeTableEntry ir_analyze_instruction_from_bytes(IrAnalyze ira, IrInstr
18445	18445	return dest_slice_type;
18446	18446	}
18447	18447
18448		static TypeTableEntry ir_analyze_instruction_to_bytes(IrAnalyze ira, IrInstructionToBytes *instruction) {
	18448	static ZigType ir_analyze_instruction_to_bytes(IrAnalyze ira, IrInstructionToBytes *instruction) {
18449	18449	IrInstruction *target = instruction->target->other;
18450	18450	if (type_is_invalid(target->value.type))
18451	18451	return ira->codegen->builtin_types.entry_invalid;
...	...	@@ -18456,20 +18456,20 @@ static TypeTableEntry ir_analyze_instruction_to_bytes(IrAnalyze ira, IrInstruc
18456	18456	return ira->codegen->builtin_types.entry_invalid;
18457	18457	}
18458	18458
18459		TypeTableEntry *src_ptr_type = target->value.type->data.structure.fields[slice_ptr_index].type_entry;
	18459	ZigType *src_ptr_type = target->value.type->data.structure.fields[slice_ptr_index].type_entry;
18460	18460
18461		TypeTableEntry *dest_ptr_type = get_pointer_to_type_extra(ira->codegen, ira->codegen->builtin_types.entry_u8,
	18461	ZigType *dest_ptr_type = get_pointer_to_type_extra(ira->codegen, ira->codegen->builtin_types.entry_u8,
18462	18462	src_ptr_type->data.pointer.is_const, src_ptr_type->data.pointer.is_volatile, PtrLenUnknown,
18463	18463	src_ptr_type->data.pointer.alignment, 0, 0);
18464		TypeTableEntry *dest_slice_type = get_slice_type(ira->codegen, dest_ptr_type);
	18464	ZigType *dest_slice_type = get_slice_type(ira->codegen, dest_ptr_type);
18465	18465
18466	18466	IrInstruction *result = ir_resolve_cast(ira, &instruction->base, target, dest_slice_type, CastOpResizeSlice, true);
18467	18467	ir_link_new_instruction(result, &instruction->base);
18468	18468	return dest_slice_type;
18469	18469	}
18470	18470
18471		static TypeTableEntry ir_analyze_instruction_int_to_float(IrAnalyze ira, IrInstructionIntToFloat *instruction) {
18472		TypeTableEntry *dest_type = ir_resolve_type(ira, instruction->dest_type->other);
	18471	static ZigType ir_analyze_instruction_int_to_float(IrAnalyze ira, IrInstructionIntToFloat *instruction) {
	18472	ZigType *dest_type = ir_resolve_type(ira, instruction->dest_type->other);
18473	18473	if (type_is_invalid(dest_type))
18474	18474	return ira->codegen->builtin_types.entry_invalid;
18475	18475
...	...	@@ -18488,8 +18488,8 @@ static TypeTableEntry ir_analyze_instruction_int_to_float(IrAnalyze ira, IrIns
18488	18488	return dest_type;
18489	18489	}
18490	18490
18491		static TypeTableEntry ir_analyze_instruction_float_to_int(IrAnalyze ira, IrInstructionFloatToInt *instruction) {
18492		TypeTableEntry *dest_type = ir_resolve_type(ira, instruction->dest_type->other);
	18491	static ZigType ir_analyze_instruction_float_to_int(IrAnalyze ira, IrInstructionFloatToInt *instruction) {
	18492	ZigType *dest_type = ir_resolve_type(ira, instruction->dest_type->other);
18493	18493	if (type_is_invalid(dest_type))
18494	18494	return ira->codegen->builtin_types.entry_invalid;
18495	18495
...	...	@@ -18516,7 +18516,7 @@ static TypeTableEntry ir_analyze_instruction_float_to_int(IrAnalyze ira, IrIns
18516	18516	return dest_type;
18517	18517	}
18518	18518
18519		static TypeTableEntry ir_analyze_instruction_err_to_int(IrAnalyze ira, IrInstructionErrToInt *instruction) {
	18519	static ZigType ir_analyze_instruction_err_to_int(IrAnalyze ira, IrInstructionErrToInt *instruction) {
18520	18520	IrInstruction *target = instruction->target->other;
18521	18521	if (type_is_invalid(target->value.type))
18522	18522	return ira->codegen->builtin_types.entry_invalid;
...	...	@@ -18535,7 +18535,7 @@ static TypeTableEntry ir_analyze_instruction_err_to_int(IrAnalyze ira, IrInstr
18535	18535	return result->value.type;
18536	18536	}
18537	18537
18538		static TypeTableEntry ir_analyze_instruction_int_to_err(IrAnalyze ira, IrInstructionIntToErr *instruction) {
	18538	static ZigType ir_analyze_instruction_int_to_err(IrAnalyze ira, IrInstructionIntToErr *instruction) {
18539	18539	IrInstruction *target = instruction->target->other;
18540	18540	if (type_is_invalid(target->value.type))
18541	18541	return ira->codegen->builtin_types.entry_invalid;
...	...	@@ -18549,7 +18549,7 @@ static TypeTableEntry ir_analyze_instruction_int_to_err(IrAnalyze ira, IrInstr
18549	18549	return result->value.type;
18550	18550	}
18551	18551
18552		static TypeTableEntry ir_analyze_instruction_bool_to_int(IrAnalyze ira, IrInstructionBoolToInt *instruction) {
	18552	static ZigType ir_analyze_instruction_bool_to_int(IrAnalyze ira, IrInstructionBoolToInt *instruction) {
18553	18553	IrInstruction *target = instruction->target->other;
18554	18554	if (type_is_invalid(target->value.type))
18555	18555	return ira->codegen->builtin_types.entry_invalid;
...	...	@@ -18570,13 +18570,13 @@ static TypeTableEntry ir_analyze_instruction_bool_to_int(IrAnalyze ira, IrInst
18570	18570	return ira->codegen->builtin_types.entry_num_lit_int;
18571	18571	}
18572	18572
18573		TypeTableEntry *u1_type = get_int_type(ira->codegen, false, 1);
	18573	ZigType *u1_type = get_int_type(ira->codegen, false, 1);
18574	18574	IrInstruction *result = ir_resolve_cast(ira, &instruction->base, target, u1_type, CastOpBoolToInt, false);
18575	18575	ir_link_new_instruction(result, &instruction->base);
18576	18576	return u1_type;
18577	18577	}
18578	18578
18579		static TypeTableEntry ir_analyze_instruction_int_type(IrAnalyze ira, IrInstructionIntType *instruction) {
	18579	static ZigType ir_analyze_instruction_int_type(IrAnalyze ira, IrInstructionIntType *instruction) {
18580	18580	IrInstruction *is_signed_value = instruction->is_signed->other;
18581	18581	bool is_signed;
18582	18582	if (!ir_resolve_bool(ira, is_signed_value, &is_signed))
...	...	@@ -18592,12 +18592,12 @@ static TypeTableEntry ir_analyze_instruction_int_type(IrAnalyze ira, IrInstruc
18592	18592	return ira->codegen->builtin_types.entry_type;
18593	18593	}
18594	18594
18595		static TypeTableEntry ir_analyze_instruction_bool_not(IrAnalyze ira, IrInstructionBoolNot *instruction) {
	18595	static ZigType ir_analyze_instruction_bool_not(IrAnalyze ira, IrInstructionBoolNot *instruction) {
18596	18596	IrInstruction *value = instruction->value->other;
18597	18597	if (type_is_invalid(value->value.type))
18598	18598	return ira->codegen->builtin_types.entry_invalid;
18599	18599
18600		TypeTableEntry *bool_type = ira->codegen->builtin_types.entry_bool;
	18600	ZigType *bool_type = ira->codegen->builtin_types.entry_bool;
18601	18601
18602	18602	IrInstruction *casted_value = ir_implicit_cast(ira, value, bool_type);
18603	18603	if (type_is_invalid(casted_value->value.type))
...	...	@@ -18617,7 +18617,7 @@ static TypeTableEntry ir_analyze_instruction_bool_not(IrAnalyze ira, IrInstruc
18617	18617	return bool_type;
18618	18618	}
18619	18619
18620		static TypeTableEntry ir_analyze_instruction_memset(IrAnalyze ira, IrInstructionMemset *instruction) {
	18620	static ZigType ir_analyze_instruction_memset(IrAnalyze ira, IrInstructionMemset *instruction) {
18621	18621	IrInstruction *dest_ptr = instruction->dest_ptr->other;
18622	18622	if (type_is_invalid(dest_ptr->value.type))
18623	18623	return ira->codegen->builtin_types.entry_invalid;
...	...	@@ -18630,15 +18630,15 @@ static TypeTableEntry ir_analyze_instruction_memset(IrAnalyze ira, IrInstructi
18630	18630	if (type_is_invalid(count_value->value.type))
18631	18631	return ira->codegen->builtin_types.entry_invalid;
18632	18632
18633		TypeTableEntry *dest_uncasted_type = dest_ptr->value.type;
	18633	ZigType *dest_uncasted_type = dest_ptr->value.type;
18634	18634	bool dest_is_volatile = (dest_uncasted_type->id == TypeTableEntryIdPointer) &&
18635	18635	dest_uncasted_type->data.pointer.is_volatile;
18636	18636
18637		TypeTableEntry *usize = ira->codegen->builtin_types.entry_usize;
18638		TypeTableEntry *u8 = ira->codegen->builtin_types.entry_u8;
	18637	ZigType *usize = ira->codegen->builtin_types.entry_usize;
	18638	ZigType *u8 = ira->codegen->builtin_types.entry_u8;
18639	18639	uint32_t dest_align = (dest_uncasted_type->id == TypeTableEntryIdPointer) ?
18640	18640	dest_uncasted_type->data.pointer.alignment : get_abi_alignment(ira->codegen, u8);
18641		TypeTableEntry *u8_ptr = get_pointer_to_type_extra(ira->codegen, u8, false, dest_is_volatile,
	18641	ZigType *u8_ptr = get_pointer_to_type_extra(ira->codegen, u8, false, dest_is_volatile,
18642	18642	PtrLenUnknown, dest_align, 0, 0);
18643	18643
18644	18644	IrInstruction *casted_dest_ptr = ir_implicit_cast(ira, dest_ptr, u8_ptr);
...	...	@@ -18709,7 +18709,7 @@ static TypeTableEntry ir_analyze_instruction_memset(IrAnalyze ira, IrInstructi
18709	18709	return ira->codegen->builtin_types.entry_void;
18710	18710	}
18711	18711
18712		static TypeTableEntry ir_analyze_instruction_memcpy(IrAnalyze ira, IrInstructionMemcpy *instruction) {
	18712	static ZigType ir_analyze_instruction_memcpy(IrAnalyze ira, IrInstructionMemcpy *instruction) {
18713	18713	IrInstruction *dest_ptr = instruction->dest_ptr->other;
18714	18714	if (type_is_invalid(dest_ptr->value.type))
18715	18715	return ira->codegen->builtin_types.entry_invalid;
...	...	@@ -18722,9 +18722,9 @@ static TypeTableEntry ir_analyze_instruction_memcpy(IrAnalyze ira, IrInstructi
18722	18722	if (type_is_invalid(count_value->value.type))
18723	18723	return ira->codegen->builtin_types.entry_invalid;
18724	18724
18725		TypeTableEntry *u8 = ira->codegen->builtin_types.entry_u8;
18726		TypeTableEntry *dest_uncasted_type = dest_ptr->value.type;
18727		TypeTableEntry *src_uncasted_type = src_ptr->value.type;
	18725	ZigType *u8 = ira->codegen->builtin_types.entry_u8;
	18726	ZigType *dest_uncasted_type = dest_ptr->value.type;
	18727	ZigType *src_uncasted_type = src_ptr->value.type;
18728	18728	bool dest_is_volatile = (dest_uncasted_type->id == TypeTableEntryIdPointer) &&
18729	18729	dest_uncasted_type->data.pointer.is_volatile;
18730	18730	bool src_is_volatile = (src_uncasted_type->id == TypeTableEntryIdPointer) &&
...	...	@@ -18734,10 +18734,10 @@ static TypeTableEntry ir_analyze_instruction_memcpy(IrAnalyze ira, IrInstructi
18734	18734	uint32_t src_align = (src_uncasted_type->id == TypeTableEntryIdPointer) ?
18735	18735	src_uncasted_type->data.pointer.alignment : get_abi_alignment(ira->codegen, u8);
18736	18736
18737		TypeTableEntry *usize = ira->codegen->builtin_types.entry_usize;
18738		TypeTableEntry *u8_ptr_mut = get_pointer_to_type_extra(ira->codegen, u8, false, dest_is_volatile,
	18737	ZigType *usize = ira->codegen->builtin_types.entry_usize;
	18738	ZigType *u8_ptr_mut = get_pointer_to_type_extra(ira->codegen, u8, false, dest_is_volatile,
18739	18739	PtrLenUnknown, dest_align, 0, 0);
18740		TypeTableEntry *u8_ptr_const = get_pointer_to_type_extra(ira->codegen, u8, true, src_is_volatile,
	18740	ZigType *u8_ptr_const = get_pointer_to_type_extra(ira->codegen, u8, true, src_is_volatile,
18741	18741	PtrLenUnknown, src_align, 0, 0);
18742	18742
18743	18743	IrInstruction *casted_dest_ptr = ir_implicit_cast(ira, dest_ptr, u8_ptr_mut);
...	...	@@ -18844,20 +18844,20 @@ static TypeTableEntry ir_analyze_instruction_memcpy(IrAnalyze ira, IrInstructi
18844	18844	return ira->codegen->builtin_types.entry_void;
18845	18845	}
18846	18846
18847		static TypeTableEntry ir_analyze_instruction_slice(IrAnalyze ira, IrInstructionSlice *instruction) {
	18847	static ZigType ir_analyze_instruction_slice(IrAnalyze ira, IrInstructionSlice *instruction) {
18848	18848	IrInstruction *ptr_ptr = instruction->ptr->other;
18849	18849	if (type_is_invalid(ptr_ptr->value.type))
18850	18850	return ira->codegen->builtin_types.entry_invalid;
18851	18851
18852		TypeTableEntry *ptr_type = ptr_ptr->value.type;
	18852	ZigType *ptr_type = ptr_ptr->value.type;
18853	18853	assert(ptr_type->id == TypeTableEntryIdPointer);
18854		TypeTableEntry *array_type = ptr_type->data.pointer.child_type;
	18854	ZigType *array_type = ptr_type->data.pointer.child_type;
18855	18855
18856	18856	IrInstruction *start = instruction->start->other;
18857	18857	if (type_is_invalid(start->value.type))
18858	18858	return ira->codegen->builtin_types.entry_invalid;
18859	18859
18860		TypeTableEntry *usize = ira->codegen->builtin_types.entry_usize;
	18860	ZigType *usize = ira->codegen->builtin_types.entry_usize;
18861	18861	IrInstruction *casted_start = ir_implicit_cast(ira, start, usize);
18862	18862	if (type_is_invalid(casted_start->value.type))
18863	18863	return ira->codegen->builtin_types.entry_invalid;
...	...	@@ -18874,7 +18874,7 @@ static TypeTableEntry ir_analyze_instruction_slice(IrAnalyze ira, IrInstructio
18874	18874	end = nullptr;
18875	18875	}
18876	18876
18877		TypeTableEntry *return_type;
	18877	ZigType *return_type;
18878	18878
18879	18879	if (array_type->id == TypeTableEntryIdArray) {
18880	18880	uint32_t byte_alignment = ptr_type->data.pointer.alignment;
...	...	@@ -18883,7 +18883,7 @@ static TypeTableEntry ir_analyze_instruction_slice(IrAnalyze ira, IrInstructio
18883	18883	}
18884	18884	bool is_comptime_const = ptr_ptr->value.special == ConstValSpecialStatic &&
18885	18885	ptr_ptr->value.data.x_ptr.mut == ConstPtrMutComptimeConst;
18886		TypeTableEntry *slice_ptr_type = get_pointer_to_type_extra(ira->codegen, array_type->data.array.child_type,
	18886	ZigType *slice_ptr_type = get_pointer_to_type_extra(ira->codegen, array_type->data.array.child_type,
18887	18887	ptr_type->data.pointer.is_const \|\| is_comptime_const,
18888	18888	ptr_type->data.pointer.is_volatile,
18889	18889	PtrLenUnknown,
...	...	@@ -18891,9 +18891,9 @@ static TypeTableEntry ir_analyze_instruction_slice(IrAnalyze ira, IrInstructio
18891	18891	return_type = get_slice_type(ira->codegen, slice_ptr_type);
18892	18892	} else if (array_type->id == TypeTableEntryIdPointer) {
18893	18893	if (array_type->data.pointer.ptr_len == PtrLenSingle) {
18894		TypeTableEntry *main_type = array_type->data.pointer.child_type;
	18894	ZigType *main_type = array_type->data.pointer.child_type;
18895	18895	if (main_type->id == TypeTableEntryIdArray) {
18896		TypeTableEntry *slice_ptr_type = get_pointer_to_type_extra(ira->codegen,
	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,
18899	18899	PtrLenUnknown,
...	...	@@ -18904,7 +18904,7 @@ static TypeTableEntry ir_analyze_instruction_slice(IrAnalyze ira, IrInstructio
18904	18904	return ira->codegen->builtin_types.entry_invalid;
18905	18905	}
18906	18906	} else {
18907		TypeTableEntry *slice_ptr_type = get_pointer_to_type_extra(ira->codegen, array_type->data.pointer.child_type,
	18907	ZigType *slice_ptr_type = get_pointer_to_type_extra(ira->codegen, array_type->data.pointer.child_type,
18908	18908	array_type->data.pointer.is_const, array_type->data.pointer.is_volatile,
18909	18909	PtrLenUnknown,
18910	18910	array_type->data.pointer.alignment, 0, 0);
...	...	@@ -18915,7 +18915,7 @@ static TypeTableEntry ir_analyze_instruction_slice(IrAnalyze ira, IrInstructio
18915	18915	}
18916	18916	}
18917	18917	} else if (is_slice(array_type)) {
18918		TypeTableEntry *ptr_type = array_type->data.structure.fields[slice_ptr_index].type_entry;
	18918	ZigType *ptr_type = array_type->data.structure.fields[slice_ptr_index].type_entry;
18919	18919	return_type = get_slice_type(ira->codegen, ptr_type);
18920	18920	} else {
18921	18921	ir_add_error(ira, &instruction->base,
...	...	@@ -18936,7 +18936,7 @@ static TypeTableEntry ir_analyze_instruction_slice(IrAnalyze ira, IrInstructio
18936	18936	(array_type->id == TypeTableEntryIdPointer && array_type->data.pointer.ptr_len == PtrLenSingle))
18937	18937	{
18938	18938	if (array_type->id == TypeTableEntryIdPointer) {
18939		TypeTableEntry *child_array_type = array_type->data.pointer.child_type;
	18939	ZigType *child_array_type = array_type->data.pointer.child_type;
18940	18940	assert(child_array_type->id == TypeTableEntryIdArray);
18941	18941	parent_ptr = ir_const_ptr_pointee(ira, &ptr_ptr->value, instruction->base.source_node);
18942	18942	if (parent_ptr == nullptr)
...	...	@@ -19109,12 +19109,12 @@ static TypeTableEntry ir_analyze_instruction_slice(IrAnalyze ira, IrInstructio
19109	19109	return return_type;
19110	19110	}
19111	19111
19112		static TypeTableEntry ir_analyze_instruction_member_count(IrAnalyze ira, IrInstructionMemberCount *instruction) {
	19112	static ZigType ir_analyze_instruction_member_count(IrAnalyze ira, IrInstructionMemberCount *instruction) {
19113	19113	Error err;
19114	19114	IrInstruction *container = instruction->container->other;
19115	19115	if (type_is_invalid(container->value.type))
19116	19116	return ira->codegen->builtin_types.entry_invalid;
19117		TypeTableEntry *container_type = ir_resolve_type(ira, container);
	19117	ZigType *container_type = ir_resolve_type(ira, container);
19118	19118
19119	19119	if ((err = ensure_complete_type(ira->codegen, container_type)))
19120	19120	return ira->codegen->builtin_types.entry_invalid;
...	...	@@ -19147,10 +19147,10 @@ static TypeTableEntry ir_analyze_instruction_member_count(IrAnalyze ira, IrIns
19147	19147	return ira->codegen->builtin_types.entry_num_lit_int;
19148	19148	}
19149	19149
19150		static TypeTableEntry ir_analyze_instruction_member_type(IrAnalyze ira, IrInstructionMemberType *instruction) {
	19150	static ZigType ir_analyze_instruction_member_type(IrAnalyze ira, IrInstructionMemberType *instruction) {
19151	19151	Error err;
19152	19152	IrInstruction *container_type_value = instruction->container_type->other;
19153		TypeTableEntry *container_type = ir_resolve_type(ira, container_type_value);
	19153	ZigType *container_type = ir_resolve_type(ira, container_type_value);
19154	19154	if (type_is_invalid(container_type))
19155	19155	return ira->codegen->builtin_types.entry_invalid;
19156	19156
...	...	@@ -19194,10 +19194,10 @@ static TypeTableEntry ir_analyze_instruction_member_type(IrAnalyze ira, IrInst
19194	19194	}
19195	19195	}
19196	19196
19197		static TypeTableEntry ir_analyze_instruction_member_name(IrAnalyze ira, IrInstructionMemberName *instruction) {
	19197	static ZigType ir_analyze_instruction_member_name(IrAnalyze ira, IrInstructionMemberName *instruction) {
19198	19198	Error err;
19199	19199	IrInstruction *container_type_value = instruction->container_type->other;
19200		TypeTableEntry *container_type = ir_resolve_type(ira, container_type_value);
	19200	ZigType *container_type = ir_resolve_type(ira, container_type_value);
19201	19201	if (type_is_invalid(container_type))
19202	19202	return ira->codegen->builtin_types.entry_invalid;
19203	19203
...	...	@@ -19252,28 +19252,28 @@ static TypeTableEntry ir_analyze_instruction_member_name(IrAnalyze ira, IrInst
19252	19252	}
19253	19253	}
19254	19254
19255		static TypeTableEntry ir_analyze_instruction_breakpoint(IrAnalyze ira, IrInstructionBreakpoint *instruction) {
	19255	static ZigType ir_analyze_instruction_breakpoint(IrAnalyze ira, IrInstructionBreakpoint *instruction) {
19256	19256	ir_build_breakpoint_from(&ira->new_irb, &instruction->base);
19257	19257	return ira->codegen->builtin_types.entry_void;
19258	19258	}
19259	19259
19260		static TypeTableEntry ir_analyze_instruction_return_address(IrAnalyze ira, IrInstructionReturnAddress *instruction) {
	19260	static ZigType ir_analyze_instruction_return_address(IrAnalyze ira, IrInstructionReturnAddress *instruction) {
19261	19261	ir_build_return_address_from(&ira->new_irb, &instruction->base);
19262	19262
19263		TypeTableEntry *u8 = ira->codegen->builtin_types.entry_u8;
19264		TypeTableEntry *u8_ptr_const = get_pointer_to_type(ira->codegen, u8, true);
	19263	ZigType *u8 = ira->codegen->builtin_types.entry_u8;
	19264	ZigType *u8_ptr_const = get_pointer_to_type(ira->codegen, u8, true);
19265	19265	return u8_ptr_const;
19266	19266	}
19267	19267
19268		static TypeTableEntry ir_analyze_instruction_frame_address(IrAnalyze ira, IrInstructionFrameAddress *instruction) {
	19268	static ZigType ir_analyze_instruction_frame_address(IrAnalyze ira, IrInstructionFrameAddress *instruction) {
19269	19269	ir_build_frame_address_from(&ira->new_irb, &instruction->base);
19270	19270
19271		TypeTableEntry *u8 = ira->codegen->builtin_types.entry_u8;
19272		TypeTableEntry *u8_ptr_const = get_pointer_to_type(ira->codegen, u8, true);
	19271	ZigType *u8 = ira->codegen->builtin_types.entry_u8;
	19272	ZigType *u8_ptr_const = get_pointer_to_type(ira->codegen, u8, true);
19273	19273	return u8_ptr_const;
19274	19274	}
19275	19275
19276		static TypeTableEntry ir_analyze_instruction_handle(IrAnalyze ira, IrInstructionHandle *instruction) {
	19276	static ZigType ir_analyze_instruction_handle(IrAnalyze ira, IrInstructionHandle *instruction) {
19277	19277	ir_build_handle_from(&ira->new_irb, &instruction->base);
19278	19278
19279	19279	FnTableEntry *fn_entry = exec_fn_entry(ira->new_irb.exec);
...	...	@@ -19281,12 +19281,12 @@ static TypeTableEntry ir_analyze_instruction_handle(IrAnalyze ira, IrInstructi
19281	19281	return get_promise_type(ira->codegen, fn_entry->type_entry->data.fn.fn_type_id.return_type);
19282	19282	}
19283	19283
19284		static TypeTableEntry ir_analyze_instruction_align_of(IrAnalyze ira, IrInstructionAlignOf *instruction) {
	19284	static ZigType ir_analyze_instruction_align_of(IrAnalyze ira, IrInstructionAlignOf *instruction) {
19285	19285	Error err;
19286	19286	IrInstruction *type_value = instruction->type_value->other;
19287	19287	if (type_is_invalid(type_value->value.type))
19288	19288	return ira->codegen->builtin_types.entry_invalid;
19289		TypeTableEntry *type_entry = ir_resolve_type(ira, type_value);
	19289	ZigType *type_entry = ir_resolve_type(ira, type_value);
19290	19290
19291	19291	if ((err = type_ensure_zero_bits_known(ira->codegen, type_entry)))
19292	19292	return ira->codegen->builtin_types.entry_invalid;
...	...	@@ -19332,12 +19332,12 @@ static TypeTableEntry ir_analyze_instruction_align_of(IrAnalyze ira, IrInstruc
19332	19332	zig_unreachable();
19333	19333	}
19334	19334
19335		static TypeTableEntry ir_analyze_instruction_overflow_op(IrAnalyze ira, IrInstructionOverflowOp *instruction) {
	19335	static ZigType ir_analyze_instruction_overflow_op(IrAnalyze ira, IrInstructionOverflowOp *instruction) {
19336	19336	IrInstruction *type_value = instruction->type_value->other;
19337	19337	if (type_is_invalid(type_value->value.type))
19338	19338	return ira->codegen->builtin_types.entry_invalid;
19339	19339
19340		TypeTableEntry *dest_type = ir_resolve_type(ira, type_value);
	19340	ZigType *dest_type = ir_resolve_type(ira, type_value);
19341	19341	if (type_is_invalid(dest_type))
19342	19342	return ira->codegen->builtin_types.entry_invalid;
19343	19343
...	...	@@ -19361,7 +19361,7 @@ static TypeTableEntry ir_analyze_instruction_overflow_op(IrAnalyze ira, IrInst
19361	19361
19362	19362	IrInstruction *casted_op2;
19363	19363	if (instruction->op == IrOverflowOpShl) {
19364		TypeTableEntry *shift_amt_type = get_smallest_unsigned_int_type(ira->codegen,
	19364	ZigType *shift_amt_type = get_smallest_unsigned_int_type(ira->codegen,
19365	19365	dest_type->data.integral.bit_count - 1);
19366	19366	casted_op2 = ir_implicit_cast(ira, op2, shift_amt_type);
19367	19367	} else {
...	...	@@ -19374,7 +19374,7 @@ static TypeTableEntry ir_analyze_instruction_overflow_op(IrAnalyze ira, IrInst
19374	19374	if (type_is_invalid(result_ptr->value.type))
19375	19375	return ira->codegen->builtin_types.entry_invalid;
19376	19376
19377		TypeTableEntry *expected_ptr_type;
	19377	ZigType *expected_ptr_type;
19378	19378	if (result_ptr->value.type->id == TypeTableEntryIdPointer) {
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,
...	...	@@ -19431,12 +19431,12 @@ static TypeTableEntry ir_analyze_instruction_overflow_op(IrAnalyze ira, IrInst
19431	19431	return ira->codegen->builtin_types.entry_bool;
19432	19432	}
19433	19433
19434		static TypeTableEntry ir_analyze_instruction_test_err(IrAnalyze ira, IrInstructionTestErr *instruction) {
	19434	static ZigType ir_analyze_instruction_test_err(IrAnalyze ira, IrInstructionTestErr *instruction) {
19435	19435	IrInstruction *value = instruction->value->other;
19436	19436	if (type_is_invalid(value->value.type))
19437	19437	return ira->codegen->builtin_types.entry_invalid;
19438	19438
19439		TypeTableEntry *type_entry = value->value.type;
	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	19442	} else if (type_entry->id == TypeTableEntryIdErrorUnion) {
...	...	@@ -19452,7 +19452,7 @@ static TypeTableEntry ir_analyze_instruction_test_err(IrAnalyze ira, IrInstruc
19452	19452	}
19453	19453	}
19454	19454
19455		TypeTableEntry *err_set_type = type_entry->data.error_union.err_set_type;
	19455	ZigType *err_set_type = type_entry->data.error_union.err_set_type;
19456	19456	if (!resolve_inferred_error_set(ira->codegen, err_set_type, instruction->base.source_node)) {
19457	19457	return ira->codegen->builtin_types.entry_invalid;
19458	19458	}
...	...	@@ -19478,18 +19478,18 @@ static TypeTableEntry ir_analyze_instruction_test_err(IrAnalyze ira, IrInstruc
19478	19478	}
19479	19479	}
19480	19480
19481		static TypeTableEntry ir_analyze_instruction_unwrap_err_code(IrAnalyze ira,
	19481	static ZigType ir_analyze_instruction_unwrap_err_code(IrAnalyze ira,
19482	19482	IrInstructionUnwrapErrCode *instruction)
19483	19483	{
19484	19484	IrInstruction *value = instruction->value->other;
19485	19485	if (type_is_invalid(value->value.type))
19486	19486	return ira->codegen->builtin_types.entry_invalid;
19487		TypeTableEntry *ptr_type = value->value.type;
	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	19490	assert(ptr_type->id == TypeTableEntryIdPointer);
19491	19491
19492		TypeTableEntry *type_entry = ptr_type->data.pointer.child_type;
	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	19495	} else if (type_entry->id == TypeTableEntryIdErrorUnion) {
...	...	@@ -19519,27 +19519,27 @@ static TypeTableEntry ir_analyze_instruction_unwrap_err_code(IrAnalyze ira,
19519	19519	}
19520	19520	}
19521	19521
19522		static TypeTableEntry ir_analyze_instruction_unwrap_err_payload(IrAnalyze ira,
	19522	static ZigType ir_analyze_instruction_unwrap_err_payload(IrAnalyze ira,
19523	19523	IrInstructionUnwrapErrPayload *instruction)
19524	19524	{
19525	19525	assert(instruction->value->other);
19526	19526	IrInstruction *value = instruction->value->other;
19527	19527	if (type_is_invalid(value->value.type))
19528	19528	return ira->codegen->builtin_types.entry_invalid;
19529		TypeTableEntry *ptr_type = value->value.type;
	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	19532	assert(ptr_type->id == TypeTableEntryIdPointer);
19533	19533
19534		TypeTableEntry *type_entry = ptr_type->data.pointer.child_type;
	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	19537	} else if (type_entry->id == TypeTableEntryIdErrorUnion) {
19538		TypeTableEntry *payload_type = type_entry->data.error_union.payload_type;
	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;
19541	19541	}
19542		TypeTableEntry *result_type = get_pointer_to_type_extra(ira->codegen, payload_type,
	19542	ZigType *result_type = get_pointer_to_type_extra(ira->codegen, payload_type,
19543	19543	ptr_type->data.pointer.is_const, ptr_type->data.pointer.is_volatile,
19544	19544	PtrLenSingle,
19545	19545	get_abi_alignment(ira->codegen, payload_type), 0, 0);
...	...	@@ -19575,7 +19575,7 @@ static TypeTableEntry ir_analyze_instruction_unwrap_err_payload(IrAnalyze ira,
19575	19575
19576	19576	}
19577	19577
19578		static TypeTableEntry ir_analyze_instruction_fn_proto(IrAnalyze ira, IrInstructionFnProto *instruction) {
	19578	static ZigType ir_analyze_instruction_fn_proto(IrAnalyze ira, IrInstructionFnProto *instruction) {
19579	19579	AstNode *proto_node = instruction->base.source_node;
19580	19580	assert(proto_node->type == NodeTypeFnProto);
19581	19581
...	...	@@ -19656,7 +19656,7 @@ static TypeTableEntry ir_analyze_instruction_fn_proto(IrAnalyze ira, IrInstruc
19656	19656	return ira->codegen->builtin_types.entry_type;
19657	19657	}
19658	19658
19659		static TypeTableEntry ir_analyze_instruction_test_comptime(IrAnalyze ira, IrInstructionTestComptime *instruction) {
	19659	static ZigType ir_analyze_instruction_test_comptime(IrAnalyze ira, IrInstructionTestComptime *instruction) {
19660	19660	IrInstruction *value = instruction->value->other;
19661	19661	if (type_is_invalid(value->value.type))
19662	19662	return ira->codegen->builtin_types.entry_invalid;
...	...	@@ -19666,11 +19666,11 @@ static TypeTableEntry ir_analyze_instruction_test_comptime(IrAnalyze ira, IrIn
19666	19666	return ira->codegen->builtin_types.entry_bool;
19667	19667	}
19668	19668
19669		static TypeTableEntry ir_analyze_instruction_check_switch_prongs(IrAnalyze ira,
	19669	static ZigType ir_analyze_instruction_check_switch_prongs(IrAnalyze ira,
19670	19670	IrInstructionCheckSwitchProngs *instruction)
19671	19671	{
19672	19672	IrInstruction *target_value = instruction->target_value->other;
19673		TypeTableEntry *switch_type = target_value->value.type;
	19673	ZigType *switch_type = target_value->value.type;
19674	19674	if (type_is_invalid(switch_type))
19675	19675	return ira->codegen->builtin_types.entry_invalid;
19676	19676
...	...	@@ -19846,11 +19846,11 @@ static TypeTableEntry ir_analyze_instruction_check_switch_prongs(IrAnalyze ira
19846	19846	return ira->codegen->builtin_types.entry_void;
19847	19847	}
19848	19848
19849		static TypeTableEntry ir_analyze_instruction_check_statement_is_void(IrAnalyze ira,
	19849	static ZigType ir_analyze_instruction_check_statement_is_void(IrAnalyze ira,
19850	19850	IrInstructionCheckStatementIsVoid *instruction)
19851	19851	{
19852	19852	IrInstruction *statement_value = instruction->statement_value->other;
19853		TypeTableEntry *statement_type = statement_value->value.type;
	19853	ZigType *statement_type = statement_value->value.type;
19854	19854	if (type_is_invalid(statement_type))
19855	19855	return ira->codegen->builtin_types.entry_invalid;
19856	19856
...	...	@@ -19862,7 +19862,7 @@ static TypeTableEntry *ir_analyze_instruction_check_statement_is_void(IrAnalyze
19862	19862	return ira->codegen->builtin_types.entry_void;
19863	19863	}
19864	19864
19865		static TypeTableEntry ir_analyze_instruction_panic(IrAnalyze ira, IrInstructionPanic *instruction) {
	19865	static ZigType ir_analyze_instruction_panic(IrAnalyze ira, IrInstructionPanic *instruction) {
19866	19866	IrInstruction *msg = instruction->msg->other;
19867	19867	if (type_is_invalid(msg->value.type))
19868	19868	return ir_unreach_error(ira);
...	...	@@ -19872,9 +19872,9 @@ static TypeTableEntry ir_analyze_instruction_panic(IrAnalyze ira, IrInstructio
19872	19872	return ir_unreach_error(ira);
19873	19873	}
19874	19874
19875		TypeTableEntry *u8_ptr_type = get_pointer_to_type_extra(ira->codegen, ira->codegen->builtin_types.entry_u8,
	19875	ZigType *u8_ptr_type = get_pointer_to_type_extra(ira->codegen, ira->codegen->builtin_types.entry_u8,
19876	19876	true, false, PtrLenUnknown, get_abi_alignment(ira->codegen, ira->codegen->builtin_types.entry_u8), 0, 0);
19877		TypeTableEntry *str_type = get_slice_type(ira->codegen, u8_ptr_type);
	19877	ZigType *str_type = get_slice_type(ira->codegen, u8_ptr_type);
19878	19878	IrInstruction *casted_msg = ir_implicit_cast(ira, msg, str_type);
19879	19879	if (type_is_invalid(casted_msg->value.type))
19880	19880	return ir_unreach_error(ira);
...	...	@@ -19886,10 +19886,10 @@ static TypeTableEntry ir_analyze_instruction_panic(IrAnalyze ira, IrInstructio
19886	19886	}
19887	19887
19888	19888	static IrInstruction ir_align_cast(IrAnalyze ira, IrInstruction *target, uint32_t align_bytes, bool safety_check_on) {
19889		TypeTableEntry *target_type = target->value.type;
	19889	ZigType *target_type = target->value.type;
19890	19890	assert(!type_is_invalid(target_type));
19891	19891
19892		TypeTableEntry *result_type;
	19892	ZigType *result_type;
19893	19893	uint32_t old_align_bytes;
19894	19894
19895	19895	if (target_type->id == TypeTableEntryIdPointer) {
...	...	@@ -19903,9 +19903,9 @@ static IrInstruction ir_align_cast(IrAnalyze ira, IrInstruction *target, uint3
19903	19903	} else if (target_type->id == TypeTableEntryIdOptional &&
19904	19904	target_type->data.maybe.child_type->id == TypeTableEntryIdPointer)
19905	19905	{
19906		TypeTableEntry *ptr_type = target_type->data.maybe.child_type;
	19906	ZigType *ptr_type = target_type->data.maybe.child_type;
19907	19907	old_align_bytes = ptr_type->data.pointer.alignment;
19908		TypeTableEntry *better_ptr_type = adjust_ptr_align(ira->codegen, ptr_type, align_bytes);
	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	19911	} else if (target_type->id == TypeTableEntryIdOptional &&
...	...	@@ -19914,12 +19914,12 @@ static IrInstruction ir_align_cast(IrAnalyze ira, IrInstruction *target, uint3
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;
19916	19916	fn_type_id.alignment = align_bytes;
19917		TypeTableEntry *fn_type = get_fn_type(ira->codegen, &fn_type_id);
	19917	ZigType *fn_type = get_fn_type(ira->codegen, &fn_type_id);
19918	19918	result_type = get_optional_type(ira->codegen, fn_type);
19919	19919	} else if (is_slice(target_type)) {
19920		TypeTableEntry *slice_ptr_type = target_type->data.structure.fields[slice_ptr_index].type_entry;
	19920	ZigType *slice_ptr_type = target_type->data.structure.fields[slice_ptr_index].type_entry;
19921	19921	old_align_bytes = slice_ptr_type->data.pointer.alignment;
19922		TypeTableEntry *result_ptr_type = adjust_ptr_align(ira->codegen, slice_ptr_type, align_bytes);
	19922	ZigType *result_ptr_type = adjust_ptr_align(ira->codegen, slice_ptr_type, align_bytes);
19923	19923	result_type = get_slice_type(ira->codegen, result_ptr_type);
19924	19924	} else {
19925	19925	ir_add_error(ira, target,
...	...	@@ -19957,16 +19957,16 @@ static IrInstruction ir_align_cast(IrAnalyze ira, IrInstruction *target, uint3
19957	19957	return result;
19958	19958	}
19959	19959
19960		static TypeTableEntry ir_analyze_instruction_ptr_cast(IrAnalyze ira, IrInstructionPtrCast *instruction) {
	19960	static ZigType ir_analyze_instruction_ptr_cast(IrAnalyze ira, IrInstructionPtrCast *instruction) {
19961	19961	Error err;
19962	19962
19963	19963	IrInstruction *dest_type_value = instruction->dest_type->other;
19964		TypeTableEntry *dest_type = ir_resolve_type(ira, dest_type_value);
	19964	ZigType *dest_type = ir_resolve_type(ira, dest_type_value);
19965	19965	if (type_is_invalid(dest_type))
19966	19966	return ira->codegen->builtin_types.entry_invalid;
19967	19967
19968	19968	IrInstruction *ptr = instruction->ptr->other;
19969		TypeTableEntry *src_type = ptr->value.type;
	19969	ZigType *src_type = ptr->value.type;
19970	19970	if (type_is_invalid(src_type))
19971	19971	return ira->codegen->builtin_types.entry_invalid;
19972	19972
...	...	@@ -20155,15 +20155,15 @@ static void buf_read_value_bytes(CodeGen codegen, uint8_t buf, ConstExprValue
20155	20155	zig_unreachable();
20156	20156	}
20157	20157
20158		static TypeTableEntry ir_analyze_instruction_bit_cast(IrAnalyze ira, IrInstructionBitCast *instruction) {
	20158	static ZigType ir_analyze_instruction_bit_cast(IrAnalyze ira, IrInstructionBitCast *instruction) {
20159	20159	Error err;
20160	20160	IrInstruction *dest_type_value = instruction->dest_type->other;
20161		TypeTableEntry *dest_type = ir_resolve_type(ira, dest_type_value);
	20161	ZigType *dest_type = ir_resolve_type(ira, dest_type_value);
20162	20162	if (type_is_invalid(dest_type))
20163	20163	return ira->codegen->builtin_types.entry_invalid;
20164	20164
20165	20165	IrInstruction *value = instruction->value->other;
20166		TypeTableEntry *src_type = value->value.type;
	20166	ZigType *src_type = value->value.type;
20167	20167	if (type_is_invalid(src_type))
20168	20168	return ira->codegen->builtin_types.entry_invalid;
20169	20169
...	...	@@ -20255,10 +20255,10 @@ static TypeTableEntry ir_analyze_instruction_bit_cast(IrAnalyze ira, IrInstruc
20255	20255	return dest_type;
20256	20256	}
20257	20257
20258		static TypeTableEntry ir_analyze_instruction_int_to_ptr(IrAnalyze ira, IrInstructionIntToPtr *instruction) {
	20258	static ZigType ir_analyze_instruction_int_to_ptr(IrAnalyze ira, IrInstructionIntToPtr *instruction) {
20259	20259	Error err;
20260	20260	IrInstruction *dest_type_value = instruction->dest_type->other;
20261		TypeTableEntry *dest_type = ir_resolve_type(ira, dest_type_value);
	20261	ZigType *dest_type = ir_resolve_type(ira, dest_type_value);
20262	20262	if (type_is_invalid(dest_type))
20263	20263	return ira->codegen->builtin_types.entry_invalid;
20264	20264
...	...	@@ -20300,7 +20300,7 @@ static TypeTableEntry ir_analyze_instruction_int_to_ptr(IrAnalyze ira, IrInstr
20300	20300	return dest_type;
20301	20301	}
20302	20302
20303		static TypeTableEntry ir_analyze_instruction_decl_ref(IrAnalyze ira,
	20303	static ZigType ir_analyze_instruction_decl_ref(IrAnalyze ira,
20304	20304	IrInstructionDeclRef *instruction)
20305	20305	{
20306	20306	Tld *tld = instruction->tld;
...	...	@@ -20361,12 +20361,12 @@ static TypeTableEntry ir_analyze_instruction_decl_ref(IrAnalyze ira,
20361	20361	zig_unreachable();
20362	20362	}
20363	20363
20364		static TypeTableEntry ir_analyze_instruction_ptr_to_int(IrAnalyze ira, IrInstructionPtrToInt *instruction) {
	20364	static ZigType ir_analyze_instruction_ptr_to_int(IrAnalyze ira, IrInstructionPtrToInt *instruction) {
20365	20365	IrInstruction *target = instruction->target->other;
20366	20366	if (type_is_invalid(target->value.type))
20367	20367	return ira->codegen->builtin_types.entry_invalid;
20368	20368
20369		TypeTableEntry *usize = ira->codegen->builtin_types.entry_usize;
	20369	ZigType *usize = ira->codegen->builtin_types.entry_usize;
20370	20370
20371	20371	if (get_codegen_ptr_type(target->value.type) == nullptr) {
20372	20372	ir_add_error(ira, target,
...	...	@@ -20400,9 +20400,9 @@ static TypeTableEntry ir_analyze_instruction_ptr_to_int(IrAnalyze ira, IrInstr
20400	20400	return usize;
20401	20401	}
20402	20402
20403		static TypeTableEntry ir_analyze_instruction_ptr_type(IrAnalyze ira, IrInstructionPtrType *instruction) {
	20403	static ZigType ir_analyze_instruction_ptr_type(IrAnalyze ira, IrInstructionPtrType *instruction) {
20404	20404	Error err;
20405		TypeTableEntry *child_type = ir_resolve_type(ira, instruction->child_type->other);
	20405	ZigType *child_type = ir_resolve_type(ira, instruction->child_type->other);
20406	20406	if (type_is_invalid(child_type))
20407	20407	return ira->codegen->builtin_types.entry_invalid;
20408	20408
...	...	@@ -20433,7 +20433,7 @@ static TypeTableEntry ir_analyze_instruction_ptr_type(IrAnalyze ira, IrInstruc
20433	20433	return ira->codegen->builtin_types.entry_type;
20434	20434	}
20435	20435
20436		static TypeTableEntry ir_analyze_instruction_align_cast(IrAnalyze ira, IrInstructionAlignCast *instruction) {
	20436	static ZigType ir_analyze_instruction_align_cast(IrAnalyze ira, IrInstructionAlignCast *instruction) {
20437	20437	uint32_t align_bytes;
20438	20438	IrInstruction *align_bytes_inst = instruction->align_bytes->other;
20439	20439	if (!ir_resolve_align(ira, align_bytes_inst, &align_bytes))
...	...	@@ -20451,7 +20451,7 @@ static TypeTableEntry ir_analyze_instruction_align_cast(IrAnalyze ira, IrInstr
20451	20451	return result->value.type;
20452	20452	}
20453	20453
20454		static TypeTableEntry ir_analyze_instruction_opaque_type(IrAnalyze ira, IrInstructionOpaqueType *instruction) {
	20454	static ZigType ir_analyze_instruction_opaque_type(IrAnalyze ira, IrInstructionOpaqueType *instruction) {
20455	20455	Buf *name = get_anon_type_name(ira->codegen, ira->new_irb.exec, "opaque", instruction->base.source_node);
20456	20456	ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
20457	20457	out_val->data.x_type = get_opaque_type(ira->codegen, instruction->base.scope, instruction->base.source_node,
...	...	@@ -20459,7 +20459,7 @@ static TypeTableEntry ir_analyze_instruction_opaque_type(IrAnalyze ira, IrInst
20459	20459	return ira->codegen->builtin_types.entry_type;
20460	20460	}
20461	20461
20462		static TypeTableEntry ir_analyze_instruction_set_align_stack(IrAnalyze ira, IrInstructionSetAlignStack *instruction) {
	20462	static ZigType ir_analyze_instruction_set_align_stack(IrAnalyze ira, IrInstructionSetAlignStack *instruction) {
20463	20463	uint32_t align_bytes;
20464	20464	IrInstruction *align_bytes_inst = instruction->align_bytes->other;
20465	20465	if (!ir_resolve_align(ira, align_bytes_inst, &align_bytes))
...	...	@@ -20499,9 +20499,9 @@ static TypeTableEntry ir_analyze_instruction_set_align_stack(IrAnalyze ira, Ir
20499	20499	return ira->codegen->builtin_types.entry_void;
20500	20500	}
20501	20501
20502		static TypeTableEntry ir_analyze_instruction_arg_type(IrAnalyze ira, IrInstructionArgType *instruction) {
	20502	static ZigType ir_analyze_instruction_arg_type(IrAnalyze ira, IrInstructionArgType *instruction) {
20503	20503	IrInstruction *fn_type_inst = instruction->fn_type->other;
20504		TypeTableEntry *fn_type = ir_resolve_type(ira, fn_type_inst);
	20504	ZigType *fn_type = ir_resolve_type(ira, fn_type_inst);
20505	20505	if (type_is_invalid(fn_type))
20506	20506	return ira->codegen->builtin_types.entry_invalid;
20507	20507
...	...	@@ -20538,10 +20538,10 @@ static TypeTableEntry ir_analyze_instruction_arg_type(IrAnalyze ira, IrInstruc
20538	20538	return ira->codegen->builtin_types.entry_type;
20539	20539	}
20540	20540
20541		static TypeTableEntry ir_analyze_instruction_tag_type(IrAnalyze ira, IrInstructionTagType *instruction) {
	20541	static ZigType ir_analyze_instruction_tag_type(IrAnalyze ira, IrInstructionTagType *instruction) {
20542	20542	Error err;
20543	20543	IrInstruction *target_inst = instruction->target->other;
20544		TypeTableEntry *enum_type = ir_resolve_type(ira, target_inst);
	20544	ZigType *enum_type = ir_resolve_type(ira, target_inst);
20545	20545	if (type_is_invalid(enum_type))
20546	20546	return ira->codegen->builtin_types.entry_invalid;
20547	20547
...	...	@@ -20576,7 +20576,7 @@ static TypeTableEntry ir_analyze_instruction_tag_type(IrAnalyze ira, IrInstruc
20576	20576	}
20577	20577	}
20578	20578
20579		static TypeTableEntry ir_analyze_instruction_cancel(IrAnalyze ira, IrInstructionCancel *instruction) {
	20579	static ZigType ir_analyze_instruction_cancel(IrAnalyze ira, IrInstructionCancel *instruction) {
20580	20580	IrInstruction *target_inst = instruction->target->other;
20581	20581	if (type_is_invalid(target_inst->value.type))
20582	20582	return ira->codegen->builtin_types.entry_invalid;
...	...	@@ -20591,7 +20591,7 @@ static TypeTableEntry ir_analyze_instruction_cancel(IrAnalyze ira, IrInstructi
20591	20591	return result->value.type;
20592	20592	}
20593	20593
20594		static TypeTableEntry ir_analyze_instruction_coro_id(IrAnalyze ira, IrInstructionCoroId *instruction) {
	20594	static ZigType ir_analyze_instruction_coro_id(IrAnalyze ira, IrInstructionCoroId *instruction) {
20595	20595	IrInstruction *promise_ptr = instruction->promise_ptr->other;
20596	20596	if (type_is_invalid(promise_ptr->value.type))
20597	20597	return ira->codegen->builtin_types.entry_invalid;
...	...	@@ -20603,7 +20603,7 @@ static TypeTableEntry ir_analyze_instruction_coro_id(IrAnalyze ira, IrInstruct
20603	20603	return result->value.type;
20604	20604	}
20605	20605
20606		static TypeTableEntry ir_analyze_instruction_coro_alloc(IrAnalyze ira, IrInstructionCoroAlloc *instruction) {
	20606	static ZigType ir_analyze_instruction_coro_alloc(IrAnalyze ira, IrInstructionCoroAlloc *instruction) {
20607	20607	IrInstruction *coro_id = instruction->coro_id->other;
20608	20608	if (type_is_invalid(coro_id->value.type))
20609	20609	return ira->codegen->builtin_types.entry_invalid;
...	...	@@ -20615,14 +20615,14 @@ static TypeTableEntry ir_analyze_instruction_coro_alloc(IrAnalyze ira, IrInstr
20615	20615	return result->value.type;
20616	20616	}
20617	20617
20618		static TypeTableEntry ir_analyze_instruction_coro_size(IrAnalyze ira, IrInstructionCoroSize *instruction) {
	20618	static ZigType ir_analyze_instruction_coro_size(IrAnalyze ira, IrInstructionCoroSize *instruction) {
20619	20619	IrInstruction *result = ir_build_coro_size(&ira->new_irb, instruction->base.scope, instruction->base.source_node);
20620	20620	ir_link_new_instruction(result, &instruction->base);
20621	20621	result->value.type = ira->codegen->builtin_types.entry_usize;
20622	20622	return result->value.type;
20623	20623	}
20624	20624
20625		static TypeTableEntry ir_analyze_instruction_coro_begin(IrAnalyze ira, IrInstructionCoroBegin *instruction) {
	20625	static ZigType ir_analyze_instruction_coro_begin(IrAnalyze ira, IrInstructionCoroBegin *instruction) {
20626	20626	IrInstruction *coro_id = instruction->coro_id->other;
20627	20627	if (type_is_invalid(coro_id->value.type))
20628	20628	return ira->codegen->builtin_types.entry_invalid;
...	...	@@ -20640,13 +20640,13 @@ static TypeTableEntry ir_analyze_instruction_coro_begin(IrAnalyze ira, IrInstr
20640	20640	return result->value.type;
20641	20641	}
20642	20642
20643		static TypeTableEntry ir_analyze_instruction_get_implicit_allocator(IrAnalyze ira, IrInstructionGetImplicitAllocator *instruction) {
	20643	static ZigType ir_analyze_instruction_get_implicit_allocator(IrAnalyze ira, IrInstructionGetImplicitAllocator *instruction) {
20644	20644	IrInstruction *result = ir_get_implicit_allocator(ira, &instruction->base, instruction->id);
20645	20645	ir_link_new_instruction(result, &instruction->base);
20646	20646	return result->value.type;
20647	20647	}
20648	20648
20649		static TypeTableEntry ir_analyze_instruction_coro_alloc_fail(IrAnalyze ira, IrInstructionCoroAllocFail *instruction) {
	20649	static ZigType ir_analyze_instruction_coro_alloc_fail(IrAnalyze ira, IrInstructionCoroAllocFail *instruction) {
20650	20650	IrInstruction *err_val = instruction->err_val->other;
20651	20651	if (type_is_invalid(err_val->value.type))
20652	20652	return ir_unreach_error(ira);
...	...	@@ -20657,7 +20657,7 @@ static TypeTableEntry ir_analyze_instruction_coro_alloc_fail(IrAnalyze ira, Ir
20657	20657	return ir_finish_anal(ira, result->value.type);
20658	20658	}
20659	20659
20660		static TypeTableEntry ir_analyze_instruction_coro_suspend(IrAnalyze ira, IrInstructionCoroSuspend *instruction) {
	20660	static ZigType ir_analyze_instruction_coro_suspend(IrAnalyze ira, IrInstructionCoroSuspend *instruction) {
20661	20661	IrInstruction *save_point = nullptr;
20662	20662	if (instruction->save_point != nullptr) {
20663	20663	save_point = instruction->save_point->other;
...	...	@@ -20676,7 +20676,7 @@ static TypeTableEntry ir_analyze_instruction_coro_suspend(IrAnalyze ira, IrIns
20676	20676	return result->value.type;
20677	20677	}
20678	20678
20679		static TypeTableEntry ir_analyze_instruction_coro_end(IrAnalyze ira, IrInstructionCoroEnd *instruction) {
	20679	static ZigType ir_analyze_instruction_coro_end(IrAnalyze ira, IrInstructionCoroEnd *instruction) {
20680	20680	IrInstruction *result = ir_build_coro_end(&ira->new_irb, instruction->base.scope,
20681	20681	instruction->base.source_node);
20682	20682	ir_link_new_instruction(result, &instruction->base);
...	...	@@ -20684,7 +20684,7 @@ static TypeTableEntry ir_analyze_instruction_coro_end(IrAnalyze ira, IrInstruc
20684	20684	return result->value.type;
20685	20685	}
20686	20686
20687		static TypeTableEntry ir_analyze_instruction_coro_free(IrAnalyze ira, IrInstructionCoroFree *instruction) {
	20687	static ZigType ir_analyze_instruction_coro_free(IrAnalyze ira, IrInstructionCoroFree *instruction) {
20688	20688	IrInstruction *coro_id = instruction->coro_id->other;
20689	20689	if (type_is_invalid(coro_id->value.type))
20690	20690	return ira->codegen->builtin_types.entry_invalid;
...	...	@@ -20696,12 +20696,12 @@ static TypeTableEntry ir_analyze_instruction_coro_free(IrAnalyze ira, IrInstru
20696	20696	IrInstruction *result = ir_build_coro_free(&ira->new_irb, instruction->base.scope,
20697	20697	instruction->base.source_node, coro_id, coro_handle);
20698	20698	ir_link_new_instruction(result, &instruction->base);
20699		TypeTableEntry *ptr_type = get_pointer_to_type(ira->codegen, ira->codegen->builtin_types.entry_u8, false);
	20699	ZigType *ptr_type = get_pointer_to_type(ira->codegen, ira->codegen->builtin_types.entry_u8, false);
20700	20700	result->value.type = get_optional_type(ira->codegen, ptr_type);
20701	20701	return result->value.type;
20702	20702	}
20703	20703
20704		static TypeTableEntry ir_analyze_instruction_coro_resume(IrAnalyze ira, IrInstructionCoroResume *instruction) {
	20704	static ZigType ir_analyze_instruction_coro_resume(IrAnalyze ira, IrInstructionCoroResume *instruction) {
20705	20705	IrInstruction *awaiter_handle = instruction->awaiter_handle->other;
20706	20706	if (type_is_invalid(awaiter_handle->value.type))
20707	20707	return ira->codegen->builtin_types.entry_invalid;
...	...	@@ -20717,7 +20717,7 @@ static TypeTableEntry ir_analyze_instruction_coro_resume(IrAnalyze ira, IrInst
20717	20717	return result->value.type;
20718	20718	}
20719	20719
20720		static TypeTableEntry ir_analyze_instruction_coro_save(IrAnalyze ira, IrInstructionCoroSave *instruction) {
	20720	static ZigType ir_analyze_instruction_coro_save(IrAnalyze ira, IrInstructionCoroSave *instruction) {
20721	20721	IrInstruction *coro_handle = instruction->coro_handle->other;
20722	20722	if (type_is_invalid(coro_handle->value.type))
20723	20723	return ira->codegen->builtin_types.entry_invalid;
...	...	@@ -20729,7 +20729,7 @@ static TypeTableEntry ir_analyze_instruction_coro_save(IrAnalyze ira, IrInstru
20729	20729	return result->value.type;
20730	20730	}
20731	20731
20732		static TypeTableEntry ir_analyze_instruction_coro_promise(IrAnalyze ira, IrInstructionCoroPromise *instruction) {
	20732	static ZigType ir_analyze_instruction_coro_promise(IrAnalyze ira, IrInstructionCoroPromise *instruction) {
20733	20733	IrInstruction *coro_handle = instruction->coro_handle->other;
20734	20734	if (type_is_invalid(coro_handle->value.type))
20735	20735	return ira->codegen->builtin_types.entry_invalid;
...	...	@@ -20742,7 +20742,7 @@ static TypeTableEntry ir_analyze_instruction_coro_promise(IrAnalyze ira, IrIns
20742	20742	return ira->codegen->builtin_types.entry_invalid;
20743	20743	}
20744	20744
20745		TypeTableEntry *coro_frame_type = get_promise_frame_type(ira->codegen,
	20745	ZigType *coro_frame_type = get_promise_frame_type(ira->codegen,
20746	20746	coro_handle->value.type->data.promise.result_type);
20747	20747
20748	20748	IrInstruction *result = ir_build_coro_promise(&ira->new_irb, instruction->base.scope,
...	...	@@ -20752,7 +20752,7 @@ static TypeTableEntry ir_analyze_instruction_coro_promise(IrAnalyze ira, IrIns
20752	20752	return result->value.type;
20753	20753	}
20754	20754
20755		static TypeTableEntry ir_analyze_instruction_coro_alloc_helper(IrAnalyze ira, IrInstructionCoroAllocHelper *instruction) {
	20755	static ZigType ir_analyze_instruction_coro_alloc_helper(IrAnalyze ira, IrInstructionCoroAllocHelper *instruction) {
20756	20756	IrInstruction *alloc_fn = instruction->alloc_fn->other;
20757	20757	if (type_is_invalid(alloc_fn->value.type))
20758	20758	return ira->codegen->builtin_types.entry_invalid;
...	...	@@ -20764,13 +20764,13 @@ static TypeTableEntry ir_analyze_instruction_coro_alloc_helper(IrAnalyze ira,
20764	20764	IrInstruction *result = ir_build_coro_alloc_helper(&ira->new_irb, instruction->base.scope,
20765	20765	instruction->base.source_node, alloc_fn, coro_size);
20766	20766	ir_link_new_instruction(result, &instruction->base);
20767		TypeTableEntry *u8_ptr_type = get_pointer_to_type(ira->codegen, ira->codegen->builtin_types.entry_u8, false);
	20767	ZigType *u8_ptr_type = get_pointer_to_type(ira->codegen, ira->codegen->builtin_types.entry_u8, false);
20768	20768	result->value.type = get_optional_type(ira->codegen, u8_ptr_type);
20769	20769	return result->value.type;
20770	20770	}
20771	20771
20772		static TypeTableEntry ir_resolve_atomic_operand_type(IrAnalyze ira, IrInstruction *op) {
20773		TypeTableEntry *operand_type = ir_resolve_type(ira, op);
	20772	static ZigType ir_resolve_atomic_operand_type(IrAnalyze ira, IrInstruction *op) {
	20773	ZigType *operand_type = ir_resolve_type(ira, op);
20774	20774	if (type_is_invalid(operand_type))
20775	20775	return ira->codegen->builtin_types.entry_invalid;
20776	20776
...	...	@@ -20801,8 +20801,8 @@ static TypeTableEntry ir_resolve_atomic_operand_type(IrAnalyze ira, IrInstruct
20801	20801	return operand_type;
20802	20802	}
20803	20803
20804		static TypeTableEntry ir_analyze_instruction_atomic_rmw(IrAnalyze ira, IrInstructionAtomicRmw *instruction) {
20805		TypeTableEntry *operand_type = ir_resolve_atomic_operand_type(ira, instruction->operand_type->other);
	20804	static ZigType ir_analyze_instruction_atomic_rmw(IrAnalyze ira, IrInstructionAtomicRmw *instruction) {
	20805	ZigType *operand_type = ir_resolve_atomic_operand_type(ira, instruction->operand_type->other);
20806	20806	if (type_is_invalid(operand_type))
20807	20807	return ira->codegen->builtin_types.entry_invalid;
20808	20808
...	...	@@ -20811,7 +20811,7 @@ static TypeTableEntry ir_analyze_instruction_atomic_rmw(IrAnalyze ira, IrInstr
20811	20811	return ira->codegen->builtin_types.entry_invalid;
20812	20812
20813	20813	// TODO let this be volatile
20814		TypeTableEntry *ptr_type = get_pointer_to_type(ira->codegen, operand_type, false);
	20814	ZigType *ptr_type = get_pointer_to_type(ira->codegen, operand_type, false);
20815	20815	IrInstruction *casted_ptr = ir_implicit_cast(ira, ptr_inst, ptr_type);
20816	20816	if (type_is_invalid(casted_ptr->value.type))
20817	20817	return ira->codegen->builtin_types.entry_invalid;
...	...	@@ -20859,8 +20859,8 @@ static TypeTableEntry ir_analyze_instruction_atomic_rmw(IrAnalyze ira, IrInstr
20859	20859	return result->value.type;
20860	20860	}
20861	20861
20862		static TypeTableEntry ir_analyze_instruction_atomic_load(IrAnalyze ira, IrInstructionAtomicLoad *instruction) {
20863		TypeTableEntry *operand_type = ir_resolve_atomic_operand_type(ira, instruction->operand_type->other);
	20862	static ZigType ir_analyze_instruction_atomic_load(IrAnalyze ira, IrInstructionAtomicLoad *instruction) {
	20863	ZigType *operand_type = ir_resolve_atomic_operand_type(ira, instruction->operand_type->other);
20864	20864	if (type_is_invalid(operand_type))
20865	20865	return ira->codegen->builtin_types.entry_invalid;
20866	20866
...	...	@@ -20868,7 +20868,7 @@ static TypeTableEntry ir_analyze_instruction_atomic_load(IrAnalyze ira, IrInst
20868	20868	if (type_is_invalid(ptr_inst->value.type))
20869	20869	return ira->codegen->builtin_types.entry_invalid;
20870	20870
20871		TypeTableEntry *ptr_type = get_pointer_to_type(ira->codegen, operand_type, true);
	20871	ZigType *ptr_type = get_pointer_to_type(ira->codegen, operand_type, true);
20872	20872	IrInstruction *casted_ptr = ir_implicit_cast(ira, ptr_inst, ptr_type);
20873	20873	if (type_is_invalid(casted_ptr->value.type))
20874	20874	return ira->codegen->builtin_types.entry_invalid;
...	...	@@ -20902,8 +20902,8 @@ static TypeTableEntry ir_analyze_instruction_atomic_load(IrAnalyze ira, IrInst
20902	20902	return result->value.type;
20903	20903	}
20904	20904
20905		static TypeTableEntry ir_analyze_instruction_promise_result_type(IrAnalyze ira, IrInstructionPromiseResultType *instruction) {
20906		TypeTableEntry *promise_type = ir_resolve_type(ira, instruction->promise_type->other);
	20905	static ZigType ir_analyze_instruction_promise_result_type(IrAnalyze ira, IrInstructionPromiseResultType *instruction) {
	20906	ZigType *promise_type = ir_resolve_type(ira, instruction->promise_type->other);
20907	20907	if (type_is_invalid(promise_type))
20908	20908	return ira->codegen->builtin_types.entry_invalid;
20909	20909
...	...	@@ -20918,8 +20918,8 @@ static TypeTableEntry ir_analyze_instruction_promise_result_type(IrAnalyze ira
20918	20918	return ira->codegen->builtin_types.entry_type;
20919	20919	}
20920	20920
20921		static TypeTableEntry ir_analyze_instruction_await_bookkeeping(IrAnalyze ira, IrInstructionAwaitBookkeeping *instruction) {
20922		TypeTableEntry *promise_result_type = ir_resolve_type(ira, instruction->promise_result_type->other);
	20921	static ZigType ir_analyze_instruction_await_bookkeeping(IrAnalyze ira, IrInstructionAwaitBookkeeping *instruction) {
	20922	ZigType *promise_result_type = ir_resolve_type(ira, instruction->promise_result_type->other);
20923	20923	if (type_is_invalid(promise_result_type))
20924	20924	return ira->codegen->builtin_types.entry_invalid;
20925	20925
...	...	@@ -20935,7 +20935,7 @@ static TypeTableEntry ir_analyze_instruction_await_bookkeeping(IrAnalyze ira,
20935	20935	return out_val->type;
20936	20936	}
20937	20937
20938		static TypeTableEntry ir_analyze_instruction_merge_err_ret_traces(IrAnalyze ira,
	20938	static ZigType ir_analyze_instruction_merge_err_ret_traces(IrAnalyze ira,
20939	20939	IrInstructionMergeErrRetTraces *instruction)
20940	20940	{
20941	20941	IrInstruction *coro_promise_ptr = instruction->coro_promise_ptr->other;
...	...	@@ -20943,9 +20943,9 @@ static TypeTableEntry ir_analyze_instruction_merge_err_ret_traces(IrAnalyze ir
20943	20943	return ira->codegen->builtin_types.entry_invalid;
20944	20944
20945	20945	assert(coro_promise_ptr->value.type->id == TypeTableEntryIdPointer);
20946		TypeTableEntry *promise_frame_type = coro_promise_ptr->value.type->data.pointer.child_type;
	20946	ZigType *promise_frame_type = coro_promise_ptr->value.type->data.pointer.child_type;
20947	20947	assert(promise_frame_type->id == TypeTableEntryIdStruct);
20948		TypeTableEntry *promise_result_type = promise_frame_type->data.structure.fields[1].type_entry;
	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)) {
20951	20951	ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
...	...	@@ -20968,7 +20968,7 @@ static TypeTableEntry ir_analyze_instruction_merge_err_ret_traces(IrAnalyze ir
20968	20968	return result->value.type;
20969	20969	}
20970	20970
20971		static TypeTableEntry ir_analyze_instruction_save_err_ret_addr(IrAnalyze ira, IrInstructionSaveErrRetAddr *instruction) {
	20971	static ZigType ir_analyze_instruction_save_err_ret_addr(IrAnalyze ira, IrInstructionSaveErrRetAddr *instruction) {
20972	20972	IrInstruction *result = ir_build_save_err_ret_addr(&ira->new_irb, instruction->base.scope,
20973	20973	instruction->base.source_node);
20974	20974	ir_link_new_instruction(result, &instruction->base);
...	...	@@ -20976,7 +20976,7 @@ static TypeTableEntry ir_analyze_instruction_save_err_ret_addr(IrAnalyze ira,
20976	20976	return result->value.type;
20977	20977	}
20978	20978
20979		static TypeTableEntry ir_analyze_instruction_mark_err_ret_trace_ptr(IrAnalyze ira, IrInstructionMarkErrRetTracePtr *instruction) {
	20979	static ZigType ir_analyze_instruction_mark_err_ret_trace_ptr(IrAnalyze ira, IrInstructionMarkErrRetTracePtr *instruction) {
20980	20980	IrInstruction *err_ret_trace_ptr = instruction->err_ret_trace_ptr->other;
20981	20981	if (type_is_invalid(err_ret_trace_ptr->value.type))
20982	20982	return ira->codegen->builtin_types.entry_invalid;
...	...	@@ -20988,8 +20988,8 @@ static TypeTableEntry ir_analyze_instruction_mark_err_ret_trace_ptr(IrAnalyze
20988	20988	return result->value.type;
20989	20989	}
20990	20990
20991		static TypeTableEntry ir_analyze_instruction_sqrt(IrAnalyze ira, IrInstructionSqrt *instruction) {
20992		TypeTableEntry *float_type = ir_resolve_type(ira, instruction->type->other);
	20991	static ZigType ir_analyze_instruction_sqrt(IrAnalyze ira, IrInstructionSqrt *instruction) {
	20992	ZigType *float_type = ir_resolve_type(ira, instruction->type->other);
20993	20993	if (type_is_invalid(float_type))
20994	20994	return ira->codegen->builtin_types.entry_invalid;
20995	20995
...	...	@@ -21055,7 +21055,7 @@ static TypeTableEntry ir_analyze_instruction_sqrt(IrAnalyze ira, IrInstruction
21055	21055	return result->value.type;
21056	21056	}
21057	21057
21058		static TypeTableEntry ir_analyze_instruction_enum_to_int(IrAnalyze ira, IrInstructionEnumToInt *instruction) {
	21058	static ZigType ir_analyze_instruction_enum_to_int(IrAnalyze ira, IrInstructionEnumToInt *instruction) {
21059	21059	Error err;
21060	21060	IrInstruction *target = instruction->target->other;
21061	21061	if (type_is_invalid(target->value.type))
...	...	@@ -21070,17 +21070,17 @@ static TypeTableEntry ir_analyze_instruction_enum_to_int(IrAnalyze ira, IrInst
21070	21070	if ((err = type_ensure_zero_bits_known(ira->codegen, target->value.type)))
21071	21071	return ira->codegen->builtin_types.entry_invalid;
21072	21072
21073		TypeTableEntry *tag_type = target->value.type->data.enumeration.tag_int_type;
	21073	ZigType *tag_type = target->value.type->data.enumeration.tag_int_type;
21074	21074
21075	21075	IrInstruction *result = ir_analyze_enum_to_int(ira, &instruction->base, target, tag_type);
21076	21076	ir_link_new_instruction(result, &instruction->base);
21077	21077	return result->value.type;
21078	21078	}
21079	21079
21080		static TypeTableEntry ir_analyze_instruction_int_to_enum(IrAnalyze ira, IrInstructionIntToEnum *instruction) {
	21080	static ZigType ir_analyze_instruction_int_to_enum(IrAnalyze ira, IrInstructionIntToEnum *instruction) {
21081	21081	Error err;
21082	21082	IrInstruction *dest_type_value = instruction->dest_type->other;
21083		TypeTableEntry *dest_type = ir_resolve_type(ira, dest_type_value);
	21083	ZigType *dest_type = ir_resolve_type(ira, dest_type_value);
21084	21084	if (type_is_invalid(dest_type))
21085	21085	return ira->codegen->builtin_types.entry_invalid;
21086	21086
...	...	@@ -21093,7 +21093,7 @@ static TypeTableEntry ir_analyze_instruction_int_to_enum(IrAnalyze ira, IrInst
21093	21093	if ((err = type_ensure_zero_bits_known(ira->codegen, dest_type)))
21094	21094	return ira->codegen->builtin_types.entry_invalid;
21095	21095
21096		TypeTableEntry *tag_type = dest_type->data.enumeration.tag_int_type;
	21096	ZigType *tag_type = dest_type->data.enumeration.tag_int_type;
21097	21097
21098	21098	IrInstruction *target = instruction->target->other;
21099	21099	if (type_is_invalid(target->value.type))
...	...	@@ -21108,7 +21108,7 @@ static TypeTableEntry ir_analyze_instruction_int_to_enum(IrAnalyze ira, IrInst
21108	21108	return result->value.type;
21109	21109	}
21110	21110
21111		static TypeTableEntry ir_analyze_instruction_check_runtime_scope(IrAnalyze ira, IrInstructionCheckRuntimeScope *instruction) {
	21111	static ZigType ir_analyze_instruction_check_runtime_scope(IrAnalyze ira, IrInstructionCheckRuntimeScope *instruction) {
21112	21112	IrInstruction *block_comptime_inst = instruction->scope_is_comptime->other;
21113	21113	bool scope_is_comptime;
21114	21114	if (!ir_resolve_bool(ira, block_comptime_inst, &scope_is_comptime))
...	...	@@ -21131,7 +21131,7 @@ static TypeTableEntry ir_analyze_instruction_check_runtime_scope(IrAnalyze ira
21131	21131	return ira->codegen->builtin_types.entry_void;
21132	21132	}
21133	21133
21134		static TypeTableEntry ir_analyze_instruction_nocast(IrAnalyze ira, IrInstruction *instruction) {
	21134	static ZigType ir_analyze_instruction_nocast(IrAnalyze ira, IrInstruction *instruction) {
21135	21135	switch (instruction->id) {
21136	21136	case IrInstructionIdInvalid:
21137	21137	case IrInstructionIdWidenOrShorten:
...	...	@@ -21413,8 +21413,8 @@ static TypeTableEntry ir_analyze_instruction_nocast(IrAnalyze ira, IrInstructi
21413	21413	zig_unreachable();
21414	21414	}
21415	21415
21416		static TypeTableEntry ir_analyze_instruction(IrAnalyze ira, IrInstruction *instruction) {
21417		TypeTableEntry *instruction_type = ir_analyze_instruction_nocast(ira, instruction);
	21416	static ZigType ir_analyze_instruction(IrAnalyze ira, IrInstruction *instruction) {
	21417	ZigType *instruction_type = ir_analyze_instruction_nocast(ira, instruction);
21418	21418	instruction->value.type = instruction_type;
21419	21419
21420	21420	if (instruction->other) {
...	...	@@ -21430,8 +21430,8 @@ static TypeTableEntry ir_analyze_instruction(IrAnalyze ira, IrInstruction *ins
21430	21430
21431	21431	// This function attempts to evaluate IR code while doing type checking and other analysis.
21432	21432	// It emits a new IrExecutable which is partially evaluated IR code.
21433		TypeTableEntry ir_analyze(CodeGen codegen, IrExecutable old_exec, IrExecutable new_exec,
21434		TypeTableEntry expected_type, AstNode expected_type_source_node)
	21433	ZigType ir_analyze(CodeGen codegen, IrExecutable old_exec, IrExecutable new_exec,
	21434	ZigType expected_type, AstNode expected_type_source_node)
21435	21435	{
21436	21436	assert(!old_exec->invalid);
21437	21437	assert(expected_type == nullptr \|\| !type_is_invalid(expected_type));
...	...	@@ -21472,7 +21472,7 @@ TypeTableEntry ir_analyze(CodeGen codegen, IrExecutable *old_exec, IrExecutabl
21472	21472	continue;
21473	21473	}
21474	21474
21475		TypeTableEntry *return_type = ir_analyze_instruction(ira, old_instruction);
	21475	ZigType *return_type = ir_analyze_instruction(ira, old_instruction);
21476	21476	if (type_is_invalid(return_type) && ir_should_inline(new_exec, old_instruction->scope)) {
21477	21477	return ira->codegen->builtin_types.entry_invalid;
21478	21478	}

src/ir.hpp+3-3

...	...	@@ -14,12 +14,12 @@ bool ir_gen(CodeGen g, AstNode node, Scope scope, IrExecutable ir_executable
14	14	bool ir_gen_fn(CodeGen g, FnTableEntry fn_entry);
15	15
16	16	IrInstruction ir_eval_const_value(CodeGen codegen, Scope scope, AstNode node,
17		TypeTableEntry expected_type, size_t backward_branch_count, size_t backward_branch_quota,
	17	ZigType expected_type, size_t backward_branch_count, size_t backward_branch_quota,
18	18	FnTableEntry fn_entry, Buf c_import_buf, AstNode source_node, Buf exec_name,
19	19	IrExecutable *parent_exec);
20	20
21		TypeTableEntry ir_analyze(CodeGen g, IrExecutable old_executable, IrExecutable new_executable,
22		TypeTableEntry expected_type, AstNode expected_type_source_node);
	21	ZigType ir_analyze(CodeGen g, IrExecutable old_executable, IrExecutable new_executable,
	22	ZigType expected_type, AstNode expected_type_source_node);
23	23
24	24	bool ir_has_side_effects(IrInstruction *instruction);
25	25	ConstExprValue const_ptr_pointee(CodeGen codegen, ConstExprValue *const_val);