From 5ce8d1ede834134ec7fd71c62738791c2d36e171 Mon Sep 17 00:00:00 2001 From: FourteenBrush <74827262+FourteenBrush@users.noreply.github.com> Date: Fri, 11 Jul 2025 16:58:47 +0200 Subject: [PATCH 1/8] Add clangd stuff to gitignore --- .gitignore | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/.gitignore b/.gitignore index c85ccb4ad..be3e78954 100644 --- a/.gitignore +++ b/.gitignore @@ -297,3 +297,8 @@ build.sh *.rdi tests/issues/build/* misc/featuregen/featuregen + +# Clangd stuff +.cache/ +.clangd +compile_commands.json From 8cbf75c928e91a93fbd0ab48877c5f32afa3a9f4 Mon Sep 17 00:00:00 2001 From: FourteenBrush <74827262+FourteenBrush@users.noreply.github.com> Date: Fri, 11 Jul 2025 17:03:49 +0200 Subject: [PATCH 2/8] Add type_enum_is_contiguous intrinsic --- base/intrinsics/intrinsics.odin | 3 +++ src/check_builtin.cpp | 48 +++++++++++++++++++++++++++++++++ src/checker_builtin_procs.hpp | 4 +++ 3 files changed, 55 insertions(+) diff --git a/base/intrinsics/intrinsics.odin b/base/intrinsics/intrinsics.odin index c1d16c5e4..20a7f4a84 100644 --- a/base/intrinsics/intrinsics.odin +++ b/base/intrinsics/intrinsics.odin @@ -213,6 +213,9 @@ type_is_subtype_of :: proc($T, $U: typeid) -> bool --- type_field_index_of :: proc($T: typeid, $name: string) -> uintptr --- +// Contiguous as in having a set of constants, when sorted, the difference between consecutive values is only 0 or 1 +type_enum_is_contiguous :: proc($T: typeid) -> bool where type_is_enum(T) --- + type_equal_proc :: proc($T: typeid) -> (equal: proc "contextless" (rawptr, rawptr) -> bool) where type_is_comparable(T) --- type_hasher_proc :: proc($T: typeid) -> (hasher: proc "contextless" (data: rawptr, seed: uintptr) -> uintptr) where type_is_comparable(T) --- diff --git a/src/check_builtin.cpp b/src/check_builtin.cpp index 9f9787b61..70848cec6 100644 --- a/src/check_builtin.cpp +++ b/src/check_builtin.cpp @@ -1,5 +1,11 @@ typedef bool (BuiltinTypeIsProc)(Type *t); +gb_internal int enum_constant_entity_cmp(void const* a, void const* b) { + BigInt bi = (*cast(Entity const **)a)->Constant.value.value_integer; + BigInt bj = (*cast(Entity const **)b)->Constant.value.value_integer; + return big_int_cmp(&bi, &bj); +} + gb_global BuiltinTypeIsProc *builtin_type_is_procs[BuiltinProc__type_simple_boolean_end - BuiltinProc__type_simple_boolean_begin] = { nullptr, // BuiltinProc__type_simple_boolean_begin @@ -6919,6 +6925,48 @@ gb_internal bool check_builtin_procedure(CheckerContext *c, Operand *operand, As break; } + case BuiltinProc_type_enum_is_contiguous: + { + Operand op = {}; + Type *bt = check_type(c, ce->args[0]); + Type *type = base_type(bt); + if (type == nullptr || type == t_invalid) { + error(ce->args[0], "Expected a type for '%.*s'", LIT(builtin_name)); + return false; + } + if (!is_type_enum(type)) { + gbString t = type_to_string(type); + error(ce->args[0], "Expected an enum type for '%.*s', got %s", LIT(builtin_name), t); + gb_string_free(t); + return false; + } + + // sort enum fields in place in ascending order + Array enum_constants = type->Enum.fields; + array_sort(enum_constants, enum_constant_entity_cmp); + + BigInt minus_one = big_int_make_i64(-1); + BigInt diff = {}; + + bool contiguous = true; + operand->mode = Addressing_Constant; + operand->type = t_untyped_bool; + + for (isize i = 0; i < enum_constants.count - 1; i++) { + BigInt curr = enum_constants[i]->Constant.value.value_integer; + BigInt next = enum_constants[i + 1]->Constant.value.value_integer; + big_int_sub(&diff, &curr, &next); + + if (!big_int_is_zero(&diff) && big_int_cmp(&diff, &minus_one) != 0) { + contiguous = false; + break; + } + } + + operand->value = exact_value_bool(contiguous); + break; + } + case BuiltinProc_type_equal_proc: { Operand op = {}; diff --git a/src/checker_builtin_procs.hpp b/src/checker_builtin_procs.hpp index 90652cb0b..38d49e330 100644 --- a/src/checker_builtin_procs.hpp +++ b/src/checker_builtin_procs.hpp @@ -325,6 +325,8 @@ BuiltinProc__type_simple_boolean_end, BuiltinProc_type_bit_set_backing_type, + BuiltinProc_type_enum_is_contiguous, + BuiltinProc_type_equal_proc, BuiltinProc_type_hasher_proc, BuiltinProc_type_map_info, @@ -678,6 +680,8 @@ gb_global BuiltinProc builtin_procs[BuiltinProc_COUNT] = { {STR_LIT("type_bit_set_backing_type"), 1, false, Expr_Expr, BuiltinProcPkg_intrinsics}, + {STR_LIT("type_enum_is_contiguous"), 1, false, Expr_Expr, BuiltinProcPkg_intrinsics }, + {STR_LIT("type_equal_proc"), 1, false, Expr_Expr, BuiltinProcPkg_intrinsics}, {STR_LIT("type_hasher_proc"), 1, false, Expr_Expr, BuiltinProcPkg_intrinsics}, {STR_LIT("type_map_info"), 1, false, Expr_Expr, BuiltinProcPkg_intrinsics}, From 56c221e211a7336326d04ba6a1240f5f47f6f723 Mon Sep 17 00:00:00 2001 From: FourteenBrush <74827262+FourteenBrush@users.noreply.github.com> Date: Fri, 11 Jul 2025 17:06:08 +0200 Subject: [PATCH 3/8] Rephrasing for constants --- base/intrinsics/intrinsics.odin | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/base/intrinsics/intrinsics.odin b/base/intrinsics/intrinsics.odin index 20a7f4a84..dc1690ba8 100644 --- a/base/intrinsics/intrinsics.odin +++ b/base/intrinsics/intrinsics.odin @@ -213,7 +213,7 @@ type_is_subtype_of :: proc($T, $U: typeid) -> bool --- type_field_index_of :: proc($T: typeid, $name: string) -> uintptr --- -// Contiguous as in having a set of constants, when sorted, the difference between consecutive values is only 0 or 1 +// Contiguous as in having a set of constants, when sorted, the difference between consecutive constants is only 0 or 1 type_enum_is_contiguous :: proc($T: typeid) -> bool where type_is_enum(T) --- type_equal_proc :: proc($T: typeid) -> (equal: proc "contextless" (rawptr, rawptr) -> bool) where type_is_comparable(T) --- From cb05271157a944c934dd8bf015570f25ebd2eccc Mon Sep 17 00:00:00 2001 From: FourteenBrush <74827262+FourteenBrush@users.noreply.github.com> Date: Fri, 11 Jul 2025 17:17:30 +0200 Subject: [PATCH 4/8] Add note on sparse vs contiguous --- base/intrinsics/intrinsics.odin | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/base/intrinsics/intrinsics.odin b/base/intrinsics/intrinsics.odin index dc1690ba8..c0685f4db 100644 --- a/base/intrinsics/intrinsics.odin +++ b/base/intrinsics/intrinsics.odin @@ -213,7 +213,8 @@ type_is_subtype_of :: proc($T, $U: typeid) -> bool --- type_field_index_of :: proc($T: typeid, $name: string) -> uintptr --- -// Contiguous as in having a set of constants, when sorted, the difference between consecutive constants is only 0 or 1 +// "Contiguous" means that the set of enum constants, when sorted, have a difference of either 0 or 1 between consecutive values. +// This is the exact opposite of "sparse". type_enum_is_contiguous :: proc($T: typeid) -> bool where type_is_enum(T) --- type_equal_proc :: proc($T: typeid) -> (equal: proc "contextless" (rawptr, rawptr) -> bool) where type_is_comparable(T) --- From 64bb0d1c7d03d0ce3a1643401009c528ec9ac296 Mon Sep 17 00:00:00 2001 From: FourteenBrush <74827262+FourteenBrush@users.noreply.github.com> Date: Fri, 11 Jul 2025 19:38:01 +0200 Subject: [PATCH 5/8] Allocate temp array instead of sorting in place --- src/check_builtin.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/check_builtin.cpp b/src/check_builtin.cpp index 70848cec6..041e89afd 100644 --- a/src/check_builtin.cpp +++ b/src/check_builtin.cpp @@ -6941,8 +6941,8 @@ gb_internal bool check_builtin_procedure(CheckerContext *c, Operand *operand, As return false; } - // sort enum fields in place in ascending order - Array enum_constants = type->Enum.fields; + auto enum_constants = array_make(temporary_allocator(), type->Enum.fields.count); + array_copy(&enum_constants, type->Enum.fields, 0); array_sort(enum_constants, enum_constant_entity_cmp); BigInt minus_one = big_int_make_i64(-1); From 2dd0b7528926f9ea275bdbd9b6654a3e1600ac54 Mon Sep 17 00:00:00 2001 From: FourteenBrush <74827262+FourteenBrush@users.noreply.github.com> Date: Fri, 11 Jul 2025 21:07:28 +0200 Subject: [PATCH 6/8] Fix BigInt leaking --- src/check_builtin.cpp | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/check_builtin.cpp b/src/check_builtin.cpp index 041e89afd..4223419a5 100644 --- a/src/check_builtin.cpp +++ b/src/check_builtin.cpp @@ -6946,6 +6946,7 @@ gb_internal bool check_builtin_procedure(CheckerContext *c, Operand *operand, As array_sort(enum_constants, enum_constant_entity_cmp); BigInt minus_one = big_int_make_i64(-1); + defer (big_int_dealloc(&minus_one)); BigInt diff = {}; bool contiguous = true; @@ -6956,6 +6957,7 @@ gb_internal bool check_builtin_procedure(CheckerContext *c, Operand *operand, As BigInt curr = enum_constants[i]->Constant.value.value_integer; BigInt next = enum_constants[i + 1]->Constant.value.value_integer; big_int_sub(&diff, &curr, &next); + defer (big_int_dealloc(&diff)); if (!big_int_is_zero(&diff) && big_int_cmp(&diff, &minus_one) != 0) { contiguous = false; From d08ebf56e76e078e70ae02ac047d9eee9c68834c Mon Sep 17 00:00:00 2001 From: FourteenBrush <74827262+FourteenBrush@users.noreply.github.com> Date: Fri, 11 Jul 2025 21:10:42 +0200 Subject: [PATCH 7/8] Add intrinsics.type_enum_is_contiguous test --- .../test_intrinsics_enum_contiguous.odin | 24 +++++++++++++++++++ 1 file changed, 24 insertions(+) create mode 100644 tests/internal/test_intrinsics_enum_contiguous.odin diff --git a/tests/internal/test_intrinsics_enum_contiguous.odin b/tests/internal/test_intrinsics_enum_contiguous.odin new file mode 100644 index 000000000..7a6901b82 --- /dev/null +++ b/tests/internal/test_intrinsics_enum_contiguous.odin @@ -0,0 +1,24 @@ +package test_internal + +import "base:intrinsics" +import "core:testing" + +@(test) +test_intrinsics_enum_is_contiguous :: proc(t: ^testing.T) { + contiguous :: intrinsics.type_enum_is_contiguous + testing.expect(t, contiguous(enum { A=0, B=0, C=0 })) + testing.expect(t, contiguous(enum { A=0, B=1, C=2 })) + testing.expect(t, contiguous(enum { A=1, B=2, C=2 })) + testing.expect(t, contiguous(enum { A=-2, B=-1, C=0 })) + testing.expect(t, contiguous(enum { A=-8, B=-6, C=-7, D=-8 })) + testing.expect(t, contiguous(enum { C=4, A=3 })) + testing.expect(t, contiguous(enum { })) + testing.expect(t, contiguous(enum { A })) + testing.expect(t, contiguous(enum { Delta=-4 })) + testing.expect(t, contiguous(enum { X = 2 * len([?]u8{ 0 }) })) + testing.expect(t, contiguous(enum { Alpha=-2, Beta=-1, Gamma=0, Delta=-3 })) + + testing.expect(t, !contiguous(enum { A=1, B=3 })) + testing.expect(t, !contiguous(enum { B=-5, Beta=-3 })) + testing.expect(t, !contiguous(enum { A=0, B=-2 })) +} From 980370a24bb4eb5bddd88097ef6afbda452bffa0 Mon Sep 17 00:00:00 2001 From: FourteenBrush <74827262+FourteenBrush@users.noreply.github.com> Date: Fri, 11 Jul 2025 21:23:21 +0200 Subject: [PATCH 8/8] Add union kind assertion to enum_constant_entity_cmp --- src/check_builtin.cpp | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-) diff --git a/src/check_builtin.cpp b/src/check_builtin.cpp index 4223419a5..b833c7014 100644 --- a/src/check_builtin.cpp +++ b/src/check_builtin.cpp @@ -1,9 +1,12 @@ typedef bool (BuiltinTypeIsProc)(Type *t); gb_internal int enum_constant_entity_cmp(void const* a, void const* b) { - BigInt bi = (*cast(Entity const **)a)->Constant.value.value_integer; - BigInt bj = (*cast(Entity const **)b)->Constant.value.value_integer; - return big_int_cmp(&bi, &bj); + Entity const *ea = *(cast(Entity const **)a); + Entity const *eb = *(cast(Entity const **)b); + GB_ASSERT(ea->kind == Entity_Constant && eb->kind == Entity_Constant); + GB_ASSERT(ea->Constant.value.kind == ExactValue_Integer && eb->Constant.value.kind == ExactValue_Integer); + + return big_int_cmp(&ea->Constant.value.value_integer, &eb->Constant.value.value_integer); } gb_global BuiltinTypeIsProc *builtin_type_is_procs[BuiltinProc__type_simple_boolean_end - BuiltinProc__type_simple_boolean_begin] = {