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

src/analyze.cpp+217-217

src/analyze.hpp+85-85

src/codegen.cpp+192-192

src/ir.cpp+553-553

src/ir.hpp+3-3

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

...	@@ -19,12 +19,12 @@	...	@@ -19,12 +19,12 @@
19		19
20	static const size_t default_backward_branch_quota = 1000;	20	static const size_t default_backward_branch_quota = 1000;
21		21
22	static Error resolve_enum_type(CodeGen g, TypeTableEntry enum_type);	22	static Error resolve_enum_type(CodeGen g, ZigType enum_type);
23	static Error resolve_struct_type(CodeGen g, TypeTableEntry struct_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);	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, TypeTableEntry enum_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, TypeTableEntry union_type);	27	static Error ATTRIBUTE_MUST_USE resolve_union_zero_bits(CodeGen g, ZigType union_type);
28	static void analyze_fn_body(CodeGen g, FnTableEntry fn_table_entry);	28	static void analyze_fn_body(CodeGen g, FnTableEntry fn_table_entry);
29		29
30	ErrorMsg add_node_error(CodeGen g, AstNode node, Buf msg) {	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,13 +70,13 @@ ErrorMsg add_error_note(CodeGen g, ErrorMsg parent_msg, AstNode node, Buf *m
70	return err;	70	return err;
71	}	71	}
72		72
73	TypeTableEntry *new_type_table_entry(TypeTableEntryId id) {	73	ZigType *new_type_table_entry(ZigTypeId id) {
74	TypeTableEntry *entry = allocate<TypeTableEntry>(1);	74	ZigType *entry = allocate<ZigType>(1);
75	entry->id = id;	75	entry->id = id;
76	return entry;	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	if (type_entry->id == TypeTableEntryIdStruct) {	80	if (type_entry->id == TypeTableEntryIdStruct) {
81	return &type_entry->data.structure.decls_scope;	81	return &type_entry->data.structure.decls_scope;
82	} else if (type_entry->id == TypeTableEntryIdEnum) {	82	} else if (type_entry->id == TypeTableEntryIdEnum) {
...	@@ -87,7 +87,7 @@ static ScopeDecls *get_container_scope_ptr(TypeTableEntry type_entry) {	...	@@ -87,7 +87,7 @@ static ScopeDecls *get_container_scope_ptr(TypeTableEntry type_entry) {
87	zig_unreachable();	87	zig_unreachable();
88	}	88	}
89		89
90	ScopeDecls get_container_scope(TypeTableEntry type_entry) {	90	ScopeDecls get_container_scope(ZigType type_entry) {
91	return *get_container_scope_ptr(type_entry);	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,7 +97,7 @@ void init_scope(Scope dest, ScopeId id, AstNode source_node, Scope *parent) {
97	dest->parent = parent;	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) {

...	@@ -14,35 +14,35 @@	...	@@ -14,35 +14,35 @@
14	void semantic_analyze(CodeGen *g);	14	void semantic_analyze(CodeGen *g);
15	ErrorMsg add_node_error(CodeGen g, AstNode node, Buf msg);	15	ErrorMsg add_node_error(CodeGen g, AstNode node, Buf msg);
16	ErrorMsg add_error_note(CodeGen g, ErrorMsg parent_msg, AstNode node, Buf *msg);	16	ErrorMsg add_error_note(CodeGen g, ErrorMsg parent_msg, AstNode node, Buf *msg);
17	TypeTableEntry *new_type_table_entry(TypeTableEntryId id);	17	ZigType *new_type_table_entry(ZigTypeId id);
18	TypeTableEntry get_pointer_to_type(CodeGen g, TypeTableEntry *child_type, bool is_const);	18	ZigType get_pointer_to_type(CodeGen g, ZigType *child_type, bool is_const);
19	TypeTableEntry get_pointer_to_type_extra(CodeGen g, TypeTableEntry *child_type, bool is_const,	19	ZigType get_pointer_to_type_extra(CodeGen g, ZigType *child_type, bool is_const,
20	bool is_volatile, PtrLen ptr_len, uint32_t byte_alignment, uint32_t bit_offset, uint32_t unaligned_bit_count);	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);	21	uint64_t type_size(CodeGen g, ZigType type_entry);
22	uint64_t type_size_bits(CodeGen g, TypeTableEntry type_entry);	22	uint64_t type_size_bits(CodeGen g, ZigType type_entry);
23	TypeTableEntry get_int_type(CodeGen g, bool is_signed, uint32_t size_in_bits);	23	ZigType 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);	24	ZigType *get_c_int_type_ptr(CodeGen g, CIntType c_int_type);
25	TypeTableEntry get_c_int_type(CodeGen g, CIntType c_int_type);	25	ZigType get_c_int_type(CodeGen g, CIntType c_int_type);
26	TypeTableEntry get_fn_type(CodeGen g, FnTypeId *fn_type_id);	26	ZigType get_fn_type(CodeGen g, FnTypeId *fn_type_id);
27	TypeTableEntry get_optional_type(CodeGen g, TypeTableEntry *child_type);	27	ZigType get_optional_type(CodeGen g, ZigType *child_type);
28	TypeTableEntry get_array_type(CodeGen g, TypeTableEntry *child_type, uint64_t array_size);	28	ZigType get_array_type(CodeGen g, ZigType *child_type, uint64_t array_size);
29	TypeTableEntry get_slice_type(CodeGen g, TypeTableEntry *ptr_type);	29	ZigType get_slice_type(CodeGen g, ZigType *ptr_type);
30	TypeTableEntry get_partial_container_type(CodeGen g, Scope *scope, ContainerKind kind,	30	ZigType get_partial_container_type(CodeGen g, Scope *scope, ContainerKind kind,
31	AstNode decl_node, const char name, ContainerLayout layout);	31	AstNode decl_node, const char name, ContainerLayout layout);
32	TypeTableEntry get_smallest_unsigned_int_type(CodeGen g, uint64_t x);	32	ZigType 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);	33	ZigType get_error_union_type(CodeGen g, ZigType err_set_type, ZigType payload_type);
34	TypeTableEntry get_bound_fn_type(CodeGen g, FnTableEntry *fn_entry);	34	ZigType get_bound_fn_type(CodeGen g, FnTableEntry *fn_entry);
35	TypeTableEntry get_opaque_type(CodeGen g, Scope scope, AstNode source_node, const char *name);	35	ZigType 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[],	36	ZigType get_struct_type(CodeGen g, const char type_name, const char field_names[],
37	TypeTableEntry *field_types[], size_t field_count);	37	ZigType *field_types[], size_t field_count);
38	TypeTableEntry get_promise_type(CodeGen g, TypeTableEntry *result_type);	38	ZigType get_promise_type(CodeGen g, ZigType *result_type);
39	TypeTableEntry get_promise_frame_type(CodeGen g, TypeTableEntry *return_type);	39	ZigType get_promise_frame_type(CodeGen g, ZigType *return_type);
40	TypeTableEntry get_test_fn_type(CodeGen g);	40	ZigType get_test_fn_type(CodeGen g);
41	bool handle_is_ptr(TypeTableEntry *type_entry);	41	bool handle_is_ptr(ZigType *type_entry);
42	void find_libc_include_path(CodeGen *g);	42	void find_libc_include_path(CodeGen *g);
43	void find_libc_lib_path(CodeGen *g);	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	ImportTableEntry add_source_file(CodeGen g, PackageTableEntry package, Buf abs_full_path, Buf *source_code);	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,28 +51,28 @@ ImportTableEntry add_source_file(CodeGen g, PackageTableEntry package, Buf a
51	VariableTableEntry find_variable(CodeGen g, Scope orig_context, Buf name);	51	VariableTableEntry find_variable(CodeGen g, Scope orig_context, Buf name);
52	Tld find_decl(CodeGen g, Scope scope, Buf name);	52	Tld find_decl(CodeGen g, Scope scope, Buf name);
53	void resolve_top_level_decl(CodeGen g, Tld tld, bool pointer_only, AstNode *source_node);	53	void resolve_top_level_decl(CodeGen g, Tld tld, bool pointer_only, AstNode *source_node);

...	@@ -437,11 +437,11 @@ static uint32_t get_err_ret_trace_arg_index(CodeGen g, FnTableEntry fn_table_e	...	@@ -437,11 +437,11 @@ static uint32_t get_err_ret_trace_arg_index(CodeGen g, FnTableEntry fn_table_e
437	if (fn_table_entry->type_entry->data.fn.fn_type_id.cc == CallingConventionAsync) {	437	if (fn_table_entry->type_entry->data.fn.fn_type_id.cc == CallingConventionAsync) {
438	return 0;	438	return 0;
439	}	439	}
440	TypeTableEntry *fn_type = fn_table_entry->type_entry;	440	ZigType *fn_type = fn_table_entry->type_entry;
441	if (!fn_type_can_fail(&fn_type->data.fn.fn_type_id)) {	441	if (!fn_type_can_fail(&fn_type->data.fn.fn_type_id)) {
442	return UINT32_MAX;	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	bool first_arg_ret = type_has_bits(return_type) && handle_is_ptr(return_type);	445	bool first_arg_ret = type_has_bits(return_type) && handle_is_ptr(return_type);
446	return first_arg_ret ? 1 : 0;	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,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	LLVMTypeRef fn_llvm_type = fn_type->data.fn.raw_type_ref;	478	LLVMTypeRef fn_llvm_type = fn_type->data.fn.raw_type_ref;
479	if (fn_table_entry->body_node == nullptr) {	479	if (fn_table_entry->body_node == nullptr) {
480	LLVMValueRef existing_llvm_fn = LLVMGetNamedFunction(g->module, buf_ptr(symbol_name));	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,7 +532,7 @@ static LLVMValueRef fn_llvm_value(CodeGen g, FnTableEntry fn_table_entry) {
532	LLVMSetUnnamedAddr(fn_table_entry->llvm_value, true);	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	if (return_type->id == TypeTableEntryIdUnreachable) {	536	if (return_type->id == TypeTableEntryIdUnreachable) {
537	addLLVMFnAttr(fn_table_entry->llvm_value, "noreturn");	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,7 +596,7 @@ static LLVMValueRef fn_llvm_value(CodeGen g, FnTableEntry fn_table_entry) {
596		596
597	FnTypeParamInfo *param_info = &fn_type->data.fn.fn_type_id.param_info[param_i];	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	if (param_info->is_noalias) {	600	if (param_info->is_noalias) {
601	addLLVMArgAttr(fn_table_entry->llvm_value, (unsigned)gen_index, "noalias");	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,7 +688,7 @@ static void clear_debug_source_node(CodeGen *g) {
688	ZigLLVMClearCurrentDebugLocation(g->builder);	688	ZigLLVMClearCurrentDebugLocation(g->builder);
689	}	689	}
690		690

...	@@ -33,7 +33,7 @@ struct IrAnalyze {	...	@@ -33,7 +33,7 @@ struct IrAnalyze {
33	IrExecContext exec_context;	33	IrExecContext exec_context;
34	size_t old_bb_index;	34	size_t old_bb_index;
35	size_t instruction_index;	35	size_t instruction_index;
36	TypeTableEntry *explicit_return_type;	36	ZigType *explicit_return_type;
37	ZigList<IrInstruction *> src_implicit_return_type_list;	37	ZigList<IrInstruction *> src_implicit_return_type_list;
38	IrBasicBlock *const_predecessor_bb;	38	IrBasicBlock *const_predecessor_bb;
39	};	39	};
...	@@ -99,38 +99,38 @@ struct ConstCastOnly {	...	@@ -99,38 +99,38 @@ struct ConstCastOnly {
99	};	99	};
100		100
101	struct ConstCastTypeMismatch {	101	struct ConstCastTypeMismatch {
102	TypeTableEntry *wanted_type;	102	ZigType *wanted_type;
103	TypeTableEntry *actual_type;	103	ZigType *actual_type;
104	};	104	};
105		105
106	struct ConstCastOptionalMismatch {	106	struct ConstCastOptionalMismatch {
107	ConstCastOnly child;	107	ConstCastOnly child;
108	TypeTableEntry *wanted_child;	108	ZigType *wanted_child;
109	TypeTableEntry *actual_child;	109	ZigType *actual_child;
110	};	110	};
111		111
112	struct ConstCastPointerMismatch {	112	struct ConstCastPointerMismatch {
113	ConstCastOnly child;	113	ConstCastOnly child;
114	TypeTableEntry *wanted_child;	114	ZigType *wanted_child;
115	TypeTableEntry *actual_child;	115	ZigType *actual_child;
116	};	116	};
117		117
118	struct ConstCastSliceMismatch {	118	struct ConstCastSliceMismatch {
119	ConstCastOnly child;	119	ConstCastOnly child;
120	TypeTableEntry *wanted_child;	120	ZigType *wanted_child;
121	TypeTableEntry *actual_child;	121	ZigType *actual_child;
122	};	122	};
123		123
124	struct ConstCastErrUnionErrSetMismatch {	124	struct ConstCastErrUnionErrSetMismatch {
125	ConstCastOnly child;	125	ConstCastOnly child;
126	TypeTableEntry *wanted_err_set;	126	ZigType *wanted_err_set;
127	TypeTableEntry *actual_err_set;	127	ZigType *actual_err_set;
128	};	128	};
129		129