From 3ec38b249446d1a51391e263fbb8303af52e6751 Mon Sep 17 00:00:00 2001 From: Jimmi HC Date: Thu, 28 Jun 2018 10:34:37 +0200 Subject: Implement const_values_equal for array type * This allows arrays to be passed by value at comptime --- src/analyze.cpp | 15 +++++++++++++-- 1 file changed, 13 insertions(+), 2 deletions(-) (limited to 'src/analyze.cpp') diff --git a/src/analyze.cpp b/src/analyze.cpp index 5160a19e81..e9b74a9c26 100644 --- a/src/analyze.cpp +++ b/src/analyze.cpp @@ -5458,8 +5458,19 @@ bool const_values_equal(ConstExprValue *a, ConstExprValue *b) { case TypeTableEntryIdPointer: case TypeTableEntryIdFn: return const_values_equal_ptr(a, b); - case TypeTableEntryIdArray: - zig_panic("TODO"); + case TypeTableEntryIdArray: { + assert(a->type->data.array.len == b->type->data.array.len); + size_t len = a->type->data.array.len; + ConstExprValue *a_elems = a->data.x_array.s_none.elements; + ConstExprValue *b_elems = b->data.x_array.s_none.elements; + + for (size_t i = 0; i < len; ++i) { + if (!const_values_equal(&a_elems[i], &b_elems[i])) + return false; + } + + return true; + } case TypeTableEntryIdStruct: for (size_t i = 0; i < a->type->data.structure.src_field_count; i += 1) { ConstExprValue *field_a = &a->data.x_struct.fields[i]; -- cgit v1.2.3 From b1128b18d5395d85f1c483d8b35e33c57be80722 Mon Sep 17 00:00:00 2001 From: Jimmi HC Date: Fri, 29 Jun 2018 08:41:16 +0200 Subject: Assert that array is not ConstArraySpecialUndef in const_values_equal --- src/analyze.cpp | 3 +++ 1 file changed, 3 insertions(+) (limited to 'src/analyze.cpp') diff --git a/src/analyze.cpp b/src/analyze.cpp index e9b74a9c26..b3a302a1d4 100644 --- a/src/analyze.cpp +++ b/src/analyze.cpp @@ -5460,6 +5460,9 @@ bool const_values_equal(ConstExprValue *a, ConstExprValue *b) { return const_values_equal_ptr(a, b); case TypeTableEntryIdArray: { assert(a->type->data.array.len == b->type->data.array.len); + assert(a->data.x_array.special != ConstArraySpecialUndef); + assert(b->data.x_array.special != ConstArraySpecialUndef); + size_t len = a->type->data.array.len; ConstExprValue *a_elems = a->data.x_array.s_none.elements; ConstExprValue *b_elems = b->data.x_array.s_none.elements; -- cgit v1.2.3 From 4c3f27ce1ea17b5236a022971ebace73a02b7c2b Mon Sep 17 00:00:00 2001 From: Jimmi HC Date: Fri, 29 Jun 2018 10:21:43 +0200 Subject: ir_resolve_const now checks recursivly for undef values --- src/analyze.cpp | 135 ++++++++++++++++++++++++++++++++++++++++++++++++ src/analyze.hpp | 1 + src/ir.cpp | 11 +++- test/compile_errors.zig | 15 ++++++ 4 files changed, 160 insertions(+), 2 deletions(-) (limited to 'src/analyze.cpp') diff --git a/src/analyze.cpp b/src/analyze.cpp index b3a302a1d4..068ea48c0a 100644 --- a/src/analyze.cpp +++ b/src/analyze.cpp @@ -5288,6 +5288,141 @@ ConstExprValue *create_const_arg_tuple(CodeGen *g, size_t arg_index_start, size_ return const_val; } +bool contains_comptime_undefined_value(ConstExprValue *value) { + assert(value->special != ConstValSpecialRuntime); + if (value->special == ConstValSpecialUndef) + return true; + + switch (value->type->id) { + case TypeTableEntryIdInvalid: + zig_unreachable(); + + case TypeTableEntryIdPointer: { + ConstPtrValue *ptr = &value->data.x_ptr; + if (ptr->mut == ConstPtrMutRuntimeVar) + return false; + + switch (ptr->special) { + case ConstPtrSpecialInvalid: + zig_unreachable(); + case ConstPtrSpecialRef: + return contains_comptime_undefined_value(ptr->data.ref.pointee); + case ConstPtrSpecialBaseArray: { + size_t index = ptr->data.base_array.elem_index; + ConstExprValue *arr = ptr->data.base_array.array_val; + if (arr->special == ConstValSpecialUndef) + return true; + if (arr->data.x_array.special == ConstArraySpecialUndef) + return true; + + return contains_comptime_undefined_value(&arr->data.x_array.s_none.elements[index]); + } + case ConstPtrSpecialBaseStruct: { + size_t index = ptr->data.base_struct.field_index; + ConstExprValue *str = ptr->data.base_struct.struct_val; + if (str->special == ConstValSpecialUndef) + return true; + + return contains_comptime_undefined_value(&str->data.x_struct.fields[index]); + } + case ConstPtrSpecialFunction: // TODO: Can a fn ptr have an undefined value? + case ConstPtrSpecialDiscard: + case ConstPtrSpecialHardCodedAddr: + return false; + } + } + case TypeTableEntryIdArray: { + ConstArrayValue *arr = &value->data.x_array; + if (arr->special == ConstArraySpecialUndef) + return true; + + for (size_t i = 0; i < value->type->data.array.len; ++i) { + if (contains_comptime_undefined_value(&arr->s_none.elements[i])) + return true; + } + return false; + } + case TypeTableEntryIdStruct: { + ConstStructValue *str = &value->data.x_struct; + if (value->type->data.structure.is_slice) { + ConstExprValue *len = &str->fields[slice_len_index]; + ConstExprValue *ptr = &str->fields[slice_ptr_index]; + if (len->special == ConstValSpecialUndef) + return true; + if (ptr->special == ConstValSpecialUndef) + return true; + + switch (ptr->data.x_ptr.special) { + case ConstPtrSpecialRef: + return contains_comptime_undefined_value(ptr->data.x_ptr.data.ref.pointee); + case ConstPtrSpecialBaseArray: { + size_t offset = ptr->data.x_ptr.data.base_array.elem_index; + ConstExprValue *arr = ptr->data.x_ptr.data.base_array.array_val; + if (arr->special == ConstValSpecialUndef) + return true; + if (arr->data.x_array.special == ConstArraySpecialUndef) + return true; + + uint64_t slice_len = bigint_as_unsigned(&len->data.x_bigint); + for (size_t i = 0; i < slice_len; ++i) { + if (contains_comptime_undefined_value(&arr->data.x_array.s_none.elements[i + offset])) + return true; + } + + return false; + } + case ConstPtrSpecialBaseStruct: + case ConstPtrSpecialInvalid: + case ConstPtrSpecialFunction: + case ConstPtrSpecialDiscard: + case ConstPtrSpecialHardCodedAddr: + zig_unreachable(); + } + } + + for (size_t i = 0; i < value->type->data.structure.src_field_count; ++i) { + if (contains_comptime_undefined_value(&str->fields[i])) + return true; + } + return false; + } + case TypeTableEntryIdOptional: + if (value->data.x_optional == nullptr) + return false; + + return contains_comptime_undefined_value(value->data.x_optional); + case TypeTableEntryIdErrorUnion: + // TODO: Can error union error be undefined? + if (value->data.x_err_union.err != nullptr) + return false; + + return contains_comptime_undefined_value(value->data.x_err_union.payload); + case TypeTableEntryIdUnion: + return contains_comptime_undefined_value(value->data.x_union.payload); + + case TypeTableEntryIdArgTuple: + case TypeTableEntryIdVoid: + case TypeTableEntryIdBool: + case TypeTableEntryIdUnreachable: + case TypeTableEntryIdInt: + case TypeTableEntryIdFloat: + case TypeTableEntryIdComptimeFloat: + case TypeTableEntryIdComptimeInt: + case TypeTableEntryIdUndefined: + case TypeTableEntryIdNull: + case TypeTableEntryIdErrorSet: + case TypeTableEntryIdEnum: + case TypeTableEntryIdFn: + case TypeTableEntryIdNamespace: + case TypeTableEntryIdBlock: + case TypeTableEntryIdBoundFn: + case TypeTableEntryIdMetaType: + case TypeTableEntryIdOpaque: + case TypeTableEntryIdPromise: + return false; + } + zig_unreachable(); +} void init_const_undefined(CodeGen *g, ConstExprValue *const_val) { TypeTableEntry *wanted_type = const_val->type; diff --git a/src/analyze.hpp b/src/analyze.hpp index 88e06b2390..100f85d4d9 100644 --- a/src/analyze.hpp +++ b/src/analyze.hpp @@ -93,6 +93,7 @@ void ensure_complete_type(CodeGen *g, TypeTableEntry *type_entry); void type_ensure_zero_bits_known(CodeGen *g, TypeTableEntry *type_entry); void complete_enum(CodeGen *g, TypeTableEntry *enum_type); bool ir_get_var_is_comptime(VariableTableEntry *var); +bool contains_comptime_undefined_value(ConstExprValue *value); bool const_values_equal(ConstExprValue *a, ConstExprValue *b); void eval_min_max_value(CodeGen *g, TypeTableEntry *type_entry, ConstExprValue *const_val, bool is_max); void eval_min_max_value_int(CodeGen *g, TypeTableEntry *int_type, BigInt *bigint, bool is_max); diff --git a/src/ir.cpp b/src/ir.cpp index c6078e755d..2cce4a5044 100644 --- a/src/ir.cpp +++ b/src/ir.cpp @@ -9148,8 +9148,15 @@ enum UndefAllowed { static ConstExprValue *ir_resolve_const(IrAnalyze *ira, IrInstruction *value, UndefAllowed undef_allowed) { switch (value->value.special) { - case ConstValSpecialStatic: - return &value->value; + case ConstValSpecialStatic: { + ConstExprValue *res = &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; diff --git a/test/compile_errors.zig b/test/compile_errors.zig index 2247f0af96..8749f5b560 100644 --- a/test/compile_errors.zig +++ b/test/compile_errors.zig @@ -4124,4 +4124,19 @@ pub fn addCases(cases: *tests.CompileErrorContext) void { , ".tmp_source.zig:3:36: error: @ArgType could not resolve the type of arg 0 because 'fn(var)var' is generic", ); + + cases.add( + "Trying to pass undefined array to function taking comptime array by value", + \\fn a(comptime b: [2]u8) u8 { return b[0]; } + \\ + \\test "" { + \\ const arr: [2]u8 = undefined; + \\ _ = a(arr); + \\} + , + ".tmp_source.zig:5:11: error: use of undefined value", + ); + + + } -- cgit v1.2.3 From 58b1692182dc2f8da5b535f59e9a89cfab10a7b6 Mon Sep 17 00:00:00 2001 From: Jimmi HC Date: Fri, 29 Jun 2018 11:34:38 +0200 Subject: contains_comptime_undefined_value should not follow pointers --- src/analyze.cpp | 72 +-------------------------------------------------------- 1 file changed, 1 insertion(+), 71 deletions(-) (limited to 'src/analyze.cpp') diff --git a/src/analyze.cpp b/src/analyze.cpp index 068ea48c0a..4c200888d8 100644 --- a/src/analyze.cpp +++ b/src/analyze.cpp @@ -5296,41 +5296,6 @@ bool contains_comptime_undefined_value(ConstExprValue *value) { switch (value->type->id) { case TypeTableEntryIdInvalid: zig_unreachable(); - - case TypeTableEntryIdPointer: { - ConstPtrValue *ptr = &value->data.x_ptr; - if (ptr->mut == ConstPtrMutRuntimeVar) - return false; - - switch (ptr->special) { - case ConstPtrSpecialInvalid: - zig_unreachable(); - case ConstPtrSpecialRef: - return contains_comptime_undefined_value(ptr->data.ref.pointee); - case ConstPtrSpecialBaseArray: { - size_t index = ptr->data.base_array.elem_index; - ConstExprValue *arr = ptr->data.base_array.array_val; - if (arr->special == ConstValSpecialUndef) - return true; - if (arr->data.x_array.special == ConstArraySpecialUndef) - return true; - - return contains_comptime_undefined_value(&arr->data.x_array.s_none.elements[index]); - } - case ConstPtrSpecialBaseStruct: { - size_t index = ptr->data.base_struct.field_index; - ConstExprValue *str = ptr->data.base_struct.struct_val; - if (str->special == ConstValSpecialUndef) - return true; - - return contains_comptime_undefined_value(&str->data.x_struct.fields[index]); - } - case ConstPtrSpecialFunction: // TODO: Can a fn ptr have an undefined value? - case ConstPtrSpecialDiscard: - case ConstPtrSpecialHardCodedAddr: - return false; - } - } case TypeTableEntryIdArray: { ConstArrayValue *arr = &value->data.x_array; if (arr->special == ConstArraySpecialUndef) @@ -5344,42 +5309,6 @@ bool contains_comptime_undefined_value(ConstExprValue *value) { } case TypeTableEntryIdStruct: { ConstStructValue *str = &value->data.x_struct; - if (value->type->data.structure.is_slice) { - ConstExprValue *len = &str->fields[slice_len_index]; - ConstExprValue *ptr = &str->fields[slice_ptr_index]; - if (len->special == ConstValSpecialUndef) - return true; - if (ptr->special == ConstValSpecialUndef) - return true; - - switch (ptr->data.x_ptr.special) { - case ConstPtrSpecialRef: - return contains_comptime_undefined_value(ptr->data.x_ptr.data.ref.pointee); - case ConstPtrSpecialBaseArray: { - size_t offset = ptr->data.x_ptr.data.base_array.elem_index; - ConstExprValue *arr = ptr->data.x_ptr.data.base_array.array_val; - if (arr->special == ConstValSpecialUndef) - return true; - if (arr->data.x_array.special == ConstArraySpecialUndef) - return true; - - uint64_t slice_len = bigint_as_unsigned(&len->data.x_bigint); - for (size_t i = 0; i < slice_len; ++i) { - if (contains_comptime_undefined_value(&arr->data.x_array.s_none.elements[i + offset])) - return true; - } - - return false; - } - case ConstPtrSpecialBaseStruct: - case ConstPtrSpecialInvalid: - case ConstPtrSpecialFunction: - case ConstPtrSpecialDiscard: - case ConstPtrSpecialHardCodedAddr: - zig_unreachable(); - } - } - for (size_t i = 0; i < value->type->data.structure.src_field_count; ++i) { if (contains_comptime_undefined_value(&str->fields[i])) return true; @@ -5400,6 +5329,7 @@ bool contains_comptime_undefined_value(ConstExprValue *value) { case TypeTableEntryIdUnion: return contains_comptime_undefined_value(value->data.x_union.payload); + case TypeTableEntryIdPointer: case TypeTableEntryIdArgTuple: case TypeTableEntryIdVoid: case TypeTableEntryIdBool: -- cgit v1.2.3 From 616fe798c801baa5fa7238f5fc576a5090938999 Mon Sep 17 00:00:00 2001 From: Jimmi Holst Christensen Date: Sat, 30 Jun 2018 17:35:05 +0200 Subject: Revert "contains_comptime_undefined_value should not follow pointers" This reverts commit 58b1692182dc2f8da5b535f59e9a89cfab10a7b6. --- src/analyze.cpp | 72 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 71 insertions(+), 1 deletion(-) (limited to 'src/analyze.cpp') diff --git a/src/analyze.cpp b/src/analyze.cpp index 4c200888d8..068ea48c0a 100644 --- a/src/analyze.cpp +++ b/src/analyze.cpp @@ -5296,6 +5296,41 @@ bool contains_comptime_undefined_value(ConstExprValue *value) { switch (value->type->id) { case TypeTableEntryIdInvalid: zig_unreachable(); + + case TypeTableEntryIdPointer: { + ConstPtrValue *ptr = &value->data.x_ptr; + if (ptr->mut == ConstPtrMutRuntimeVar) + return false; + + switch (ptr->special) { + case ConstPtrSpecialInvalid: + zig_unreachable(); + case ConstPtrSpecialRef: + return contains_comptime_undefined_value(ptr->data.ref.pointee); + case ConstPtrSpecialBaseArray: { + size_t index = ptr->data.base_array.elem_index; + ConstExprValue *arr = ptr->data.base_array.array_val; + if (arr->special == ConstValSpecialUndef) + return true; + if (arr->data.x_array.special == ConstArraySpecialUndef) + return true; + + return contains_comptime_undefined_value(&arr->data.x_array.s_none.elements[index]); + } + case ConstPtrSpecialBaseStruct: { + size_t index = ptr->data.base_struct.field_index; + ConstExprValue *str = ptr->data.base_struct.struct_val; + if (str->special == ConstValSpecialUndef) + return true; + + return contains_comptime_undefined_value(&str->data.x_struct.fields[index]); + } + case ConstPtrSpecialFunction: // TODO: Can a fn ptr have an undefined value? + case ConstPtrSpecialDiscard: + case ConstPtrSpecialHardCodedAddr: + return false; + } + } case TypeTableEntryIdArray: { ConstArrayValue *arr = &value->data.x_array; if (arr->special == ConstArraySpecialUndef) @@ -5309,6 +5344,42 @@ bool contains_comptime_undefined_value(ConstExprValue *value) { } case TypeTableEntryIdStruct: { ConstStructValue *str = &value->data.x_struct; + if (value->type->data.structure.is_slice) { + ConstExprValue *len = &str->fields[slice_len_index]; + ConstExprValue *ptr = &str->fields[slice_ptr_index]; + if (len->special == ConstValSpecialUndef) + return true; + if (ptr->special == ConstValSpecialUndef) + return true; + + switch (ptr->data.x_ptr.special) { + case ConstPtrSpecialRef: + return contains_comptime_undefined_value(ptr->data.x_ptr.data.ref.pointee); + case ConstPtrSpecialBaseArray: { + size_t offset = ptr->data.x_ptr.data.base_array.elem_index; + ConstExprValue *arr = ptr->data.x_ptr.data.base_array.array_val; + if (arr->special == ConstValSpecialUndef) + return true; + if (arr->data.x_array.special == ConstArraySpecialUndef) + return true; + + uint64_t slice_len = bigint_as_unsigned(&len->data.x_bigint); + for (size_t i = 0; i < slice_len; ++i) { + if (contains_comptime_undefined_value(&arr->data.x_array.s_none.elements[i + offset])) + return true; + } + + return false; + } + case ConstPtrSpecialBaseStruct: + case ConstPtrSpecialInvalid: + case ConstPtrSpecialFunction: + case ConstPtrSpecialDiscard: + case ConstPtrSpecialHardCodedAddr: + zig_unreachable(); + } + } + for (size_t i = 0; i < value->type->data.structure.src_field_count; ++i) { if (contains_comptime_undefined_value(&str->fields[i])) return true; @@ -5329,7 +5400,6 @@ bool contains_comptime_undefined_value(ConstExprValue *value) { case TypeTableEntryIdUnion: return contains_comptime_undefined_value(value->data.x_union.payload); - case TypeTableEntryIdPointer: case TypeTableEntryIdArgTuple: case TypeTableEntryIdVoid: case TypeTableEntryIdBool: -- cgit v1.2.3 From 01bd5c46e177ae59f72197063c374e845eea3ff3 Mon Sep 17 00:00:00 2001 From: Jimmi Holst Christensen Date: Sat, 30 Jun 2018 17:35:06 +0200 Subject: Revert "ir_resolve_const now checks recursivly for undef values" This reverts commit 4c3f27ce1ea17b5236a022971ebace73a02b7c2b. --- src/analyze.cpp | 135 ------------------------------------------------ src/analyze.hpp | 1 - src/ir.cpp | 11 +--- test/compile_errors.zig | 15 ------ 4 files changed, 2 insertions(+), 160 deletions(-) (limited to 'src/analyze.cpp') diff --git a/src/analyze.cpp b/src/analyze.cpp index 068ea48c0a..b3a302a1d4 100644 --- a/src/analyze.cpp +++ b/src/analyze.cpp @@ -5288,141 +5288,6 @@ ConstExprValue *create_const_arg_tuple(CodeGen *g, size_t arg_index_start, size_ return const_val; } -bool contains_comptime_undefined_value(ConstExprValue *value) { - assert(value->special != ConstValSpecialRuntime); - if (value->special == ConstValSpecialUndef) - return true; - - switch (value->type->id) { - case TypeTableEntryIdInvalid: - zig_unreachable(); - - case TypeTableEntryIdPointer: { - ConstPtrValue *ptr = &value->data.x_ptr; - if (ptr->mut == ConstPtrMutRuntimeVar) - return false; - - switch (ptr->special) { - case ConstPtrSpecialInvalid: - zig_unreachable(); - case ConstPtrSpecialRef: - return contains_comptime_undefined_value(ptr->data.ref.pointee); - case ConstPtrSpecialBaseArray: { - size_t index = ptr->data.base_array.elem_index; - ConstExprValue *arr = ptr->data.base_array.array_val; - if (arr->special == ConstValSpecialUndef) - return true; - if (arr->data.x_array.special == ConstArraySpecialUndef) - return true; - - return contains_comptime_undefined_value(&arr->data.x_array.s_none.elements[index]); - } - case ConstPtrSpecialBaseStruct: { - size_t index = ptr->data.base_struct.field_index; - ConstExprValue *str = ptr->data.base_struct.struct_val; - if (str->special == ConstValSpecialUndef) - return true; - - return contains_comptime_undefined_value(&str->data.x_struct.fields[index]); - } - case ConstPtrSpecialFunction: // TODO: Can a fn ptr have an undefined value? - case ConstPtrSpecialDiscard: - case ConstPtrSpecialHardCodedAddr: - return false; - } - } - case TypeTableEntryIdArray: { - ConstArrayValue *arr = &value->data.x_array; - if (arr->special == ConstArraySpecialUndef) - return true; - - for (size_t i = 0; i < value->type->data.array.len; ++i) { - if (contains_comptime_undefined_value(&arr->s_none.elements[i])) - return true; - } - return false; - } - case TypeTableEntryIdStruct: { - ConstStructValue *str = &value->data.x_struct; - if (value->type->data.structure.is_slice) { - ConstExprValue *len = &str->fields[slice_len_index]; - ConstExprValue *ptr = &str->fields[slice_ptr_index]; - if (len->special == ConstValSpecialUndef) - return true; - if (ptr->special == ConstValSpecialUndef) - return true; - - switch (ptr->data.x_ptr.special) { - case ConstPtrSpecialRef: - return contains_comptime_undefined_value(ptr->data.x_ptr.data.ref.pointee); - case ConstPtrSpecialBaseArray: { - size_t offset = ptr->data.x_ptr.data.base_array.elem_index; - ConstExprValue *arr = ptr->data.x_ptr.data.base_array.array_val; - if (arr->special == ConstValSpecialUndef) - return true; - if (arr->data.x_array.special == ConstArraySpecialUndef) - return true; - - uint64_t slice_len = bigint_as_unsigned(&len->data.x_bigint); - for (size_t i = 0; i < slice_len; ++i) { - if (contains_comptime_undefined_value(&arr->data.x_array.s_none.elements[i + offset])) - return true; - } - - return false; - } - case ConstPtrSpecialBaseStruct: - case ConstPtrSpecialInvalid: - case ConstPtrSpecialFunction: - case ConstPtrSpecialDiscard: - case ConstPtrSpecialHardCodedAddr: - zig_unreachable(); - } - } - - for (size_t i = 0; i < value->type->data.structure.src_field_count; ++i) { - if (contains_comptime_undefined_value(&str->fields[i])) - return true; - } - return false; - } - case TypeTableEntryIdOptional: - if (value->data.x_optional == nullptr) - return false; - - return contains_comptime_undefined_value(value->data.x_optional); - case TypeTableEntryIdErrorUnion: - // TODO: Can error union error be undefined? - if (value->data.x_err_union.err != nullptr) - return false; - - return contains_comptime_undefined_value(value->data.x_err_union.payload); - case TypeTableEntryIdUnion: - return contains_comptime_undefined_value(value->data.x_union.payload); - - case TypeTableEntryIdArgTuple: - case TypeTableEntryIdVoid: - case TypeTableEntryIdBool: - case TypeTableEntryIdUnreachable: - case TypeTableEntryIdInt: - case TypeTableEntryIdFloat: - case TypeTableEntryIdComptimeFloat: - case TypeTableEntryIdComptimeInt: - case TypeTableEntryIdUndefined: - case TypeTableEntryIdNull: - case TypeTableEntryIdErrorSet: - case TypeTableEntryIdEnum: - case TypeTableEntryIdFn: - case TypeTableEntryIdNamespace: - case TypeTableEntryIdBlock: - case TypeTableEntryIdBoundFn: - case TypeTableEntryIdMetaType: - case TypeTableEntryIdOpaque: - case TypeTableEntryIdPromise: - return false; - } - zig_unreachable(); -} void init_const_undefined(CodeGen *g, ConstExprValue *const_val) { TypeTableEntry *wanted_type = const_val->type; diff --git a/src/analyze.hpp b/src/analyze.hpp index 100f85d4d9..88e06b2390 100644 --- a/src/analyze.hpp +++ b/src/analyze.hpp @@ -93,7 +93,6 @@ void ensure_complete_type(CodeGen *g, TypeTableEntry *type_entry); void type_ensure_zero_bits_known(CodeGen *g, TypeTableEntry *type_entry); void complete_enum(CodeGen *g, TypeTableEntry *enum_type); bool ir_get_var_is_comptime(VariableTableEntry *var); -bool contains_comptime_undefined_value(ConstExprValue *value); bool const_values_equal(ConstExprValue *a, ConstExprValue *b); void eval_min_max_value(CodeGen *g, TypeTableEntry *type_entry, ConstExprValue *const_val, bool is_max); void eval_min_max_value_int(CodeGen *g, TypeTableEntry *int_type, BigInt *bigint, bool is_max); diff --git a/src/ir.cpp b/src/ir.cpp index 2cce4a5044..c6078e755d 100644 --- a/src/ir.cpp +++ b/src/ir.cpp @@ -9148,15 +9148,8 @@ enum UndefAllowed { static ConstExprValue *ir_resolve_const(IrAnalyze *ira, IrInstruction *value, UndefAllowed undef_allowed) { switch (value->value.special) { - case ConstValSpecialStatic: { - ConstExprValue *res = &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 ConstValSpecialStatic: + return &value->value; case ConstValSpecialRuntime: ir_add_error(ira, value, buf_sprintf("unable to evaluate constant expression")); return nullptr; diff --git a/test/compile_errors.zig b/test/compile_errors.zig index 8749f5b560..2247f0af96 100644 --- a/test/compile_errors.zig +++ b/test/compile_errors.zig @@ -4124,19 +4124,4 @@ pub fn addCases(cases: *tests.CompileErrorContext) void { , ".tmp_source.zig:3:36: error: @ArgType could not resolve the type of arg 0 because 'fn(var)var' is generic", ); - - cases.add( - "Trying to pass undefined array to function taking comptime array by value", - \\fn a(comptime b: [2]u8) u8 { return b[0]; } - \\ - \\test "" { - \\ const arr: [2]u8 = undefined; - \\ _ = a(arr); - \\} - , - ".tmp_source.zig:5:11: error: use of undefined value", - ); - - - } -- cgit v1.2.3