From f9448363e40058bf8ca2f958bc5610d64805a6dc Mon Sep 17 00:00:00 2001 From: hl-valdemar Date: Sat, 18 Jul 2026 16:48:41 +0200 Subject: [PATCH] grouped comptime param update --- compiler/parser/parser.odin | 3 +++ compiler_tests.odin | 35 +++++++++++++++++++++++++++----- std/arraylist/arraylist.bro | 10 ++++----- std/arraylist/arraylist.test.bro | 32 +++++++++++++++++++++++++++++ std/testing/testing.bro | 11 +++++----- 5 files changed, 75 insertions(+), 16 deletions(-) create mode 100644 std/arraylist/arraylist.test.bro diff --git a/compiler/parser/parser.odin b/compiler/parser/parser.odin index 2d30a09..f7550f1 100644 --- a/compiler/parser/parser.odin +++ b/compiler/parser/parser.odin @@ -1953,6 +1953,9 @@ parse_params :: proc(parser: ^Parser) -> ([]ast.Param, bool) { break } skip_newlines(parser) + if comptime_value { + _, _ = allow(parser, .Dollar) + } } type_syntax := parse_type(parser) for name in names { diff --git a/compiler_tests.odin b/compiler_tests.odin index b3429d0..a400f08 100644 --- a/compiler_tests.odin +++ b/compiler_tests.odin @@ -230,6 +230,31 @@ main func() void {} testing.expect(t, !module.functions[0].params[1].comptime_value) } +@(test) +parser_accepts_grouped_comptime_params :: proc(t: ^testing.T) { + text := `grouped func($K, $V type, $A, B usize) void {} +main func() void {} +` + source_file := source.Source{path="test.bro", text=text} + diagnostics := source.init_diagnostics(&source_file) + defer source.destroy_diagnostics(&diagnostics) + symbols := symbol.init_table() + defer symbol.destroy_table(&symbols) + stream := lexer.lex(&source_file, &diagnostics, &symbols) + defer delete(stream.items) + module := parser.parse(&stream, &source_file, &diagnostics) + defer ast.destroy_module(&module) + + params := module.functions[0].params + testing.expect_value(t, len(diagnostics.items), 0) + testing.expect_value(t, len(params), 4) + for param in params { + testing.expect(t, param.comptime_value) + } + testing.expect_value(t, params[0].type, params[1].type) + testing.expect_value(t, params[2].type, params[3].type) +} + @(test) parser_accepts_comptime_type_params_and_builtin_type_args :: proc(t: ^testing.T) { text := `id func($T type, value T) T { @@ -13130,12 +13155,12 @@ dependency_passes test { defer delete(stderr) output := string(stderr) testing.expect_value(t, state.exit_code, 1) - testing.expect(t, strings.contains(output, "PASS root.root_passes")) - testing.expect(t, strings.contains(output, "FAIL root.root_fails")) + testing.expect(t, strings.contains(output, "root.root_passes [ok]")) + testing.expect(t, strings.contains(output, "root.root_fails [failed]")) testing.expect(t, strings.contains(output, "expected 42, found 41")) - testing.expect(t, strings.contains(output, "PASS root.root_continues")) - testing.expect(t, strings.contains(output, "FAIL root.root_errors")) - testing.expect(t, strings.contains(output, "PASS dependency.dependency_passes")) + testing.expect(t, strings.contains(output, "root.root_continues [ok]")) + testing.expect(t, strings.contains(output, "root.root_errors [failed]")) + testing.expect(t, strings.contains(output, "dependency.dependency_passes [ok]")) testing.expect(t, strings.contains(output, root_path)) testing.expect(t, strings.contains(output, "3 passed, 2 failed")) } diff --git a/std/arraylist/arraylist.bro b/std/arraylist/arraylist.bro index bcd11c2..9088da7 100644 --- a/std/arraylist/arraylist.bro +++ b/std/arraylist/arraylist.bro @@ -23,8 +23,8 @@ deinit func($T type, list @mut ArrayList(T)) void { list.capacity = 0 } -reserve func($T type, list @mut ArrayList(T), minimum_capacity usize) void ! mem.AllocError { - if minimum_capacity <= list.capacity { +reserve func($T type, list @mut ArrayList(T), min_capacity usize) void ! mem.AllocError { + if min_capacity <= list.capacity { return } @@ -32,13 +32,13 @@ reserve func($T type, list @mut ArrayList(T), minimum_capacity usize) void ! mem if list.capacity >= 8 { half usize :: divtrunc!(list.capacity, 2) if list.capacity > maxval!(usize) - half { - new_capacity = minimum_capacity + new_capacity = min_capacity } else { new_capacity = list.capacity + half } } - if new_capacity < minimum_capacity { - new_capacity = minimum_capacity + if new_capacity < min_capacity { + new_capacity = min_capacity } length usize :: list.items.len diff --git a/std/arraylist/arraylist.test.bro b/std/arraylist/arraylist.test.bro new file mode 100644 index 0000000..ae64e8d --- /dev/null +++ b/std/arraylist/arraylist.test.bro @@ -0,0 +1,32 @@ +import "@std/mem" +import "@std/testing" + +handles_append test { + list ArrayList(i32) = init(mem.c_allocator) + defer deinit(&list) + + try append(&list, 42) + + try testing.expect_equal(1, list.items.len) + try testing.expect_equal(42, list.items[0]) +} + +handles_clear test { + list ArrayList(i32) = init(mem.c_allocator) + defer deinit(&list) + + try append(&list, 42) + clear(&list) + + try testing.expect_equal(0, list.items.len) +} + +handles_reserve test { + list ArrayList(i32) = init(mem.c_allocator) + defer deinit(&list) + + try reserve(&list, 10) + + try testing.expect_equal(10, list.capacity) + try testing.expect_equal(0, list.items.len) +} diff --git a/std/testing/testing.bro b/std/testing/testing.bro index bcd5875..3a05e90 100644 --- a/std/testing/testing.bro +++ b/std/testing/testing.bro @@ -1,4 +1,4 @@ -debug :: import "@std/debug" +import "@std/debug" Error :: enum { expectation_failed @@ -11,26 +11,25 @@ SourceLocation :: struct { } expect func(condition bool, location SourceLocation) void ! Error { - if (!condition) { + if !condition { debug.print("{s}:{d}:{d}: expectation failed\n", {location.file, location.line, location.column}) return .expectation_failed } } expect_equal func($T type, expected, actual T, location SourceLocation) void ! Error { - if (expected != actual) { + if expected != actual { debug.print("{s}:{d}:{d}: expected {}, found {}\n", {location.file, location.line, location.column, expected, actual}) return .expectation_failed } } run func(name []u8, callback *func() void ! Error) bool { - debug.print("RUN {s}\n", {name,}) callback() catch |_| { - debug.print("FAIL {s}\n", {name,}) + debug.print("{s} [failed]\n", {name,}) return false } - debug.print("PASS {s}\n", {name,}) + debug.print("{s} [ok]\n", {name,}) return true }