Commit 01bd5c46e177ae59f72197063c374e845eea3ff3 | zig

author	Jimmi Holst Christensen <jhc@dismail.de> 2018-06-30 17:35:06+02:00
committer	Jimmi Holst Christensen <jhc@dismail.de> 2018-06-30 17:35:06+02:00
log	01bd5c46e177ae59f72197063c374e845eea3ff3
tree	9829dd206b9062b28994edc6581fda926acfe03c
parent	616fe798c801baa5fa7238f5fc576a5090938999

Revert "ir_resolve_const now checks recursivly for undef values"

This reverts commit 4c3f27ce1ea17b5236a022971ebace73a02b7c2b.

4 files changed, 2 insertions(+), 160 deletions(-)

src
test
- compile_errors.zig

src/analyze.cpp-135

...	@@ -5288,141 +5288,6 @@ ConstExprValue create_const_arg_tuple(CodeGen g, size_t arg_index_start, size_	...	@@ -5288,141 +5288,6 @@ ConstExprValue create_const_arg_tuple(CodeGen g, size_t arg_index_start, size_
5288	return const_val;	5288	return const_val;
5289	}	5289	}
5290		5290
5291	bool contains_comptime_undefined_value(ConstExprValue *value) {
5292	assert(value->special != ConstValSpecialRuntime);
5293	if (value->special == ConstValSpecialUndef)
5294	return true;
5295
5296	switch (value->type->id) {
5297	case TypeTableEntryIdInvalid:
5298	zig_unreachable();
5299
5300	case TypeTableEntryIdPointer: {
5301	ConstPtrValue *ptr = &value->data.x_ptr;
5302	if (ptr->mut == ConstPtrMutRuntimeVar)
5303	return false;
5304
5305	switch (ptr->special) {
5306	case ConstPtrSpecialInvalid:
5307	zig_unreachable();
5308	case ConstPtrSpecialRef:
5309	return contains_comptime_undefined_value(ptr->data.ref.pointee);
5310	case ConstPtrSpecialBaseArray: {
5311	size_t index = ptr->data.base_array.elem_index;
5312	ConstExprValue *arr = ptr->data.base_array.array_val;
5313	if (arr->special == ConstValSpecialUndef)
5314	return true;
5315	if (arr->data.x_array.special == ConstArraySpecialUndef)
5316	return true;
5317
5318	return contains_comptime_undefined_value(&arr->data.x_array.s_none.elements[index]);
5319	}
5320	case ConstPtrSpecialBaseStruct: {
5321	size_t index = ptr->data.base_struct.field_index;
5322	ConstExprValue *str = ptr->data.base_struct.struct_val;
5323	if (str->special == ConstValSpecialUndef)
5324	return true;
5325
5326	return contains_comptime_undefined_value(&str->data.x_struct.fields[index]);
5327	}
5328	case ConstPtrSpecialFunction: // TODO: Can a fn ptr have an undefined value?
5329	case ConstPtrSpecialDiscard:
5330	case ConstPtrSpecialHardCodedAddr:
5331	return false;
5332	}
5333	}
5334	case TypeTableEntryIdArray: {
5335	ConstArrayValue *arr = &value->data.x_array;
5336	if (arr->special == ConstArraySpecialUndef)
5337	return true;
5338
5339	for (size_t i = 0; i < value->type->data.array.len; ++i) {
5340	if (contains_comptime_undefined_value(&arr->s_none.elements[i]))
5341	return true;
5342	}
5343	return false;
5344	}
5345	case TypeTableEntryIdStruct: {
5346	ConstStructValue *str = &value->data.x_struct;
5347	if (value->type->data.structure.is_slice) {
5348	ConstExprValue *len = &str->fields[slice_len_index];
5349	ConstExprValue *ptr = &str->fields[slice_ptr_index];
5350	if (len->special == ConstValSpecialUndef)
5351	return true;
5352	if (ptr->special == ConstValSpecialUndef)
5353	return true;
5354
5355	switch (ptr->data.x_ptr.special) {
5356	case ConstPtrSpecialRef:
5357	return contains_comptime_undefined_value(ptr->data.x_ptr.data.ref.pointee);
5358	case ConstPtrSpecialBaseArray: {
5359	size_t offset = ptr->data.x_ptr.data.base_array.elem_index;
5360	ConstExprValue *arr = ptr->data.x_ptr.data.base_array.array_val;
5361	if (arr->special == ConstValSpecialUndef)
5362	return true;
5363	if (arr->data.x_array.special == ConstArraySpecialUndef)
5364	return true;
5365
5366	uint64_t slice_len = bigint_as_unsigned(&len->data.x_bigint);
5367	for (size_t i = 0; i < slice_len; ++i) {
5368	if (contains_comptime_undefined_value(&arr->data.x_array.s_none.elements[i + offset]))
5369	return true;
5370	}
5371
5372	return false;
5373	}
5374	case ConstPtrSpecialBaseStruct:
5375	case ConstPtrSpecialInvalid:
5376	case ConstPtrSpecialFunction:
5377	case ConstPtrSpecialDiscard:
5378	case ConstPtrSpecialHardCodedAddr:
5379	zig_unreachable();
5380	}
5381	}
5382
5383	for (size_t i = 0; i < value->type->data.structure.src_field_count; ++i) {
5384	if (contains_comptime_undefined_value(&str->fields[i]))
5385	return true;
5386	}
5387	return false;
5388	}
5389	case TypeTableEntryIdOptional:
5390	if (value->data.x_optional == nullptr)
5391	return false;
5392
5393	return contains_comptime_undefined_value(value->data.x_optional);
5394	case TypeTableEntryIdErrorUnion:
5395	// TODO: Can error union error be undefined?
5396	if (value->data.x_err_union.err != nullptr)
5397	return false;
5398
5399	return contains_comptime_undefined_value(value->data.x_err_union.payload);
5400	case TypeTableEntryIdUnion:
5401	return contains_comptime_undefined_value(value->data.x_union.payload);
5402
5403	case TypeTableEntryIdArgTuple:
5404	case TypeTableEntryIdVoid:
5405	case TypeTableEntryIdBool:
5406	case TypeTableEntryIdUnreachable:
5407	case TypeTableEntryIdInt:
5408	case TypeTableEntryIdFloat:
5409	case TypeTableEntryIdComptimeFloat:
5410	case TypeTableEntryIdComptimeInt:
5411	case TypeTableEntryIdUndefined:
5412	case TypeTableEntryIdNull:
5413	case TypeTableEntryIdErrorSet:
5414	case TypeTableEntryIdEnum:
5415	case TypeTableEntryIdFn:
5416	case TypeTableEntryIdNamespace:
5417	case TypeTableEntryIdBlock:
5418	case TypeTableEntryIdBoundFn:
5419	case TypeTableEntryIdMetaType:
5420	case TypeTableEntryIdOpaque:
5421	case TypeTableEntryIdPromise:
5422	return false;
5423	}
5424	zig_unreachable();
5425	}
5426		5291
5427	void init_const_undefined(CodeGen g, ConstExprValue const_val) {	5292	void init_const_undefined(CodeGen g, ConstExprValue const_val) {
5428	TypeTableEntry *wanted_type = const_val->type;	5293	TypeTableEntry *wanted_type = const_val->type;

src/analyze.hpp-1

...	@@ -93,7 +93,6 @@ void ensure_complete_type(CodeGen g, TypeTableEntry type_entry);	...	@@ -93,7 +93,6 @@ void ensure_complete_type(CodeGen g, TypeTableEntry type_entry);
93	void type_ensure_zero_bits_known(CodeGen g, TypeTableEntry type_entry);	93	void type_ensure_zero_bits_known(CodeGen g, TypeTableEntry type_entry);
94	void complete_enum(CodeGen g, TypeTableEntry enum_type);	94	void complete_enum(CodeGen g, TypeTableEntry enum_type);
95	bool ir_get_var_is_comptime(VariableTableEntry *var);	95	bool ir_get_var_is_comptime(VariableTableEntry *var);
96	bool contains_comptime_undefined_value(ConstExprValue *value);
97	bool const_values_equal(ConstExprValue a, ConstExprValue b);	96	bool const_values_equal(ConstExprValue a, ConstExprValue b);
98	void eval_min_max_value(CodeGen g, TypeTableEntry type_entry, ConstExprValue *const_val, bool is_max);	97	void eval_min_max_value(CodeGen g, TypeTableEntry type_entry, ConstExprValue *const_val, bool is_max);
99	void eval_min_max_value_int(CodeGen g, TypeTableEntry int_type, BigInt *bigint, bool is_max);	98	void eval_min_max_value_int(CodeGen g, TypeTableEntry int_type, BigInt *bigint, bool is_max);

src/ir.cpp+2-9

 @@ -9148,15 +9148,8 @@ enum UndefAllowed {
 static ConstExprValue *ir_resolve_const(IrAnalyze *ira, IrInstruction *value, UndefAllowed undef_allowed) {
     switch (value->value.special) {
-        case ConstValSpecialStatic: {
+        case ConstValSpecialStatic:
-            ConstExprValue *res = &value->value;
+            return &value->value;
-            if (undef_allowed == UndefBad && contains_comptime_undefined_value(res)) {
-                ir_add_error(ira, value, buf_sprintf("use of undefined value"));
-                return nullptr;
-            }
-            return res;
-        }
         case ConstValSpecialRuntime:
             ir_add_error(ira, value, buf_sprintf("unable to evaluate constant expression"));
             return nullptr;

test/compile_errors.zig-15

...	@@ -4124,19 +4124,4 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {	...	@@ -4124,19 +4124,4 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
4124	,	4124	,
4125	".tmp_source.zig:3:36: error: @ArgType could not resolve the type of arg 0 because 'fn(var)var' is generic",	4125	".tmp_source.zig:3:36: error: @ArgType could not resolve the type of arg 0 because 'fn(var)var' is generic",
4126	);	4126	);
4127
4128	cases.add(
4129	"Trying to pass undefined array to function taking comptime array by value",
4130	\\fn a(comptime b: [2]u8) u8 { return b[0]; }
4131	\\
4132	\\test "" {
4133	\\ const arr: [2]u8 = undefined;
4134	\\ _ = a(arr);
4135	\\}
4136	,
4137	".tmp_source.zig:5:11: error: use of undefined value",
4138	);
4139
4140
4141
4142	}	4127	}