Commit 02cb220faf0d527b656a3a87ec96e6738770c8e6 | zig

author	Jimmi Holst Christensen <jhc@dismail.de> 2018-06-05 11:14:43+02:00
committer	Jimmi Holst Christensen <jhc@dismail.de> 2018-06-05 11:14:43+02:00
log	02cb220faf0d527b656a3a87ec96e6738770c8e6
tree	5d79c58df7d786e3fa8adc0bc382fffa3ccafe60
parent	e53b683bd3958a7b1c517e2391edce42b9d4e48b

Renamed "(int/float literal)" to "comptime_int/float"

13 files changed, 230 insertions(+), 216 deletions(-)

doc
- langref.html.in
src
std
- math
test
- cases
  - math.zig
  - misc.zig
- compile_errors.zig

doc/langref.html.in+9-9

...	...	@@ -4893,8 +4893,8 @@ pub const TypeId = enum {
4893	4893	Pointer,
4894	4894	Array,
4895	4895	Struct,
4896		FloatLiteral,
4897		IntLiteral,
	4896	ComptimeFloat,
	4897	ComptimeInt,
4898	4898	UndefinedLiteral,
4899	4899	NullLiteral,
4900	4900	Nullable,
...	...	@@ -4927,8 +4927,8 @@ pub const TypeInfo = union(TypeId) {
4927	4927	Pointer: Pointer,
4928	4928	Array: Array,
4929	4929	Struct: Struct,
4930		FloatLiteral: void,
4931		IntLiteral: void,
	4930	ComptimeFloat: void,
	4931	ComptimeInt: void,
4932	4932	UndefinedLiteral: void,
4933	4933	NullLiteral: void,
4934	4934	Nullable: Nullable,
...	...	@@ -5685,8 +5685,8 @@ pub const TypeId = enum {
5685	5685	Pointer,
5686	5686	Array,
5687	5687	Struct,
5688		FloatLiteral,
5689		IntLiteral,
	5688	ComptimeFloat,
	5689	ComptimeInt,
5690	5690	UndefinedLiteral,
5691	5691	NullLiteral,
5692	5692	Nullable,
...	...	@@ -5713,10 +5713,10 @@ pub const TypeInfo = union(TypeId) {
5713	5713	Pointer: Pointer,
5714	5714	Array: Array,
5715	5715	Struct: Struct,
5716		FloatLiteral: void,
5717		IntLiteral: void,
	5716	ComptimeFloat: void,
	5717	ComptimeInt: void,
5718	5718	UndefinedLiteral: void,
5719		NullLiteral: void,
	5719	Null: void,
5720	5720	Nullable: Nullable,
5721	5721	ErrorUnion: ErrorUnion,
5722	5722	ErrorSet: ErrorSet,

src/all_types.hpp+2-2

...	...	@@ -1159,8 +1159,8 @@ enum TypeTableEntryId {
1159	1159	TypeTableEntryIdPointer,
1160	1160	TypeTableEntryIdArray,
1161	1161	TypeTableEntryIdStruct,
1162		TypeTableEntryIdNumLitFloat,
1163		TypeTableEntryIdNumLitInt,
	1162	TypeTableEntryIdComptimeFloat,
	1163	TypeTableEntryIdComptimeInt,
1164	1164	TypeTableEntryIdUndefLit,
1165	1165	TypeTableEntryIdNullLit,
1166	1166	TypeTableEntryIdMaybe,

src/analyze.cpp+47-47

...	...	@@ -232,8 +232,8 @@ bool type_is_complete(TypeTableEntry *type_entry) {
232	232	case TypeTableEntryIdFloat:
233	233	case TypeTableEntryIdPointer:
234	234	case TypeTableEntryIdArray:
235		case TypeTableEntryIdNumLitFloat:
236		case TypeTableEntryIdNumLitInt:
	235	case TypeTableEntryIdComptimeFloat:
	236	case TypeTableEntryIdComptimeInt:
237	237	case TypeTableEntryIdUndefLit:
238	238	case TypeTableEntryIdNullLit:
239	239	case TypeTableEntryIdMaybe:
...	...	@@ -268,8 +268,8 @@ bool type_has_zero_bits_known(TypeTableEntry *type_entry) {
268	268	case TypeTableEntryIdFloat:
269	269	case TypeTableEntryIdPointer:
270	270	case TypeTableEntryIdArray:
271		case TypeTableEntryIdNumLitFloat:
272		case TypeTableEntryIdNumLitInt:
	271	case TypeTableEntryIdComptimeFloat:
	272	case TypeTableEntryIdComptimeInt:
273	273	case TypeTableEntryIdUndefLit:
274	274	case TypeTableEntryIdNullLit:
275	275	case TypeTableEntryIdMaybe:
...	...	@@ -1333,8 +1333,8 @@ static bool type_allowed_in_packed_struct(TypeTableEntry *type_entry) {
1333	1333	zig_unreachable();
1334	1334	case TypeTableEntryIdMetaType:
1335	1335	case TypeTableEntryIdUnreachable:
1336		case TypeTableEntryIdNumLitFloat:
1337		case TypeTableEntryIdNumLitInt:
	1336	case TypeTableEntryIdComptimeFloat:
	1337	case TypeTableEntryIdComptimeInt:
1338	1338	case TypeTableEntryIdUndefLit:
1339	1339	case TypeTableEntryIdNullLit:
1340	1340	case TypeTableEntryIdErrorUnion:
...	...	@@ -1374,8 +1374,8 @@ static bool type_allowed_in_extern(CodeGen g, TypeTableEntry type_entry) {
1374	1374	case TypeTableEntryIdInvalid:
1375	1375	zig_unreachable();
1376	1376	case TypeTableEntryIdMetaType:
1377		case TypeTableEntryIdNumLitFloat:
1378		case TypeTableEntryIdNumLitInt:
	1377	case TypeTableEntryIdComptimeFloat:
	1378	case TypeTableEntryIdComptimeInt:
1379	1379	case TypeTableEntryIdUndefLit:
1380	1380	case TypeTableEntryIdNullLit:
1381	1381	case TypeTableEntryIdErrorUnion:
...	...	@@ -1518,8 +1518,8 @@ static TypeTableEntry analyze_fn_type(CodeGen g, AstNode proto_node, Scope c
1518	1518	add_node_error(g, param_node->data.param_decl.type,
1519	1519	buf_sprintf("parameter of type '%s' not allowed", buf_ptr(&type_entry->name)));
1520	1520	return g->builtin_types.entry_invalid;
1521		case TypeTableEntryIdNumLitFloat:
1522		case TypeTableEntryIdNumLitInt:
	1521	case TypeTableEntryIdComptimeFloat:
	1522	case TypeTableEntryIdComptimeInt:
1523	1523	case TypeTableEntryIdNamespace:
1524	1524	case TypeTableEntryIdBlock:
1525	1525	case TypeTableEntryIdBoundFn:
...	...	@@ -1607,8 +1607,8 @@ static TypeTableEntry analyze_fn_type(CodeGen g, AstNode proto_node, Scope c
1607	1607	buf_sprintf("return type '%s' not allowed", buf_ptr(&fn_type_id.return_type->name)));
1608	1608	return g->builtin_types.entry_invalid;
1609	1609
1610		case TypeTableEntryIdNumLitFloat:
1611		case TypeTableEntryIdNumLitInt:
	1610	case TypeTableEntryIdComptimeFloat:
	1611	case TypeTableEntryIdComptimeInt:
1612	1612	case TypeTableEntryIdNamespace:
1613	1613	case TypeTableEntryIdBlock:
1614	1614	case TypeTableEntryIdBoundFn:
...	...	@@ -3337,8 +3337,6 @@ TypeTableEntry validate_var_type(CodeGen g, AstNode *source_node, TypeTableEnt
3337	3337	case TypeTableEntryIdInvalid:
3338	3338	return g->builtin_types.entry_invalid;
3339	3339	case TypeTableEntryIdUnreachable:
3340		case TypeTableEntryIdNumLitFloat:
3341		case TypeTableEntryIdNumLitInt:
3342	3340	case TypeTableEntryIdUndefLit:
3343	3341	case TypeTableEntryIdNullLit:
3344	3342	case TypeTableEntryIdBlock:
...	...	@@ -3347,6 +3345,8 @@ TypeTableEntry validate_var_type(CodeGen g, AstNode *source_node, TypeTableEnt
3347	3345	add_node_error(g, source_node, buf_sprintf("variable of type '%s' not allowed",
3348	3346	buf_ptr(&type_entry->name)));
3349	3347	return g->builtin_types.entry_invalid;
	3348	case TypeTableEntryIdComptimeFloat:
	3349	case TypeTableEntryIdComptimeInt:
3350	3350	case TypeTableEntryIdNamespace:
3351	3351	case TypeTableEntryIdMetaType:
3352	3352	case TypeTableEntryIdVoid:
...	...	@@ -3480,8 +3480,8 @@ static void resolve_decl_var(CodeGen g, TldVar tld_var) {
3480	3480	add_node_error(g, source_node, buf_sprintf("variable initialization is unreachable"));
3481	3481	implicit_type = g->builtin_types.entry_invalid;
3482	3482	} else if ((!is_const \|\| linkage == VarLinkageExternal) &&
3483		(implicit_type->id == TypeTableEntryIdNumLitFloat \|\|
3484		implicit_type->id == TypeTableEntryIdNumLitInt))
	3483	(implicit_type->id == TypeTableEntryIdComptimeFloat \|\|
	3484	implicit_type->id == TypeTableEntryIdComptimeInt))
3485	3485	{
3486	3486	add_node_error(g, source_node, buf_sprintf("unable to infer variable type"));
3487	3487	implicit_type = g->builtin_types.entry_invalid;
...	...	@@ -3730,8 +3730,8 @@ static bool is_container(TypeTableEntry *type_entry) {
3730	3730	case TypeTableEntryIdInt:
3731	3731	case TypeTableEntryIdFloat:
3732	3732	case TypeTableEntryIdArray:
3733		case TypeTableEntryIdNumLitFloat:
3734		case TypeTableEntryIdNumLitInt:
	3733	case TypeTableEntryIdComptimeFloat:
	3734	case TypeTableEntryIdComptimeInt:
3735	3735	case TypeTableEntryIdUndefLit:
3736	3736	case TypeTableEntryIdNullLit:
3737	3737	case TypeTableEntryIdMaybe:
...	...	@@ -3779,8 +3779,8 @@ void resolve_container_type(CodeGen g, TypeTableEntry type_entry) {
3779	3779	case TypeTableEntryIdInt:
3780	3780	case TypeTableEntryIdFloat:
3781	3781	case TypeTableEntryIdArray:
3782		case TypeTableEntryIdNumLitFloat:
3783		case TypeTableEntryIdNumLitInt:
	3782	case TypeTableEntryIdComptimeFloat:
	3783	case TypeTableEntryIdComptimeInt:
3784	3784	case TypeTableEntryIdUndefLit:
3785	3785	case TypeTableEntryIdNullLit:
3786	3786	case TypeTableEntryIdMaybe:
...	...	@@ -4283,8 +4283,8 @@ bool handle_is_ptr(TypeTableEntry *type_entry) {
4283	4283	switch (type_entry->id) {
4284	4284	case TypeTableEntryIdInvalid:
4285	4285	case TypeTableEntryIdMetaType:
4286		case TypeTableEntryIdNumLitFloat:
4287		case TypeTableEntryIdNumLitInt:
	4286	case TypeTableEntryIdComptimeFloat:
	4287	case TypeTableEntryIdComptimeInt:
4288	4288	case TypeTableEntryIdUndefLit:
4289	4289	case TypeTableEntryIdNullLit:
4290	4290	case TypeTableEntryIdNamespace:
...	...	@@ -4568,7 +4568,7 @@ static uint32_t hash_const_val(ConstExprValue *const_val) {
4568	4568	case TypeTableEntryIdVoid:
4569	4569	return (uint32_t)4149439618;
4570	4570	case TypeTableEntryIdInt:
4571		case TypeTableEntryIdNumLitInt:
	4571	case TypeTableEntryIdComptimeInt:
4572	4572	{
4573	4573	uint32_t result = 1331471175;
4574	4574	for (size_t i = 0; i < const_val->data.x_bigint.digit_count; i += 1) {
...	...	@@ -4609,7 +4609,7 @@ static uint32_t hash_const_val(ConstExprValue *const_val) {
4609	4609	default:
4610	4610	zig_unreachable();
4611	4611	}
4612		case TypeTableEntryIdNumLitFloat:
	4612	case TypeTableEntryIdComptimeFloat:
4613	4613	{
4614	4614	float128_t f128 = bigfloat_to_f128(&const_val->data.x_bigfloat);
4615	4615	uint32_t ints[4];
...	...	@@ -4754,8 +4754,8 @@ static bool can_mutate_comptime_var_state(ConstExprValue *value) {
4754	4754	case TypeTableEntryIdUnreachable:
4755	4755	case TypeTableEntryIdInt:
4756	4756	case TypeTableEntryIdFloat:
4757		case TypeTableEntryIdNumLitFloat:
4758		case TypeTableEntryIdNumLitInt:
	4757	case TypeTableEntryIdComptimeFloat:
	4758	case TypeTableEntryIdComptimeInt:
4759	4759	case TypeTableEntryIdUndefLit:
4760	4760	case TypeTableEntryIdNullLit:
4761	4761	case TypeTableEntryIdNamespace:
...	...	@@ -4819,8 +4819,8 @@ static bool return_type_is_cacheable(TypeTableEntry *return_type) {
4819	4819	case TypeTableEntryIdUnreachable:
4820	4820	case TypeTableEntryIdInt:
4821	4821	case TypeTableEntryIdFloat:
4822		case TypeTableEntryIdNumLitFloat:
4823		case TypeTableEntryIdNumLitInt:
	4822	case TypeTableEntryIdComptimeFloat:
	4823	case TypeTableEntryIdComptimeInt:
4824	4824	case TypeTableEntryIdUndefLit:
4825	4825	case TypeTableEntryIdNullLit:
4826	4826	case TypeTableEntryIdNamespace:
...	...	@@ -4930,8 +4930,8 @@ bool type_requires_comptime(TypeTableEntry *type_entry) {
4930	4930	case TypeTableEntryIdInvalid:
4931	4931	case TypeTableEntryIdOpaque:
4932	4932	zig_unreachable();
4933		case TypeTableEntryIdNumLitFloat:
4934		case TypeTableEntryIdNumLitInt:
	4933	case TypeTableEntryIdComptimeFloat:
	4934	case TypeTableEntryIdComptimeInt:
4935	4935	case TypeTableEntryIdUndefLit:
4936	4936	case TypeTableEntryIdNullLit:
4937	4937	case TypeTableEntryIdMetaType:
...	...	@@ -5070,7 +5070,7 @@ ConstExprValue create_const_signed(TypeTableEntry type, int64_t x) {
5070	5070	void init_const_float(ConstExprValue const_val, TypeTableEntry type, double value) {
5071	5071	const_val->special = ConstValSpecialStatic;
5072	5072	const_val->type = type;
5073		if (type->id == TypeTableEntryIdNumLitFloat) {
	5073	if (type->id == TypeTableEntryIdComptimeFloat) {
5074	5074	bigfloat_init_64(&const_val->data.x_bigfloat, value);
5075	5075	} else if (type->id == TypeTableEntryIdFloat) {
5076	5076	switch (type->data.floating.bit_count) {
...	...	@@ -5350,10 +5350,10 @@ bool const_values_equal(ConstExprValue a, ConstExprValue b) {
5350	5350	default:
5351	5351	zig_unreachable();
5352	5352	}
5353		case TypeTableEntryIdNumLitFloat:
	5353	case TypeTableEntryIdComptimeFloat:
5354	5354	return bigfloat_cmp(&a->data.x_bigfloat, &b->data.x_bigfloat) == CmpEQ;
5355	5355	case TypeTableEntryIdInt:
5356		case TypeTableEntryIdNumLitInt:
	5356	case TypeTableEntryIdComptimeInt:
5357	5357	return bigint_cmp(&a->data.x_bigint, &b->data.x_bigint) == CmpEQ;
5358	5358	case TypeTableEntryIdPointer:
5359	5359	case TypeTableEntryIdFn:
...	...	@@ -5514,7 +5514,7 @@ void render_const_value(CodeGen g, Buf buf, ConstExprValue *const_val) {
5514	5514	case TypeTableEntryIdVoid:
5515	5515	buf_appendf(buf, "{}");
5516	5516	return;
5517		case TypeTableEntryIdNumLitFloat:
	5517	case TypeTableEntryIdComptimeFloat:
5518	5518	bigfloat_append_buf(buf, &const_val->data.x_bigfloat);
5519	5519	return;
5520	5520	case TypeTableEntryIdFloat:
...	...	@@ -5542,7 +5542,7 @@ void render_const_value(CodeGen g, Buf buf, ConstExprValue *const_val) {
5542	5542	default:
5543	5543	zig_unreachable();
5544	5544	}
5545		case TypeTableEntryIdNumLitInt:
	5545	case TypeTableEntryIdComptimeInt:
5546	5546	case TypeTableEntryIdInt:
5547	5547	bigint_append_buf(buf, &const_val->data.x_bigint, 10);
5548	5548	return;
...	...	@@ -5761,8 +5761,8 @@ uint32_t type_id_hash(TypeId x) {
5761	5761	case TypeTableEntryIdUnreachable:
5762	5762	case TypeTableEntryIdFloat:
5763	5763	case TypeTableEntryIdStruct:
5764		case TypeTableEntryIdNumLitFloat:
5765		case TypeTableEntryIdNumLitInt:
	5764	case TypeTableEntryIdComptimeFloat:
	5765	case TypeTableEntryIdComptimeInt:
5766	5766	case TypeTableEntryIdUndefLit:
5767	5767	case TypeTableEntryIdNullLit:
5768	5768	case TypeTableEntryIdMaybe:
...	...	@@ -5807,8 +5807,8 @@ bool type_id_eql(TypeId a, TypeId b) {
5807	5807	case TypeTableEntryIdUnreachable:
5808	5808	case TypeTableEntryIdFloat:
5809	5809	case TypeTableEntryIdStruct:
5810		case TypeTableEntryIdNumLitFloat:
5811		case TypeTableEntryIdNumLitInt:
	5810	case TypeTableEntryIdComptimeFloat:
	5811	case TypeTableEntryIdComptimeInt:
5812	5812	case TypeTableEntryIdUndefLit:
5813	5813	case TypeTableEntryIdNullLit:
5814	5814	case TypeTableEntryIdMaybe:
...	...	@@ -5929,8 +5929,8 @@ static const TypeTableEntryId all_type_ids[] = {
5929	5929	TypeTableEntryIdPointer,
5930	5930	TypeTableEntryIdArray,
5931	5931	TypeTableEntryIdStruct,
5932		TypeTableEntryIdNumLitFloat,
5933		TypeTableEntryIdNumLitInt,
	5932	TypeTableEntryIdComptimeFloat,
	5933	TypeTableEntryIdComptimeInt,
5934	5934	TypeTableEntryIdUndefLit,
5935	5935	TypeTableEntryIdNullLit,
5936	5936	TypeTableEntryIdMaybe,
...	...	@@ -5980,9 +5980,9 @@ size_t type_id_index(TypeTableEntry *entry) {
5980	5980	if (entry->data.structure.is_slice)
5981	5981	return 25;
5982	5982	return 8;
5983		case TypeTableEntryIdNumLitFloat:
	5983	case TypeTableEntryIdComptimeFloat:
5984	5984	return 9;
5985		case TypeTableEntryIdNumLitInt:
	5985	case TypeTableEntryIdComptimeInt:
5986	5986	return 10;
5987	5987	case TypeTableEntryIdUndefLit:
5988	5988	return 11;
...	...	@@ -6038,10 +6038,10 @@ const char *type_id_name(TypeTableEntryId id) {
6038	6038	return "Array";
6039	6039	case TypeTableEntryIdStruct:
6040	6040	return "Struct";
6041		case TypeTableEntryIdNumLitFloat:
6042		return "FloatLiteral";
6043		case TypeTableEntryIdNumLitInt:
6044		return "IntLiteral";
	6041	case TypeTableEntryIdComptimeFloat:
	6042	return "ComptimeFloat";
	6043	case TypeTableEntryIdComptimeInt:
	6044	return "ComptimeInt";
6045	6045	case TypeTableEntryIdUndefLit:
6046	6046	return "UndefinedLiteral";
6047	6047	case TypeTableEntryIdNullLit:

src/codegen.cpp+20-18

...	...	@@ -4916,8 +4916,8 @@ static LLVMValueRef pack_const_int(CodeGen *g, LLVMTypeRef big_int_type_ref, Con
4916	4916	case TypeTableEntryIdInvalid:
4917	4917	case TypeTableEntryIdMetaType:
4918	4918	case TypeTableEntryIdUnreachable:
4919		case TypeTableEntryIdNumLitFloat:
4920		case TypeTableEntryIdNumLitInt:
	4919	case TypeTableEntryIdComptimeFloat:
	4920	case TypeTableEntryIdComptimeInt:
4921	4921	case TypeTableEntryIdUndefLit:
4922	4922	case TypeTableEntryIdNullLit:
4923	4923	case TypeTableEntryIdErrorUnion:
...	...	@@ -5362,8 +5362,8 @@ static LLVMValueRef gen_const_val(CodeGen g, ConstExprValue const_val, const c
5362	5362	case TypeTableEntryIdInvalid:
5363	5363	case TypeTableEntryIdMetaType:
5364	5364	case TypeTableEntryIdUnreachable:
5365		case TypeTableEntryIdNumLitFloat:
5366		case TypeTableEntryIdNumLitInt:
	5365	case TypeTableEntryIdComptimeFloat:
	5366	case TypeTableEntryIdComptimeInt:
5367	5367	case TypeTableEntryIdUndefLit:
5368	5368	case TypeTableEntryIdNullLit:
5369	5369	case TypeTableEntryIdNamespace:
...	...	@@ -5604,7 +5604,7 @@ static void do_code_gen(CodeGen *g) {
5604	5604	TldVar *tld_var = g->global_vars.at(i);
5605	5605	VariableTableEntry *var = tld_var->var;
5606	5606
5607		if (var->value->type->id == TypeTableEntryIdNumLitFloat) {
	5607	if (var->value->type->id == TypeTableEntryIdComptimeFloat) {
5608	5608	// Generate debug info for it but that's it.
5609	5609	ConstExprValue *const_val = var->value;
5610	5610	assert(const_val->special != ConstValSpecialRuntime);
...	...	@@ -5618,7 +5618,7 @@ static void do_code_gen(CodeGen *g) {
5618	5618	continue;
5619	5619	}
5620	5620
5621		if (var->value->type->id == TypeTableEntryIdNumLitInt) {
	5621	if (var->value->type->id == TypeTableEntryIdComptimeInt) {
5622	5622	// Generate debug info for it but that's it.
5623	5623	ConstExprValue *const_val = var->value;
5624	5624	assert(const_val->special != ConstValSpecialRuntime);
...	...	@@ -6012,16 +6012,18 @@ static void define_builtin_types(CodeGen *g) {
6012	6012	g->builtin_types.entry_block = entry;
6013	6013	}
6014	6014	{
6015		TypeTableEntry *entry = new_type_table_entry(TypeTableEntryIdNumLitFloat);
6016		buf_init_from_str(&entry->name, "(float literal)");
	6015	TypeTableEntry *entry = new_type_table_entry(TypeTableEntryIdComptimeFloat);
	6016	buf_init_from_str(&entry->name, "comptime_float");
6017	6017	entry->zero_bits = true;
6018	6018	g->builtin_types.entry_num_lit_float = entry;
	6019	g->primitive_type_table.put(&entry->name, entry);
6019	6020	}
6020	6021	{
6021		TypeTableEntry *entry = new_type_table_entry(TypeTableEntryIdNumLitInt);
6022		buf_init_from_str(&entry->name, "(integer literal)");
	6022	TypeTableEntry *entry = new_type_table_entry(TypeTableEntryIdComptimeInt);
	6023	buf_init_from_str(&entry->name, "comptime_int");
6023	6024	entry->zero_bits = true;
6024	6025	g->builtin_types.entry_num_lit_int = entry;
	6026	g->primitive_type_table.put(&entry->name, entry);
6025	6027	}
6026	6028	{
6027	6029	TypeTableEntry *entry = new_type_table_entry(TypeTableEntryIdUndefLit);
...	...	@@ -6495,8 +6497,8 @@ static void define_builtin_compile_vars(CodeGen *g) {
6495	6497	" Slice: Slice,\n"
6496	6498	" Array: Array,\n"
6497	6499	" Struct: Struct,\n"
6498		" FloatLiteral: void,\n"
6499		" IntLiteral: void,\n"
	6500	" ComptimeFloat: void,\n"
	6501	" ComptimeInt: void,\n"
6500	6502	" UndefinedLiteral: void,\n"
6501	6503	" NullLiteral: void,\n"
6502	6504	" Nullable: Nullable,\n"
...	...	@@ -7070,8 +7072,8 @@ static void prepend_c_type_to_decl_list(CodeGen g, GenH gen_h, TypeTableEntry
7070	7072	switch (type_entry->id) {
7071	7073	case TypeTableEntryIdInvalid:
7072	7074	case TypeTableEntryIdMetaType:
7073		case TypeTableEntryIdNumLitFloat:
7074		case TypeTableEntryIdNumLitInt:
	7075	case TypeTableEntryIdComptimeFloat:
	7076	case TypeTableEntryIdComptimeInt:
7075	7077	case TypeTableEntryIdUndefLit:
7076	7078	case TypeTableEntryIdNullLit:
7077	7079	case TypeTableEntryIdNamespace:
...	...	@@ -7255,8 +7257,8 @@ static void get_c_type(CodeGen g, GenH gen_h, TypeTableEntry *type_entry, Buf
7255	7257	case TypeTableEntryIdBoundFn:
7256	7258	case TypeTableEntryIdNamespace:
7257	7259	case TypeTableEntryIdBlock:
7258		case TypeTableEntryIdNumLitFloat:
7259		case TypeTableEntryIdNumLitInt:
	7260	case TypeTableEntryIdComptimeFloat:
	7261	case TypeTableEntryIdComptimeInt:
7260	7262	case TypeTableEntryIdUndefLit:
7261	7263	case TypeTableEntryIdNullLit:
7262	7264	case TypeTableEntryIdArgTuple:
...	...	@@ -7407,8 +7409,8 @@ static void gen_h_file(CodeGen *g) {
7407	7409	case TypeTableEntryIdInt:
7408	7410	case TypeTableEntryIdFloat:
7409	7411	case TypeTableEntryIdPointer:
7410		case TypeTableEntryIdNumLitFloat:
7411		case TypeTableEntryIdNumLitInt:
	7412	case TypeTableEntryIdComptimeFloat:
	7413	case TypeTableEntryIdComptimeInt:
7412	7414	case TypeTableEntryIdArray:
7413	7415	case TypeTableEntryIdUndefLit:
7414	7416	case TypeTableEntryIdNullLit:

src/ir.cpp+115-115

...	...	@@ -6945,14 +6945,14 @@ static bool ir_emit_global_runtime_side_effect(IrAnalyze ira, IrInstruction so
6945	6945	}
6946	6946
6947	6947	static bool const_val_fits_in_num_lit(ConstExprValue const_val, TypeTableEntry num_lit_type) {
6948		return ((num_lit_type->id == TypeTableEntryIdNumLitFloat &&
6949		(const_val->type->id == TypeTableEntryIdFloat \|\| const_val->type->id == TypeTableEntryIdNumLitFloat)) \|\|
6950		(num_lit_type->id == TypeTableEntryIdNumLitInt &&
6951		(const_val->type->id == TypeTableEntryIdInt \|\| const_val->type->id == TypeTableEntryIdNumLitInt)));
	6948	return ((num_lit_type->id == TypeTableEntryIdComptimeFloat &&
	6949	(const_val->type->id == TypeTableEntryIdFloat \|\| const_val->type->id == TypeTableEntryIdComptimeFloat)) \|\|
	6950	(num_lit_type->id == TypeTableEntryIdComptimeInt &&
	6951	(const_val->type->id == TypeTableEntryIdInt \|\| const_val->type->id == TypeTableEntryIdComptimeInt)));
6952	6952	}
6953	6953
6954	6954	static bool float_has_fraction(ConstExprValue *const_val) {
6955		if (const_val->type->id == TypeTableEntryIdNumLitFloat) {
	6955	if (const_val->type->id == TypeTableEntryIdComptimeFloat) {
6956	6956	return bigfloat_has_fraction(&const_val->data.x_bigfloat);
6957	6957	} else if (const_val->type->id == TypeTableEntryIdFloat) {
6958	6958	switch (const_val->type->data.floating.bit_count) {
...	...	@@ -6975,7 +6975,7 @@ static bool float_has_fraction(ConstExprValue *const_val) {
6975	6975	}
6976	6976
6977	6977	static void float_append_buf(Buf buf, ConstExprValue const_val) {
6978		if (const_val->type->id == TypeTableEntryIdNumLitFloat) {
	6978	if (const_val->type->id == TypeTableEntryIdComptimeFloat) {
6979	6979	bigfloat_append_buf(buf, &const_val->data.x_bigfloat);
6980	6980	} else if (const_val->type->id == TypeTableEntryIdFloat) {
6981	6981	switch (const_val->type->data.floating.bit_count) {
...	...	@@ -7010,7 +7010,7 @@ static void float_append_buf(Buf buf, ConstExprValue const_val) {
7010	7010	}
7011	7011
7012	7012	static void float_init_bigint(BigInt bigint, ConstExprValue const_val) {
7013		if (const_val->type->id == TypeTableEntryIdNumLitFloat) {
	7013	if (const_val->type->id == TypeTableEntryIdComptimeFloat) {
7014	7014	bigint_init_bigfloat(bigint, &const_val->data.x_bigfloat);
7015	7015	} else if (const_val->type->id == TypeTableEntryIdFloat) {
7016	7016	switch (const_val->type->data.floating.bit_count) {
...	...	@@ -7046,7 +7046,7 @@ static void float_init_bigint(BigInt bigint, ConstExprValue const_val) {
7046	7046	}
7047	7047
7048	7048	static void float_init_bigfloat(ConstExprValue dest_val, BigFloat bigfloat) {
7049		if (dest_val->type->id == TypeTableEntryIdNumLitFloat) {
	7049	if (dest_val->type->id == TypeTableEntryIdComptimeFloat) {
7050	7050	bigfloat_init_bigfloat(&dest_val->data.x_bigfloat, bigfloat);
7051	7051	} else if (dest_val->type->id == TypeTableEntryIdFloat) {
7052	7052	switch (dest_val->type->data.floating.bit_count) {
...	...	@@ -7068,7 +7068,7 @@ static void float_init_bigfloat(ConstExprValue dest_val, BigFloat bigfloat) {
7068	7068	}
7069	7069
7070	7070	static void float_init_f32(ConstExprValue *dest_val, float x) {
7071		if (dest_val->type->id == TypeTableEntryIdNumLitFloat) {
	7071	if (dest_val->type->id == TypeTableEntryIdComptimeFloat) {
7072	7072	bigfloat_init_32(&dest_val->data.x_bigfloat, x);
7073	7073	} else if (dest_val->type->id == TypeTableEntryIdFloat) {
7074	7074	switch (dest_val->type->data.floating.bit_count) {
...	...	@@ -7094,7 +7094,7 @@ static void float_init_f32(ConstExprValue *dest_val, float x) {
7094	7094	}
7095	7095
7096	7096	static void float_init_f64(ConstExprValue *dest_val, double x) {
7097		if (dest_val->type->id == TypeTableEntryIdNumLitFloat) {
	7097	if (dest_val->type->id == TypeTableEntryIdComptimeFloat) {
7098	7098	bigfloat_init_64(&dest_val->data.x_bigfloat, x);
7099	7099	} else if (dest_val->type->id == TypeTableEntryIdFloat) {
7100	7100	switch (dest_val->type->data.floating.bit_count) {
...	...	@@ -7120,7 +7120,7 @@ static void float_init_f64(ConstExprValue *dest_val, double x) {
7120	7120	}
7121	7121
7122	7122	static void float_init_f128(ConstExprValue *dest_val, float128_t x) {
7123		if (dest_val->type->id == TypeTableEntryIdNumLitFloat) {
	7123	if (dest_val->type->id == TypeTableEntryIdComptimeFloat) {
7124	7124	bigfloat_init_128(&dest_val->data.x_bigfloat, x);
7125	7125	} else if (dest_val->type->id == TypeTableEntryIdFloat) {
7126	7126	switch (dest_val->type->data.floating.bit_count) {
...	...	@@ -7150,7 +7150,7 @@ static void float_init_f128(ConstExprValue *dest_val, float128_t x) {
7150	7150	}
7151	7151
7152	7152	static void float_init_float(ConstExprValue dest_val, ConstExprValue src_val) {
7153		if (src_val->type->id == TypeTableEntryIdNumLitFloat) {
	7153	if (src_val->type->id == TypeTableEntryIdComptimeFloat) {
7154	7154	float_init_bigfloat(dest_val, &src_val->data.x_bigfloat);
7155	7155	} else if (src_val->type->id == TypeTableEntryIdFloat) {
7156	7156	switch (src_val->type->data.floating.bit_count) {
...	...	@@ -7173,7 +7173,7 @@ static void float_init_float(ConstExprValue dest_val, ConstExprValue src_val)
7173	7173
7174	7174	static Cmp float_cmp(ConstExprValue op1, ConstExprValue op2) {
7175	7175	assert(op1->type == op2->type);
7176		if (op1->type->id == TypeTableEntryIdNumLitFloat) {
	7176	if (op1->type->id == TypeTableEntryIdComptimeFloat) {
7177	7177	return bigfloat_cmp(&op1->data.x_bigfloat, &op2->data.x_bigfloat);
7178	7178	} else if (op1->type->id == TypeTableEntryIdFloat) {
7179	7179	switch (op1->type->data.floating.bit_count) {
...	...	@@ -7210,7 +7210,7 @@ static Cmp float_cmp(ConstExprValue op1, ConstExprValue op2) {
7210	7210	}
7211	7211
7212	7212	static Cmp float_cmp_zero(ConstExprValue *op) {
7213		if (op->type->id == TypeTableEntryIdNumLitFloat) {
	7213	if (op->type->id == TypeTableEntryIdComptimeFloat) {
7214	7214	return bigfloat_cmp_zero(&op->data.x_bigfloat);
7215	7215	} else if (op->type->id == TypeTableEntryIdFloat) {
7216	7216	switch (op->type->data.floating.bit_count) {
...	...	@@ -7251,7 +7251,7 @@ static Cmp float_cmp_zero(ConstExprValue *op) {
7251	7251	static void float_add(ConstExprValue out_val, ConstExprValue op1, ConstExprValue *op2) {
7252	7252	assert(op1->type == op2->type);
7253	7253	out_val->type = op1->type;
7254		if (op1->type->id == TypeTableEntryIdNumLitFloat) {
	7254	if (op1->type->id == TypeTableEntryIdComptimeFloat) {
7255	7255	bigfloat_add(&out_val->data.x_bigfloat, &op1->data.x_bigfloat, &op2->data.x_bigfloat);
7256	7256	} else if (op1->type->id == TypeTableEntryIdFloat) {
7257	7257	switch (op1->type->data.floating.bit_count) {
...	...	@@ -7275,7 +7275,7 @@ static void float_add(ConstExprValue out_val, ConstExprValue op1, ConstExprVal
7275	7275	static void float_sub(ConstExprValue out_val, ConstExprValue op1, ConstExprValue *op2) {
7276	7276	assert(op1->type == op2->type);
7277	7277	out_val->type = op1->type;
7278		if (op1->type->id == TypeTableEntryIdNumLitFloat) {
	7278	if (op1->type->id == TypeTableEntryIdComptimeFloat) {
7279	7279	bigfloat_sub(&out_val->data.x_bigfloat, &op1->data.x_bigfloat, &op2->data.x_bigfloat);
7280	7280	} else if (op1->type->id == TypeTableEntryIdFloat) {
7281	7281	switch (op1->type->data.floating.bit_count) {
...	...	@@ -7299,7 +7299,7 @@ static void float_sub(ConstExprValue out_val, ConstExprValue op1, ConstExprVal
7299	7299	static void float_mul(ConstExprValue out_val, ConstExprValue op1, ConstExprValue *op2) {
7300	7300	assert(op1->type == op2->type);
7301	7301	out_val->type = op1->type;
7302		if (op1->type->id == TypeTableEntryIdNumLitFloat) {
	7302	if (op1->type->id == TypeTableEntryIdComptimeFloat) {
7303	7303	bigfloat_mul(&out_val->data.x_bigfloat, &op1->data.x_bigfloat, &op2->data.x_bigfloat);
7304	7304	} else if (op1->type->id == TypeTableEntryIdFloat) {
7305	7305	switch (op1->type->data.floating.bit_count) {
...	...	@@ -7323,7 +7323,7 @@ static void float_mul(ConstExprValue out_val, ConstExprValue op1, ConstExprVal
7323	7323	static void float_div(ConstExprValue out_val, ConstExprValue op1, ConstExprValue *op2) {
7324	7324	assert(op1->type == op2->type);
7325	7325	out_val->type = op1->type;
7326		if (op1->type->id == TypeTableEntryIdNumLitFloat) {
	7326	if (op1->type->id == TypeTableEntryIdComptimeFloat) {
7327	7327	bigfloat_div(&out_val->data.x_bigfloat, &op1->data.x_bigfloat, &op2->data.x_bigfloat);
7328	7328	} else if (op1->type->id == TypeTableEntryIdFloat) {
7329	7329	switch (op1->type->data.floating.bit_count) {
...	...	@@ -7347,7 +7347,7 @@ static void float_div(ConstExprValue out_val, ConstExprValue op1, ConstExprVal
7347	7347	static void float_div_trunc(ConstExprValue out_val, ConstExprValue op1, ConstExprValue *op2) {
7348	7348	assert(op1->type == op2->type);
7349	7349	out_val->type = op1->type;
7350		if (op1->type->id == TypeTableEntryIdNumLitFloat) {
	7350	if (op1->type->id == TypeTableEntryIdComptimeFloat) {
7351	7351	bigfloat_div_trunc(&out_val->data.x_bigfloat, &op1->data.x_bigfloat, &op2->data.x_bigfloat);
7352	7352	} else if (op1->type->id == TypeTableEntryIdFloat) {
7353	7353	switch (op1->type->data.floating.bit_count) {
...	...	@@ -7382,7 +7382,7 @@ static void float_div_trunc(ConstExprValue out_val, ConstExprValue op1, ConstE
7382	7382	static void float_div_floor(ConstExprValue out_val, ConstExprValue op1, ConstExprValue *op2) {
7383	7383	assert(op1->type == op2->type);
7384	7384	out_val->type = op1->type;
7385		if (op1->type->id == TypeTableEntryIdNumLitFloat) {
	7385	if (op1->type->id == TypeTableEntryIdComptimeFloat) {
7386	7386	bigfloat_div_floor(&out_val->data.x_bigfloat, &op1->data.x_bigfloat, &op2->data.x_bigfloat);
7387	7387	} else if (op1->type->id == TypeTableEntryIdFloat) {
7388	7388	switch (op1->type->data.floating.bit_count) {
...	...	@@ -7407,7 +7407,7 @@ static void float_div_floor(ConstExprValue out_val, ConstExprValue op1, ConstE
7407	7407	static void float_rem(ConstExprValue out_val, ConstExprValue op1, ConstExprValue *op2) {
7408	7408	assert(op1->type == op2->type);
7409	7409	out_val->type = op1->type;
7410		if (op1->type->id == TypeTableEntryIdNumLitFloat) {
	7410	if (op1->type->id == TypeTableEntryIdComptimeFloat) {
7411	7411	bigfloat_rem(&out_val->data.x_bigfloat, &op1->data.x_bigfloat, &op2->data.x_bigfloat);
7412	7412	} else if (op1->type->id == TypeTableEntryIdFloat) {
7413	7413	switch (op1->type->data.floating.bit_count) {
...	...	@@ -7431,7 +7431,7 @@ static void float_rem(ConstExprValue out_val, ConstExprValue op1, ConstExprVal
7431	7431	static void float_mod(ConstExprValue out_val, ConstExprValue op1, ConstExprValue *op2) {
7432	7432	assert(op1->type == op2->type);
7433	7433	out_val->type = op1->type;
7434		if (op1->type->id == TypeTableEntryIdNumLitFloat) {
	7434	if (op1->type->id == TypeTableEntryIdComptimeFloat) {
7435	7435	bigfloat_mod(&out_val->data.x_bigfloat, &op1->data.x_bigfloat, &op2->data.x_bigfloat);
7436	7436	} else if (op1->type->id == TypeTableEntryIdFloat) {
7437	7437	switch (op1->type->data.floating.bit_count) {
...	...	@@ -7456,7 +7456,7 @@ static void float_mod(ConstExprValue out_val, ConstExprValue op1, ConstExprVal
7456	7456
7457	7457	static void float_negate(ConstExprValue out_val, ConstExprValue op) {
7458	7458	out_val->type = op->type;
7459		if (op->type->id == TypeTableEntryIdNumLitFloat) {
	7459	if (op->type->id == TypeTableEntryIdComptimeFloat) {
7460	7460	bigfloat_negate(&out_val->data.x_bigfloat, &op->data.x_bigfloat);
7461	7461	} else if (op->type->id == TypeTableEntryIdFloat) {
7462	7462	switch (op->type->data.floating.bit_count) {
...	...	@@ -7530,9 +7530,9 @@ static bool ir_num_lit_fits_in_other_type(IrAnalyze ira, IrInstruction instruc
7530	7530	assert(const_val->special != ConstValSpecialRuntime);
7531	7531
7532	7532	bool const_val_is_int = (const_val->type->id == TypeTableEntryIdInt \|\|
7533		const_val->type->id == TypeTableEntryIdNumLitInt);
	7533	const_val->type->id == TypeTableEntryIdComptimeInt);
7534	7534	bool const_val_is_float = (const_val->type->id == TypeTableEntryIdFloat \|\|
7535		const_val->type->id == TypeTableEntryIdNumLitFloat);
	7535	const_val->type->id == TypeTableEntryIdComptimeFloat);
7536	7536	if (other_type->id == TypeTableEntryIdFloat) {
7537	7537	return true;
7538	7538	} else if (other_type->id == TypeTableEntryIdInt && const_val_is_int) {
...	...	@@ -7576,7 +7576,7 @@ static bool ir_num_lit_fits_in_other_type(IrAnalyze ira, IrInstruction instruc
7576	7576	return true;
7577	7577	}
7578	7578	}
7579		if (explicit_cast && (other_type->id == TypeTableEntryIdInt \|\| other_type->id == TypeTableEntryIdNumLitInt) &&
	7579	if (explicit_cast && (other_type->id == TypeTableEntryIdInt \|\| other_type->id == TypeTableEntryIdComptimeInt) &&
7580	7580	const_val_is_float)
7581	7581	{
7582	7582	if (float_has_fraction(const_val)) {
...	...	@@ -7589,7 +7589,7 @@ static bool ir_num_lit_fits_in_other_type(IrAnalyze ira, IrInstruction instruc
7589	7589	buf_ptr(&other_type->name)));
7590	7590	return false;
7591	7591	} else {
7592		if (other_type->id == TypeTableEntryIdNumLitInt) {
	7592	if (other_type->id == TypeTableEntryIdComptimeInt) {
7593	7593	return true;
7594	7594	} else {
7595	7595	BigInt bigint;
...	...	@@ -8078,8 +8078,8 @@ static ImplicitCastMatchResult ir_types_match_with_implicit_cast(IrAnalyze *ira,
8078	8078
8079	8079	// implicit number literal to typed number
8080	8080	// implicit number literal to &const integer
8081		if (actual_type->id == TypeTableEntryIdNumLitFloat \|\|
8082		actual_type->id == TypeTableEntryIdNumLitInt)
	8081	if (actual_type->id == TypeTableEntryIdComptimeFloat \|\|
	8082	actual_type->id == TypeTableEntryIdComptimeInt)
8083	8083	{
8084	8084	if (expected_type->id == TypeTableEntryIdPointer &&
8085	8085	expected_type->data.pointer.is_const)
...	...	@@ -8099,9 +8099,9 @@ static ImplicitCastMatchResult ir_types_match_with_implicit_cast(IrAnalyze *ira,
8099	8099	// implicit typed number to integer or float literal.
8100	8100	// works when the number is known
8101	8101	if (value->value.special == ConstValSpecialStatic) {
8102		if (actual_type->id == TypeTableEntryIdInt && expected_type->id == TypeTableEntryIdNumLitInt) {
	8102	if (actual_type->id == TypeTableEntryIdInt && expected_type->id == TypeTableEntryIdComptimeInt) {
8103	8103	return ImplicitCastMatchResultYes;
8104		} else if (actual_type->id == TypeTableEntryIdFloat && expected_type->id == TypeTableEntryIdNumLitFloat) {
	8104	} else if (actual_type->id == TypeTableEntryIdFloat && expected_type->id == TypeTableEntryIdComptimeFloat) {
8105	8105	return ImplicitCastMatchResultYes;
8106	8106	}
8107	8107	}
...	...	@@ -8555,8 +8555,8 @@ static TypeTableEntry ir_resolve_peer_types(IrAnalyze ira, AstNode *source_nod
8555	8555	continue;
8556	8556	}
8557	8557
8558		if (prev_type->id == TypeTableEntryIdNumLitInt \|\|
8559		prev_type->id == TypeTableEntryIdNumLitFloat)
	8558	if (prev_type->id == TypeTableEntryIdComptimeInt \|\|
	8559	prev_type->id == TypeTableEntryIdComptimeFloat)
8560	8560	{
8561	8561	if (ir_num_lit_fits_in_other_type(ira, prev_inst, cur_type, false)) {
8562	8562	prev_inst = cur_inst;
...	...	@@ -8566,8 +8566,8 @@ static TypeTableEntry ir_resolve_peer_types(IrAnalyze ira, AstNode *source_nod
8566	8566	}
8567	8567	}
8568	8568
8569		if (cur_type->id == TypeTableEntryIdNumLitInt \|\|
8570		cur_type->id == TypeTableEntryIdNumLitFloat)
	8569	if (cur_type->id == TypeTableEntryIdComptimeInt \|\|
	8570	cur_type->id == TypeTableEntryIdComptimeFloat)
8571	8571	{
8572	8572	if (ir_num_lit_fits_in_other_type(ira, cur_inst, prev_type, false)) {
8573	8573	continue;
...	...	@@ -8671,8 +8671,8 @@ static TypeTableEntry ir_resolve_peer_types(IrAnalyze ira, AstNode *source_nod
8671	8671	} else if (expected_type != nullptr && expected_type->id == TypeTableEntryIdErrorUnion) {
8672	8672	return get_error_union_type(ira->codegen, err_set_type, expected_type->data.error_union.payload_type);
8673	8673	} else {
8674		if (prev_inst->value.type->id == TypeTableEntryIdNumLitInt \|\|
8675		prev_inst->value.type->id == TypeTableEntryIdNumLitFloat)
	8674	if (prev_inst->value.type->id == TypeTableEntryIdComptimeInt \|\|
	8675	prev_inst->value.type->id == TypeTableEntryIdComptimeFloat)
8676	8676	{
8677	8677	ir_add_error_node(ira, source_node,
8678	8678	buf_sprintf("unable to make error union out of number literal"));
...	...	@@ -8686,8 +8686,8 @@ static TypeTableEntry ir_resolve_peer_types(IrAnalyze ira, AstNode *source_nod
8686	8686	}
8687	8687	}
8688	8688	} else if (any_are_null && prev_inst->value.type->id != TypeTableEntryIdNullLit) {
8689		if (prev_inst->value.type->id == TypeTableEntryIdNumLitInt \|\|
8690		prev_inst->value.type->id == TypeTableEntryIdNumLitFloat)
	8689	if (prev_inst->value.type->id == TypeTableEntryIdComptimeInt \|\|
	8690	prev_inst->value.type->id == TypeTableEntryIdComptimeFloat)
8691	8691	{
8692	8692	ir_add_error_node(ira, source_node,
8693	8693	buf_sprintf("unable to make maybe out of number literal"));
...	...	@@ -8743,7 +8743,7 @@ static void eval_const_expr_implicit_cast(CastOp cast_op,
8743	8743	break;
8744	8744	}
8745	8745	case CastOpNumLitToConcrete:
8746		if (other_val->type->id == TypeTableEntryIdNumLitFloat) {
	8746	if (other_val->type->id == TypeTableEntryIdComptimeFloat) {
8747	8747	assert(new_type->id == TypeTableEntryIdFloat);
8748	8748	switch (new_type->data.floating.bit_count) {
8749	8749	case 32:
...	...	@@ -8758,7 +8758,7 @@ static void eval_const_expr_implicit_cast(CastOp cast_op,
8758	8758	default:
8759	8759	zig_unreachable();
8760	8760	}
8761		} else if (other_val->type->id == TypeTableEntryIdNumLitInt) {
	8761	} else if (other_val->type->id == TypeTableEntryIdComptimeInt) {
8762	8762	bigint_init_bigint(&const_val->data.x_bigint, &other_val->data.x_bigint);
8763	8763	} else {
8764	8764	zig_unreachable();
...	...	@@ -9601,9 +9601,9 @@ static IrInstruction ir_analyze_number_to_literal(IrAnalyze ira, IrInstruction
9601	9601
9602	9602	IrInstruction *result = ir_create_const(&ira->new_irb, source_instr->scope,
9603	9603	source_instr->source_node, wanted_type);
9604		if (wanted_type->id == TypeTableEntryIdNumLitFloat) {
	9604	if (wanted_type->id == TypeTableEntryIdComptimeFloat) {
9605	9605	float_init_float(&result->value, val);
9606		} else if (wanted_type->id == TypeTableEntryIdNumLitInt) {
	9606	} else if (wanted_type->id == TypeTableEntryIdComptimeInt) {
9607	9607	bigint_init_bigint(&result->value.data.x_bigint, &val->data.x_bigint);
9608	9608	} else {
9609	9609	zig_unreachable();
...	...	@@ -9978,8 +9978,8 @@ static IrInstruction ir_analyze_cast(IrAnalyze ira, IrInstruction *source_inst
9978	9978	TypeTableEntry *wanted_child_type = wanted_type->data.maybe.child_type;
9979	9979	if (types_match_const_cast_only(ira, wanted_child_type, actual_type, source_node).id == ConstCastResultIdOk) {
9980	9980	return ir_analyze_maybe_wrap(ira, source_instr, value, wanted_type);
9981		} else if (actual_type->id == TypeTableEntryIdNumLitInt \|\|
9982		actual_type->id == TypeTableEntryIdNumLitFloat)
	9981	} else if (actual_type->id == TypeTableEntryIdComptimeInt \|\|
	9982	actual_type->id == TypeTableEntryIdComptimeFloat)
9983	9983	{
9984	9984	if (ir_num_lit_fits_in_other_type(ira, value, wanted_child_type, true)) {
9985	9985	return ir_analyze_maybe_wrap(ira, source_instr, value, wanted_type);
...	...	@@ -10013,8 +10013,8 @@ static IrInstruction ir_analyze_cast(IrAnalyze ira, IrInstruction *source_inst
10013	10013	if (wanted_type->id == TypeTableEntryIdErrorUnion) {
10014	10014	if (types_match_const_cast_only(ira, wanted_type->data.error_union.payload_type, actual_type, source_node).id == ConstCastResultIdOk) {
10015	10015	return ir_analyze_err_wrap_payload(ira, source_instr, value, wanted_type);
10016		} else if (actual_type->id == TypeTableEntryIdNumLitInt \|\|
10017		actual_type->id == TypeTableEntryIdNumLitFloat)
	10016	} else if (actual_type->id == TypeTableEntryIdComptimeInt \|\|
	10017	actual_type->id == TypeTableEntryIdComptimeFloat)
10018	10018	{
10019	10019	if (ir_num_lit_fits_in_other_type(ira, value, wanted_type->data.error_union.payload_type, true)) {
10020	10020	return ir_analyze_err_wrap_payload(ira, source_instr, value, wanted_type);
...	...	@@ -10062,8 +10062,8 @@ static IrInstruction ir_analyze_cast(IrAnalyze ira, IrInstruction *source_inst
10062	10062	TypeTableEntry *wanted_child_type = wanted_type->data.error_union.payload_type->data.maybe.child_type;
10063	10063	if (types_match_const_cast_only(ira, wanted_child_type, actual_type, source_node).id == ConstCastResultIdOk \|\|
10064	10064	actual_type->id == TypeTableEntryIdNullLit \|\|
10065		actual_type->id == TypeTableEntryIdNumLitInt \|\|
10066		actual_type->id == TypeTableEntryIdNumLitFloat)
	10065	actual_type->id == TypeTableEntryIdComptimeInt \|\|
	10066	actual_type->id == TypeTableEntryIdComptimeFloat)
10067	10067	{
10068	10068	IrInstruction *cast1 = ir_analyze_cast(ira, source_instr, wanted_type->data.error_union.payload_type, value);
10069	10069	if (type_is_invalid(cast1->value.type))
...	...	@@ -10079,8 +10079,8 @@ static IrInstruction ir_analyze_cast(IrAnalyze ira, IrInstruction *source_inst
10079	10079
10080	10080	// explicit cast from number literal to another type
10081	10081	// explicit cast from number literal to &const integer
10082		if (actual_type->id == TypeTableEntryIdNumLitFloat \|\|
10083		actual_type->id == TypeTableEntryIdNumLitInt)
	10082	if (actual_type->id == TypeTableEntryIdComptimeFloat \|\|
	10083	actual_type->id == TypeTableEntryIdComptimeInt)
10084	10084	{
10085	10085	ensure_complete_type(ira->codegen, wanted_type);
10086	10086	if (type_is_invalid(wanted_type))
...	...	@@ -10109,9 +10109,9 @@ static IrInstruction ir_analyze_cast(IrAnalyze ira, IrInstruction *source_inst
10109	10109	return cast2;
10110	10110	} else if (ir_num_lit_fits_in_other_type(ira, value, wanted_type, true)) {
10111	10111	CastOp op;
10112		if ((actual_type->id == TypeTableEntryIdNumLitFloat &&
	10112	if ((actual_type->id == TypeTableEntryIdComptimeFloat &&
10113	10113	wanted_type->id == TypeTableEntryIdFloat) \|\|
10114		(actual_type->id == TypeTableEntryIdNumLitInt &&
	10114	(actual_type->id == TypeTableEntryIdComptimeInt &&
10115	10115	wanted_type->id == TypeTableEntryIdInt))
10116	10116	{
10117	10117	op = CastOpNumLitToConcrete;
...	...	@@ -10131,8 +10131,8 @@ static IrInstruction ir_analyze_cast(IrAnalyze ira, IrInstruction *source_inst
10131	10131	// explicit cast from typed number to integer or float literal.
10132	10132	// works when the number is known at compile time
10133	10133	if (instr_is_comptime(value) &&
10134		((actual_type->id == TypeTableEntryIdInt && wanted_type->id == TypeTableEntryIdNumLitInt) \|\|
10135		(actual_type->id == TypeTableEntryIdFloat && wanted_type->id == TypeTableEntryIdNumLitFloat)))
	10134	((actual_type->id == TypeTableEntryIdInt && wanted_type->id == TypeTableEntryIdComptimeInt) \|\|
	10135	(actual_type->id == TypeTableEntryIdFloat && wanted_type->id == TypeTableEntryIdComptimeFloat)))
10136	10136	{
10137	10137	return ir_analyze_number_to_literal(ira, source_instr, value, wanted_type);
10138	10138	}
...	...	@@ -10759,8 +10759,8 @@ static TypeTableEntry ir_analyze_bin_op_cmp(IrAnalyze ira, IrInstructionBinOp
10759	10759	case TypeTableEntryIdInvalid:
10760	10760	zig_unreachable(); // handled above
10761	10761
10762		case TypeTableEntryIdNumLitFloat:
10763		case TypeTableEntryIdNumLitInt:
	10762	case TypeTableEntryIdComptimeFloat:
	10763	case TypeTableEntryIdComptimeInt:
10764	10764	case TypeTableEntryIdInt:
10765	10765	case TypeTableEntryIdFloat:
10766	10766	break;
...	...	@@ -10818,10 +10818,10 @@ static TypeTableEntry ir_analyze_bin_op_cmp(IrAnalyze ira, IrInstructionBinOp
10818	10818	bool one_possible_value = !type_requires_comptime(resolved_type) && !type_has_bits(resolved_type);
10819	10819	if (one_possible_value \|\| (value_is_comptime(op1_val) && value_is_comptime(op2_val))) {
10820	10820	bool answer;
10821		if (resolved_type->id == TypeTableEntryIdNumLitFloat \|\| resolved_type->id == TypeTableEntryIdFloat) {
	10821	if (resolved_type->id == TypeTableEntryIdComptimeFloat \|\| resolved_type->id == TypeTableEntryIdFloat) {
10822	10822	Cmp cmp_result = float_cmp(op1_val, op2_val);
10823	10823	answer = resolve_cmp_op_id(op_id, cmp_result);
10824		} else if (resolved_type->id == TypeTableEntryIdNumLitInt \|\| resolved_type->id == TypeTableEntryIdInt) {
	10824	} else if (resolved_type->id == TypeTableEntryIdComptimeInt \|\| resolved_type->id == TypeTableEntryIdInt) {
10825	10825	Cmp cmp_result = bigint_cmp(&op1_val->data.x_bigint, &op2_val->data.x_bigint);
10826	10826	answer = resolve_cmp_op_id(op_id, cmp_result);
10827	10827	} else {
...	...	@@ -10885,12 +10885,12 @@ static int ir_eval_math_op(TypeTableEntry type_entry, ConstExprValue op1_val,
10885	10885	bool is_int;
10886	10886	bool is_float;
10887	10887	Cmp op2_zcmp;
10888		if (type_entry->id == TypeTableEntryIdInt \|\| type_entry->id == TypeTableEntryIdNumLitInt) {
	10888	if (type_entry->id == TypeTableEntryIdInt \|\| type_entry->id == TypeTableEntryIdComptimeInt) {
10889	10889	is_int = true;
10890	10890	is_float = false;
10891	10891	op2_zcmp = bigint_cmp_zero(&op2_val->data.x_bigint);
10892	10892	} else if (type_entry->id == TypeTableEntryIdFloat \|\|
10893		type_entry->id == TypeTableEntryIdNumLitFloat)
	10893	type_entry->id == TypeTableEntryIdComptimeFloat)
10894	10894	{
10895	10895	is_int = false;
10896	10896	is_float = true;
...	...	@@ -11064,7 +11064,7 @@ static TypeTableEntry ir_analyze_bit_shift(IrAnalyze ira, IrInstructionBinOp *
11064	11064	if (type_is_invalid(op1->value.type))
11065	11065	return ira->codegen->builtin_types.entry_invalid;
11066	11066
11067		if (op1->value.type->id != TypeTableEntryIdInt && op1->value.type->id != TypeTableEntryIdNumLitInt) {
	11067	if (op1->value.type->id != TypeTableEntryIdInt && op1->value.type->id != TypeTableEntryIdComptimeInt) {
11068	11068	ir_add_error(ira, &bin_op_instruction->base,
11069	11069	buf_sprintf("bit shifting operation expected integer type, found '%s'",
11070	11070	buf_ptr(&op1->value.type->name)));
...	...	@@ -11077,7 +11077,7 @@ static TypeTableEntry ir_analyze_bit_shift(IrAnalyze ira, IrInstructionBinOp *
11077	11077
11078	11078	IrInstruction *casted_op2;
11079	11079	IrBinOp op_id = bin_op_instruction->op_id;
11080		if (op1->value.type->id == TypeTableEntryIdNumLitInt) {
	11080	if (op1->value.type->id == TypeTableEntryIdComptimeInt) {
11081	11081	casted_op2 = op2;
11082	11082
11083	11083	if (op_id == IrBinOpBitShiftLeftLossy) {
...	...	@@ -11122,7 +11122,7 @@ static TypeTableEntry ir_analyze_bit_shift(IrAnalyze ira, IrInstructionBinOp *
11122	11122
11123	11123	ir_num_lit_fits_in_other_type(ira, result_instruction, op1->value.type, false);
11124	11124	return op1->value.type;
11125		} else if (op1->value.type->id == TypeTableEntryIdNumLitInt) {
	11125	} else if (op1->value.type->id == TypeTableEntryIdComptimeInt) {
11126	11126	ir_add_error(ira, &bin_op_instruction->base,
11127	11127	buf_sprintf("LHS of shift must be an integer type, or RHS must be compile-time known"));
11128	11128	return ira->codegen->builtin_types.entry_invalid;
...	...	@@ -11158,15 +11158,15 @@ static TypeTableEntry ir_analyze_bin_op_math(IrAnalyze ira, IrInstructionBinOp
11158	11158	if (type_is_invalid(resolved_type))
11159	11159	return resolved_type;
11160	11160
11161		bool is_int = resolved_type->id == TypeTableEntryIdInt \|\| resolved_type->id == TypeTableEntryIdNumLitInt;
11162		bool is_float = resolved_type->id == TypeTableEntryIdFloat \|\| resolved_type->id == TypeTableEntryIdNumLitFloat;
	11161	bool is_int = resolved_type->id == TypeTableEntryIdInt \|\| resolved_type->id == TypeTableEntryIdComptimeInt;
	11162	bool is_float = resolved_type->id == TypeTableEntryIdFloat \|\| resolved_type->id == TypeTableEntryIdComptimeFloat;
11163	11163	bool is_signed_div = (
11164	11164	(resolved_type->id == TypeTableEntryIdInt && resolved_type->data.integral.is_signed) \|\|
11165	11165	resolved_type->id == TypeTableEntryIdFloat \|\|
11166		(resolved_type->id == TypeTableEntryIdNumLitFloat &&
	11166	(resolved_type->id == TypeTableEntryIdComptimeFloat &&
11167	11167	((bigfloat_cmp_zero(&op1->value.data.x_bigfloat) != CmpGT) !=
11168	11168	(bigfloat_cmp_zero(&op2->value.data.x_bigfloat) != CmpGT))) \|\|
11169		(resolved_type->id == TypeTableEntryIdNumLitInt &&
	11169	(resolved_type->id == TypeTableEntryIdComptimeInt &&
11170	11170	((bigint_cmp_zero(&op1->value.data.x_bigint) != CmpGT) !=
11171	11171	(bigint_cmp_zero(&op2->value.data.x_bigint) != CmpGT)))
11172	11172	);
...	...	@@ -11267,7 +11267,7 @@ static TypeTableEntry ir_analyze_bin_op_math(IrAnalyze ira, IrInstructionBinOp
11267	11267	return ira->codegen->builtin_types.entry_invalid;
11268	11268	}
11269	11269
11270		if (resolved_type->id == TypeTableEntryIdNumLitInt) {
	11270	if (resolved_type->id == TypeTableEntryIdComptimeInt) {
11271	11271	if (op_id == IrBinOpAddWrap) {
11272	11272	op_id = IrBinOpAdd;
11273	11273	} else if (op_id == IrBinOpSubWrap) {
...	...	@@ -11641,8 +11641,8 @@ static VarClassRequired get_var_class_required(TypeTableEntry *type_entry) {
11641	11641	case TypeTableEntryIdFn:
11642	11642	case TypeTableEntryIdPromise:
11643	11643	return VarClassRequiredAny;
11644		case TypeTableEntryIdNumLitFloat:
11645		case TypeTableEntryIdNumLitInt:
	11644	case TypeTableEntryIdComptimeFloat:
	11645	case TypeTableEntryIdComptimeInt:
11646	11646	case TypeTableEntryIdUndefLit:
11647	11647	case TypeTableEntryIdBlock:
11648	11648	case TypeTableEntryIdNullLit:
...	...	@@ -11910,8 +11910,8 @@ static TypeTableEntry ir_analyze_instruction_export(IrAnalyze ira, IrInstructi
11910	11910	case TypeTableEntryIdMetaType:
11911	11911	case TypeTableEntryIdVoid:
11912	11912	case TypeTableEntryIdUnreachable:
11913		case TypeTableEntryIdNumLitFloat:
11914		case TypeTableEntryIdNumLitInt:
	11913	case TypeTableEntryIdComptimeFloat:
	11914	case TypeTableEntryIdComptimeInt:
11915	11915	case TypeTableEntryIdUndefLit:
11916	11916	case TypeTableEntryIdNullLit:
11917	11917	case TypeTableEntryIdMaybe:
...	...	@@ -11934,8 +11934,8 @@ static TypeTableEntry ir_analyze_instruction_export(IrAnalyze ira, IrInstructi
11934	11934	case TypeTableEntryIdFloat:
11935	11935	case TypeTableEntryIdPointer:
11936	11936	case TypeTableEntryIdArray:
11937		case TypeTableEntryIdNumLitFloat:
11938		case TypeTableEntryIdNumLitInt:
	11937	case TypeTableEntryIdComptimeFloat:
	11938	case TypeTableEntryIdComptimeInt:
11939	11939	case TypeTableEntryIdUndefLit:
11940	11940	case TypeTableEntryIdNullLit:
11941	11941	case TypeTableEntryIdMaybe:
...	...	@@ -12149,7 +12149,7 @@ static bool ir_analyze_fn_call_generic_arg(IrAnalyze ira, AstNode fn_proto_nod
12149	12149	}
12150	12150
12151	12151	bool comptime_arg = param_decl_node->data.param_decl.is_inline \|\|
12152		casted_arg->value.type->id == TypeTableEntryIdNumLitInt \|\| casted_arg->value.type->id == TypeTableEntryIdNumLitFloat;
	12152	casted_arg->value.type->id == TypeTableEntryIdComptimeInt \|\| casted_arg->value.type->id == TypeTableEntryIdComptimeFloat;
12153	12153
12154	12154	ConstExprValue *arg_val;
12155	12155
...	...	@@ -12174,8 +12174,8 @@ static bool ir_analyze_fn_call_generic_arg(IrAnalyze ira, AstNode fn_proto_nod
12174	12174	var->shadowable = !comptime_arg;
12175	12175
12176	12176	*next_proto_i += 1;
12177		} else if (casted_arg->value.type->id == TypeTableEntryIdNumLitInt \|\|
12178		casted_arg->value.type->id == TypeTableEntryIdNumLitFloat)
	12177	} else if (casted_arg->value.type->id == TypeTableEntryIdComptimeInt \|\|
	12178	casted_arg->value.type->id == TypeTableEntryIdComptimeFloat)
12179	12179	{
12180	12180	ir_add_error(ira, casted_arg,
12181	12181	buf_sprintf("compiler bug: integer and float literals in var args function must be casted. https://github.com/ziglang/zig/issues/557"));
...	...	@@ -12898,8 +12898,8 @@ static TypeTableEntry ir_analyze_maybe(IrAnalyze ira, IrInstructionUnOp *un_op
12898	12898	case TypeTableEntryIdPointer:
12899	12899	case TypeTableEntryIdArray:
12900	12900	case TypeTableEntryIdStruct:
12901		case TypeTableEntryIdNumLitFloat:
12902		case TypeTableEntryIdNumLitInt:
	12901	case TypeTableEntryIdComptimeFloat:
	12902	case TypeTableEntryIdComptimeInt:
12903	12903	case TypeTableEntryIdUndefLit:
12904	12904	case TypeTableEntryIdNullLit:
12905	12905	case TypeTableEntryIdMaybe:
...	...	@@ -12935,10 +12935,10 @@ static TypeTableEntry ir_analyze_negation(IrAnalyze ira, IrInstructionUnOp *un
12935	12935
12936	12936	bool is_wrap_op = (un_op_instruction->op_id == IrUnOpNegationWrap);
12937	12937
12938		bool is_float = (expr_type->id == TypeTableEntryIdFloat \|\| expr_type->id == TypeTableEntryIdNumLitFloat);
	12938	bool is_float = (expr_type->id == TypeTableEntryIdFloat \|\| expr_type->id == TypeTableEntryIdComptimeFloat);
12939	12939
12940	12940	if ((expr_type->id == TypeTableEntryIdInt && expr_type->data.integral.is_signed) \|\|
12941		expr_type->id == TypeTableEntryIdNumLitInt \|\| (is_float && !is_wrap_op))
	12941	expr_type->id == TypeTableEntryIdComptimeInt \|\| (is_float && !is_wrap_op))
12942	12942	{
12943	12943	if (instr_is_comptime(value)) {
12944	12944	ConstExprValue *target_const_val = ir_resolve_const(ira, value, UndefBad);
...	...	@@ -12954,7 +12954,7 @@ static TypeTableEntry ir_analyze_negation(IrAnalyze ira, IrInstructionUnOp *un
12954	12954	} else {
12955	12955	bigint_negate(&out_val->data.x_bigint, &target_const_val->data.x_bigint);
12956	12956	}
12957		if (is_wrap_op \|\| is_float \|\| expr_type->id == TypeTableEntryIdNumLitInt) {
	12957	if (is_wrap_op \|\| is_float \|\| expr_type->id == TypeTableEntryIdComptimeInt) {
12958	12958	return expr_type;
12959	12959	}
12960	12960
...	...	@@ -13150,8 +13150,8 @@ static TypeTableEntry ir_analyze_instruction_phi(IrAnalyze ira, IrInstructionP
13150	13150	if (type_is_invalid(resolved_type))
13151	13151	return resolved_type;
13152	13152
13153		if (resolved_type->id == TypeTableEntryIdNumLitFloat \|\|
13154		resolved_type->id == TypeTableEntryIdNumLitInt \|\|
	13153	if (resolved_type->id == TypeTableEntryIdComptimeFloat \|\|
	13154	resolved_type->id == TypeTableEntryIdComptimeInt \|\|
13155	13155	resolved_type->id == TypeTableEntryIdNullLit \|\|
13156	13156	resolved_type->id == TypeTableEntryIdUndefLit)
13157	13157	{
...	...	@@ -14213,8 +14213,8 @@ static TypeTableEntry ir_analyze_instruction_typeof(IrAnalyze ira, IrInstructi
14213	14213	switch (type_entry->id) {
14214	14214	case TypeTableEntryIdInvalid:
14215	14215	zig_unreachable(); // handled above
14216		case TypeTableEntryIdNumLitFloat:
14217		case TypeTableEntryIdNumLitInt:
	14216	case TypeTableEntryIdComptimeFloat:
	14217	case TypeTableEntryIdComptimeInt:
14218	14218	case TypeTableEntryIdUndefLit:
14219	14219	case TypeTableEntryIdNullLit:
14220	14220	case TypeTableEntryIdNamespace:
...	...	@@ -14495,8 +14495,8 @@ static TypeTableEntry ir_analyze_instruction_slice_type(IrAnalyze ira,
14495	14495	case TypeTableEntryIdPointer:
14496	14496	case TypeTableEntryIdArray:
14497	14497	case TypeTableEntryIdStruct:
14498		case TypeTableEntryIdNumLitFloat:
14499		case TypeTableEntryIdNumLitInt:
	14498	case TypeTableEntryIdComptimeFloat:
	14499	case TypeTableEntryIdComptimeInt:
14500	14500	case TypeTableEntryIdMaybe:
14501	14501	case TypeTableEntryIdErrorUnion:
14502	14502	case TypeTableEntryIdErrorSet:
...	...	@@ -14603,8 +14603,8 @@ static TypeTableEntry ir_analyze_instruction_array_type(IrAnalyze ira,
14603	14603	case TypeTableEntryIdPointer:
14604	14604	case TypeTableEntryIdArray:
14605	14605	case TypeTableEntryIdStruct:
14606		case TypeTableEntryIdNumLitFloat:
14607		case TypeTableEntryIdNumLitInt:
	14606	case TypeTableEntryIdComptimeFloat:
	14607	case TypeTableEntryIdComptimeInt:
14608	14608	case TypeTableEntryIdMaybe:
14609	14609	case TypeTableEntryIdErrorUnion:
14610	14610	case TypeTableEntryIdErrorSet:
...	...	@@ -14659,8 +14659,8 @@ static TypeTableEntry ir_analyze_instruction_size_of(IrAnalyze ira,
14659	14659	case TypeTableEntryIdUndefLit:
14660	14660	case TypeTableEntryIdNullLit:
14661	14661	case TypeTableEntryIdBlock:
14662		case TypeTableEntryIdNumLitFloat:
14663		case TypeTableEntryIdNumLitInt:
	14662	case TypeTableEntryIdComptimeFloat:
	14663	case TypeTableEntryIdComptimeInt:
14664	14664	case TypeTableEntryIdBoundFn:
14665	14665	case TypeTableEntryIdMetaType:
14666	14666	case TypeTableEntryIdNamespace:
...	...	@@ -15020,8 +15020,8 @@ static TypeTableEntry ir_analyze_instruction_switch_target(IrAnalyze ira,
15020	15020	case TypeTableEntryIdBool:
15021	15021	case TypeTableEntryIdInt:
15022	15022	case TypeTableEntryIdFloat:
15023		case TypeTableEntryIdNumLitFloat:
15024		case TypeTableEntryIdNumLitInt:
	15023	case TypeTableEntryIdComptimeFloat:
	15024	case TypeTableEntryIdComptimeInt:
15025	15025	case TypeTableEntryIdPointer:
15026	15026	case TypeTableEntryIdPromise:
15027	15027	case TypeTableEntryIdFn:
...	...	@@ -15618,8 +15618,8 @@ static TypeTableEntry ir_analyze_min_max(IrAnalyze ira, IrInstruction *source_
15618	15618	case TypeTableEntryIdPromise:
15619	15619	case TypeTableEntryIdArray:
15620	15620	case TypeTableEntryIdStruct:
15621		case TypeTableEntryIdNumLitFloat:
15622		case TypeTableEntryIdNumLitInt:
	15621	case TypeTableEntryIdComptimeFloat:
	15622	case TypeTableEntryIdComptimeInt:
15623	15623	case TypeTableEntryIdUndefLit:
15624	15624	case TypeTableEntryIdNullLit:
15625	15625	case TypeTableEntryIdMaybe:
...	...	@@ -16280,8 +16280,8 @@ static ConstExprValue ir_make_type_info_value(IrAnalyze ira, TypeTableEntry *t
16280	16280	case TypeTableEntryIdVoid:
16281	16281	case TypeTableEntryIdBool:
16282	16282	case TypeTableEntryIdUnreachable:
16283		case TypeTableEntryIdNumLitFloat:
16284		case TypeTableEntryIdNumLitInt:
	16283	case TypeTableEntryIdComptimeFloat:
	16284	case TypeTableEntryIdComptimeInt:
16285	16285	case TypeTableEntryIdUndefLit:
16286	16286	case TypeTableEntryIdNullLit:
16287	16287	case TypeTableEntryIdNamespace:
...	...	@@ -17143,7 +17143,7 @@ static TypeTableEntry ir_analyze_instruction_truncate(IrAnalyze ira, IrInstruc
17143	17143	return ira->codegen->builtin_types.entry_invalid;
17144	17144
17145	17145	if (dest_type->id != TypeTableEntryIdInt &&
17146		dest_type->id != TypeTableEntryIdNumLitInt)
	17146	dest_type->id != TypeTableEntryIdComptimeInt)
17147	17147	{
17148	17148	ir_add_error(ira, dest_type_value, buf_sprintf("expected integer type, found '%s'", buf_ptr(&dest_type->name)));
17149	17149	return ira->codegen->builtin_types.entry_invalid;
...	...	@@ -17155,7 +17155,7 @@ static TypeTableEntry ir_analyze_instruction_truncate(IrAnalyze ira, IrInstruc
17155	17155	return ira->codegen->builtin_types.entry_invalid;
17156	17156
17157	17157	if (src_type->id != TypeTableEntryIdInt &&
17158		src_type->id != TypeTableEntryIdNumLitInt)
	17158	src_type->id != TypeTableEntryIdComptimeInt)
17159	17159	{
17160	17160	ir_add_error(ira, target, buf_sprintf("expected integer type, found '%s'", buf_ptr(&src_type->name)));
17161	17161	return ira->codegen->builtin_types.entry_invalid;
...	...	@@ -17876,8 +17876,8 @@ static TypeTableEntry ir_analyze_instruction_align_of(IrAnalyze ira, IrInstruc
17876	17876	zig_unreachable();
17877	17877	case TypeTableEntryIdMetaType:
17878	17878	case TypeTableEntryIdUnreachable:
17879		case TypeTableEntryIdNumLitFloat:
17880		case TypeTableEntryIdNumLitInt:
	17879	case TypeTableEntryIdComptimeFloat:
	17880	case TypeTableEntryIdComptimeInt:
17881	17881	case TypeTableEntryIdUndefLit:
17882	17882	case TypeTableEntryIdNullLit:
17883	17883	case TypeTableEntryIdNamespace:
...	...	@@ -18377,8 +18377,8 @@ static TypeTableEntry ir_analyze_instruction_check_switch_prongs(IrAnalyze ira
18377	18377	if (!end_val)
18378	18378	return ira->codegen->builtin_types.entry_invalid;
18379	18379
18380		assert(start_val->type->id == TypeTableEntryIdInt \|\| start_val->type->id == TypeTableEntryIdNumLitInt);
18381		assert(end_val->type->id == TypeTableEntryIdInt \|\| end_val->type->id == TypeTableEntryIdNumLitInt);
	18380	assert(start_val->type->id == TypeTableEntryIdInt \|\| start_val->type->id == TypeTableEntryIdComptimeInt);
	18381	assert(end_val->type->id == TypeTableEntryIdInt \|\| end_val->type->id == TypeTableEntryIdComptimeInt);
18382	18382	AstNode *prev_node = rangeset_add_range(&rs, &start_val->data.x_bigint, &end_val->data.x_bigint,
18383	18383	start_value->source_node);
18384	18384	if (prev_node != nullptr) {
...	...	@@ -18610,8 +18610,8 @@ static void buf_write_value_bytes(CodeGen codegen, uint8_t buf, ConstExprValue
18610	18610	case TypeTableEntryIdNamespace:
18611	18611	case TypeTableEntryIdBlock:
18612	18612	case TypeTableEntryIdUnreachable:
18613		case TypeTableEntryIdNumLitFloat:
18614		case TypeTableEntryIdNumLitInt:
	18613	case TypeTableEntryIdComptimeFloat:
	18614	case TypeTableEntryIdComptimeInt:
18615	18615	case TypeTableEntryIdUndefLit:
18616	18616	case TypeTableEntryIdNullLit:
18617	18617	case TypeTableEntryIdPromise:
...	...	@@ -18677,8 +18677,8 @@ static void buf_read_value_bytes(CodeGen codegen, uint8_t buf, ConstExprValue
18677	18677	case TypeTableEntryIdNamespace:
18678	18678	case TypeTableEntryIdBlock:
18679	18679	case TypeTableEntryIdUnreachable:
18680		case TypeTableEntryIdNumLitFloat:
18681		case TypeTableEntryIdNumLitInt:
	18680	case TypeTableEntryIdComptimeFloat:
	18681	case TypeTableEntryIdComptimeInt:
18682	18682	case TypeTableEntryIdUndefLit:
18683	18683	case TypeTableEntryIdNullLit:
18684	18684	case TypeTableEntryIdPromise:
...	...	@@ -18758,8 +18758,8 @@ static TypeTableEntry ir_analyze_instruction_bit_cast(IrAnalyze ira, IrInstruc
18758	18758	case TypeTableEntryIdNamespace:
18759	18759	case TypeTableEntryIdBlock:
18760	18760	case TypeTableEntryIdUnreachable:
18761		case TypeTableEntryIdNumLitFloat:
18762		case TypeTableEntryIdNumLitInt:
	18761	case TypeTableEntryIdComptimeFloat:
	18762	case TypeTableEntryIdComptimeInt:
18763	18763	case TypeTableEntryIdUndefLit:
18764	18764	case TypeTableEntryIdNullLit:
18765	18765	ir_add_error(ira, dest_type_value,
...	...	@@ -18784,8 +18784,8 @@ static TypeTableEntry ir_analyze_instruction_bit_cast(IrAnalyze ira, IrInstruc
18784	18784	case TypeTableEntryIdNamespace:
18785	18785	case TypeTableEntryIdBlock:
18786	18786	case TypeTableEntryIdUnreachable:
18787		case TypeTableEntryIdNumLitFloat:
18788		case TypeTableEntryIdNumLitInt:
	18787	case TypeTableEntryIdComptimeFloat:
	18788	case TypeTableEntryIdComptimeInt:
18789	18789	case TypeTableEntryIdUndefLit:
18790	18790	case TypeTableEntryIdNullLit:
18791	18791	ir_add_error(ira, dest_type_value,
...	...	@@ -19560,7 +19560,7 @@ static TypeTableEntry ir_analyze_instruction_sqrt(IrAnalyze ira, IrInstruction
19560	19560	if (type_is_invalid(op->value.type))
19561	19561	return ira->codegen->builtin_types.entry_invalid;
19562	19562
19563		bool ok_type = float_type->id == TypeTableEntryIdNumLitFloat \|\| float_type->id == TypeTableEntryIdFloat;
	19563	bool ok_type = float_type->id == TypeTableEntryIdComptimeFloat \|\| float_type->id == TypeTableEntryIdFloat;
19564	19564	if (!ok_type) {
19565	19565	ir_add_error(ira, instruction->type, buf_sprintf("@sqrt does not support type '%s'", buf_ptr(&float_type->name)));
19566	19566	return ira->codegen->builtin_types.entry_invalid;
...	...	@@ -19577,7 +19577,7 @@ static TypeTableEntry ir_analyze_instruction_sqrt(IrAnalyze ira, IrInstruction
19577	19577
19578	19578	ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
19579	19579
19580		if (float_type->id == TypeTableEntryIdNumLitFloat) {
	19580	if (float_type->id == TypeTableEntryIdComptimeFloat) {
19581	19581	bigfloat_sqrt(&out_val->data.x_bigfloat, &val->data.x_bigfloat);
19582	19582	} else if (float_type->id == TypeTableEntryIdFloat) {
19583	19583	switch (float_type->data.floating.bit_count) {

std/math/ln.zig+2-2

...	...	@@ -14,7 +14,7 @@ const TypeId = builtin.TypeId;
14	14	pub fn ln(x: var) @typeOf(x) {
15	15	const T = @typeOf(x);
16	16	switch (@typeId(T)) {
17		TypeId.FloatLiteral => {
	17	TypeId.ComptimeFloat => {
18	18	return @typeOf(1.0)(ln_64(x));
19	19	},
20	20	TypeId.Float => {
...	...	@@ -24,7 +24,7 @@ pub fn ln(x: var) @typeOf(x) {
24	24	else => @compileError("ln not implemented for " ++ @typeName(T)),
25	25	};
26	26	},
27		TypeId.IntLiteral => {
	27	TypeId.ComptimeInt => {
28	28	return @typeOf(1)(math.floor(ln_64(f64(x))));
29	29	},
30	30	TypeId.Int => {

std/math/log.zig+3-3

...	...	@@ -9,15 +9,15 @@ pub fn log(comptime T: type, base: T, x: T) T {
9	9	return math.log2(x);
10	10	} else if (base == 10) {
11	11	return math.log10(x);
12		} else if ((@typeId(T) == TypeId.Float or @typeId(T) == TypeId.FloatLiteral) and base == math.e) {
	12	} else if ((@typeId(T) == TypeId.Float or @typeId(T) == TypeId.ComptimeFloat) and base == math.e) {
13	13	return math.ln(x);
14	14	}
15	15
16	16	switch (@typeId(T)) {
17		TypeId.FloatLiteral => {
	17	TypeId.ComptimeFloat => {
18	18	return @typeOf(1.0)(math.ln(f64(x)) / math.ln(f64(base)));
19	19	},
20		TypeId.IntLiteral => {
	20	TypeId.ComptimeInt => {
21	21	return @typeOf(1)(math.floor(math.ln(f64(x)) / math.ln(f64(base))));
22	22	},
23	23	builtin.TypeId.Int => {

std/math/log10.zig+2-2

...	...	@@ -14,7 +14,7 @@ const TypeId = builtin.TypeId;
14	14	pub fn log10(x: var) @typeOf(x) {
15	15	const T = @typeOf(x);
16	16	switch (@typeId(T)) {
17		TypeId.FloatLiteral => {
	17	TypeId.ComptimeFloat => {
18	18	return @typeOf(1.0)(log10_64(x));
19	19	},
20	20	TypeId.Float => {
...	...	@@ -24,7 +24,7 @@ pub fn log10(x: var) @typeOf(x) {
24	24	else => @compileError("log10 not implemented for " ++ @typeName(T)),
25	25	};
26	26	},
27		TypeId.IntLiteral => {
	27	TypeId.ComptimeInt => {
28	28	return @typeOf(1)(math.floor(log10_64(f64(x))));
29	29	},
30	30	TypeId.Int => {

std/math/log2.zig+2-2

...	...	@@ -14,7 +14,7 @@ const TypeId = builtin.TypeId;
14	14	pub fn log2(x: var) @typeOf(x) {
15	15	const T = @typeOf(x);
16	16	switch (@typeId(T)) {
17		TypeId.FloatLiteral => {
	17	TypeId.ComptimeFloat => {
18	18	return @typeOf(1.0)(log2_64(x));
19	19	},
20	20	TypeId.Float => {
...	...	@@ -24,7 +24,7 @@ pub fn log2(x: var) @typeOf(x) {
24	24	else => @compileError("log2 not implemented for " ++ @typeName(T)),
25	25	};
26	26	},
27		TypeId.IntLiteral => comptime {
	27	TypeId.ComptimeInt => comptime {
28	28	var result = 0;
29	29	var x_shifted = x;
30	30	while (b: {

std/math/sqrt.zig+2-2

...	...	@@ -14,9 +14,9 @@ const TypeId = builtin.TypeId;
14	14	pub fn sqrt(x: var) (if (@typeId(@typeOf(x)) == TypeId.Int) @IntType(false, @typeOf(x).bit_count / 2) else @typeOf(x)) {
15	15	const T = @typeOf(x);
16	16	switch (@typeId(T)) {
17		TypeId.FloatLiteral => return T(@sqrt(f64, x)), // TODO upgrade to f128
	17	TypeId.ComptimeFloat => return T(@sqrt(f64, x)), // TODO upgrade to f128
18	18	TypeId.Float => return @sqrt(T, x),
19		TypeId.IntLiteral => comptime {
	19	TypeId.ComptimeInt => comptime {
20	20	if (x > @maxValue(u128)) {
21	21	@compileError("sqrt not implemented for comptime_int greater than 128 bits");
22	22	}

test/cases/math.zig+18-6

...	...	@@ -329,14 +329,14 @@ fn testShrExact(x: u8) void {
329	329	assert(shifted == 0b00101101);
330	330	}
331	331
332		test "big number addition" {
	332	test "comptime_int addition" {
333	333	comptime {
334	334	assert(35361831660712422535336160538497375248 + 101752735581729509668353361206450473702 == 137114567242441932203689521744947848950);
335	335	assert(594491908217841670578297176641415611445982232488944558774612 + 390603545391089362063884922208143568023166603618446395589768 == 985095453608931032642182098849559179469148836107390954364380);
336	336	}
337	337	}
338	338
339		test "big number multiplication" {
	339	test "comptime_int multiplication" {
340	340	comptime {
341	341	assert(
342	342	45960427431263824329884196484953148229 * 128339149605334697009938835852565949723 == 5898522172026096622534201617172456926982464453350084962781392314016180490567,
...	...	@@ -347,13 +347,13 @@ test "big number multiplication" {
347	347	}
348	348	}
349	349
350		test "big number shifting" {
	350	test "comptime_int shifting" {
351	351	comptime {
352	352	assert((u128(1) << 127) == 0x80000000000000000000000000000000);
353	353	}
354	354	}
355	355
356		test "big number multi-limb shift and mask" {
	356	test "comptime_int multi-limb shift and mask" {
357	357	comptime {
358	358	var a = 0xefffffffa0000001eeeeeeefaaaaaaab;
359	359
...	...	@@ -370,7 +370,7 @@ test "big number multi-limb shift and mask" {
370	370	}
371	371	}
372	372
373		test "big number multi-limb partial shift right" {
	373	test "comptime_int multi-limb partial shift right" {
374	374	comptime {
375	375	var a = 0x1ffffffffeeeeeeee;
376	376	a >>= 16;
...	...	@@ -391,7 +391,7 @@ fn test_xor() void {
391	391	assert(0xFF ^ 0xFF == 0x00);
392	392	}
393	393
394		test "big number xor" {
	394	test "comptime_int xor" {
395	395	comptime {
396	396	assert(0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF ^ 0x00000000000000000000000000000000 == 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
397	397	assert(0xFFFFFFFFFFFFFFFF0000000000000000 ^ 0x0000000000000000FFFFFFFFFFFFFFFF == 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
...	...	@@ -449,3 +449,15 @@ test "@sqrt" {
449	449	fn testSqrt(comptime T: type, x: T) void {
450	450	assert(@sqrt(T, x * x) == x);
451	451	}
	452
	453	test "comptime_int param and return" {
	454	const a = comptimeAdd(35361831660712422535336160538497375248, 101752735581729509668353361206450473702);
	455	assert(a == 137114567242441932203689521744947848950);
	456
	457	const b = comptimeAdd(594491908217841670578297176641415611445982232488944558774612, 390603545391089362063884922208143568023166603618446395589768);
	458	assert(b == 985095453608931032642182098849559179469148836107390954364380);
	459	}
	460
	461	fn comptimeAdd(comptime a: comptime_int, comptime b: comptime_int) comptime_int {
	462	return a + b;
	463	}

test/cases/misc.zig+2-2

...	...	@@ -501,8 +501,8 @@ test "@typeId" {
501	501	assert(@typeId(*f32) == Tid.Pointer);
502	502	assert(@typeId([2]u8) == Tid.Array);
503	503	assert(@typeId(AStruct) == Tid.Struct);
504		assert(@typeId(@typeOf(1)) == Tid.IntLiteral);
505		assert(@typeId(@typeOf(1.0)) == Tid.FloatLiteral);
	504	assert(@typeId(@typeOf(1)) == Tid.ComptimeInt);
	505	assert(@typeId(@typeOf(1.0)) == Tid.ComptimeFloat);
506	506	assert(@typeId(@typeOf(undefined)) == Tid.UndefinedLiteral);
507	507	assert(@typeId(@typeOf(null)) == Tid.NullLiteral);
508	508	assert(@typeId(?i32) == Tid.Nullable);

test/compile_errors.zig+6-6

...	...	@@ -1539,7 +1539,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
1539	1539	\\fn foo() *const i32 { return y; }
1540	1540	\\export fn entry() usize { return @sizeOf(@typeOf(foo)); }
1541	1541	,
1542		".tmp_source.zig:3:30: error: expected type 'const i32', found 'const (integer literal)'",
	1542	".tmp_source.zig:3:30: error: expected type 'const i32', found 'const comptime_int'",
1543	1543	);
1544	1544
1545	1545	cases.add(
...	...	@@ -1555,7 +1555,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
1555	1555	\\const x = 2 == 2.0;
1556	1556	\\export fn entry() usize { return @sizeOf(@typeOf(x)); }
1557	1557	,
1558		".tmp_source.zig:1:11: error: integer value 2 cannot be implicitly casted to type '(float literal)'",
	1558	".tmp_source.zig:1:11: error: integer value 2 cannot be implicitly casted to type 'comptime_float'",
1559	1559	);
1560	1560
1561	1561	cases.add(
...	...	@@ -2189,7 +2189,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
2189	2189	\\
2190	2190	\\export fn entry() usize { return @sizeOf(@typeOf(block_aligned_stuff)); }
2191	2191	,
2192		".tmp_source.zig:3:60: error: unable to perform binary not operation on type '(integer literal)'",
	2192	".tmp_source.zig:3:60: error: unable to perform binary not operation on type 'comptime_int'",
2193	2193	);
2194	2194
2195	2195	cases.addCase(x: {
...	...	@@ -3269,10 +3269,10 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
3269	3269	\\ fn bar(self: *const Foo) void {}
3270	3270	\\};
3271	3271	,
3272		".tmp_source.zig:4:4: error: variable of type '*(integer literal)' must be const or comptime",
	3272	".tmp_source.zig:4:4: error: variable of type '*comptime_int' must be const or comptime",
3273	3273	".tmp_source.zig:7:4: error: variable of type '(undefined)' must be const or comptime",
3274		".tmp_source.zig:8:4: error: variable of type '(integer literal)' must be const or comptime",
3275		".tmp_source.zig:9:4: error: variable of type '(float literal)' must be const or comptime",
	3274	".tmp_source.zig:8:4: error: variable of type 'comptime_int' must be const or comptime",
	3275	".tmp_source.zig:9:4: error: variable of type 'comptime_float' must be const or comptime",
3276	3276	".tmp_source.zig:10:4: error: variable of type '(block)' must be const or comptime",
3277	3277	".tmp_source.zig:11:4: error: variable of type '(null)' must be const or comptime",
3278	3278	".tmp_source.zig:12:4: error: variable of type 'Opaque' must be const or comptime",