diff --git a/source/diagnostics/diagnostics.hon b/source/diagnostics/diagnostics.hon index e2f5cc7..ae9fd85 100644 --- a/source/diagnostics/diagnostics.hon +++ b/source/diagnostics/diagnostics.hon @@ -21,30 +21,30 @@ Diagnostic :: struct { span Span } -Store :: struct { items arraylist.ArrayList(Diagnostic) } +Store :: struct { list arraylist.ArrayList(Diagnostic) } CapacityError :: enum { diagnostic_limit_reached } init proc(allocator mem.Allocator) Store { - return Store{ items = arraylist.init(allocator) } + return Store{ list = arraylist.init(allocator) } } deinit proc(store @mut Store) void { - arraylist.deinit(&store.items) + arraylist.deinit(&store.list) } add proc(store @mut Store, code Code, span Span) DiagnosticId ! (mem.AllocError | CapacityError) { - if (store.items.items.len >= usize(NO_DIAGNOSTIC)) return .diagnostic_limit_reached - id :: DiagnosticId(store.items.items.len) - try arraylist.append(&store.items, Diagnostic{ code = code, span = span }) + if (store.list.items.len >= usize(NO_DIAGNOSTIC)) return .diagnostic_limit_reached + id :: DiagnosticId(store.list.items.len) + try arraylist.append(&store.list, Diagnostic{ code = code, span = span }) return id } get proc(store @Store, id DiagnosticId) ?Diagnostic { - if (usize(id) >= store.items.items.len) return null - return store.items.items[usize(id)] + if (usize(id) >= store.list.items.len) return null + return store.list.items[usize(id)] } -len proc(store @Store) usize { - return store.items.items.len +count proc(store @Store) usize { + return store.list.items.len } diff --git a/source/lexer/lexer.test.hon b/source/lexer/lexer.test.hon index bdc9379..f4be324 100644 --- a/source/lexer/lexer.test.hon +++ b/source/lexer/lexer.test.hon @@ -22,7 +22,7 @@ reports_invalid_input_and_keeps_scanning test { try testing.expect_equal(TokenKind.float, state.tokens.items[5].kind) try testing.expect_equal(TokenKind.string, state.tokens.items[6].kind) try testing.expect_equal(TokenKind.eof, state.tokens.items[7].kind) - try testing.expect_equal(2, diagnostics.len(&diagnostic_store)) + try testing.expect_equal(2, diagnostics.count(&diagnostic_store)) try testing.expect_equal("name", strpool.get_str(&strpool.STRINGS, state.tokens.items[1].data.str_id)?) try testing.expect_equal(u32(3), state.tokens.items[1].span.start) try testing.expect_equal(u32(7), state.tokens.items[1].span.end) diff --git a/source/main.hon b/source/main.hon index 17d425b..5799cb2 100644 --- a/source/main.hon +++ b/source/main.hon @@ -59,5 +59,5 @@ main proc() void! { try ast_renderer.render(&renderer, &tree) debug.print("{s}", {renderer.bytes.items}) - debug.print("diagnostics: {}\n", {diagnostics.len(&diagnostic_store)}) + debug.print("diagnostics: {}\n", {diagnostics.count(&diagnostic_store)}) } diff --git a/source/parser/parser.test.hon b/source/parser/parser.test.hon index 702f093..ab18291 100644 --- a/source/parser/parser.test.hon +++ b/source/parser/parser.test.hon @@ -30,7 +30,7 @@ parses_expression_precedence_through_tree_views test { try testing.expect_equal(ast.ExprKind.binary, ast.expr_kind(&tree, add.right)) multiply :: ast.binary_expr(&tree, add.right) try testing.expect_equal(ast.BinaryOperator.multiply, multiply.operator) - try testing.expect_equal(0, diagnostics.len(&diagnostic_store)) + try testing.expect_equal(0, diagnostics.count(&diagnostic_store)) } parses_function_structure_through_tree_views test { @@ -63,7 +63,7 @@ parses_function_structure_through_tree_views test { try testing.expect_equal(first.type, second.type) try testing.expect(first.type != third.type) try testing.expect_equal(1, ast.block_statement_count(&tree, function.body)) - try testing.expect_equal(0, diagnostics.len(&diagnostic_store)) + try testing.expect_equal(0, diagnostics.count(&diagnostic_store)) } recovers_invalid_declaration_and_preserves_sibling test { diff --git a/std/io/file.hon b/std/io/file.hon index c0b7432..eba8a6f 100644 --- a/std/io/file.hon +++ b/std/io/file.hon @@ -84,7 +84,7 @@ writer proc(file File) Writer { .read_write: flags = c.O_RDWR } while true { - fd c_int :: c.open(ptrcast!(c_char, path.ptr), flags) + fd c_int :: c.open(ptrcast!(path.ptr), flags) if (fd >= 0) return Handle{ file_desc = fd } if (c.__error()?^ != c.EINTR) return .open_failed } diff --git a/std/io/io.hon b/std/io/io.hon index 48f552f..05726ed 100644 --- a/std/io/io.hon +++ b/std/io/io.hon @@ -336,7 +336,7 @@ format_field_name proc($T type, index usize) []u8 { @hide:file distinct_value proc($Backing, $Distinct type, value Distinct) Backing { - return ptrcast!(Backing, &value)^ + return ptrcast!(@Backing, &value)^ } @hide:file @@ -375,12 +375,12 @@ write_float proc(output Writer, $T type, value T, scientific bool) void ! WriteE buffer [64]mut u8 := undefined count := 0 if sizeof!(T) == 4 { - if (scientific) count = c.snprintf(ptrcast!(c_char, (&buffer).ptr), c_ulong(buffer.len), "%.8e", value) - else count = c.snprintf(ptrcast!(c_char, (&buffer).ptr), c_ulong(buffer.len), "%.9g", value) + if (scientific) count = c.snprintf(ptrcast!((&buffer).ptr), c_ulong(buffer.len), "%.8e", value) + else count = c.snprintf(ptrcast!((&buffer).ptr), c_ulong(buffer.len), "%.9g", value) } else if scientific { - count = c.snprintf(ptrcast!(c_char, (&buffer).ptr), c_ulong(buffer.len), "%.16e", value) + count = c.snprintf(ptrcast!((&buffer).ptr), c_ulong(buffer.len), "%.16e", value) } else { - count = c.snprintf(ptrcast!(c_char, (&buffer).ptr), c_ulong(buffer.len), "%.17g", value) + count = c.snprintf(ptrcast!((&buffer).ptr), c_ulong(buffer.len), "%.17g", value) } if (count < 0 or usize(count) >= buffer.len) return .write_failed try write_all(output, buffer[0..usize(count)]) diff --git a/std/mem/mem.hon b/std/mem/mem.hon index 7b0d41b..4bfa3b7 100644 --- a/std/mem/mem.hon +++ b/std/mem/mem.hon @@ -48,7 +48,7 @@ alloc proc($T type, allocator Allocator, count usize) []mut T ! AllocError { memory := raw_alloc(allocator, count * element_size, alignof!(T)) if memory |bytes| { - pointer *mut T :: ptrcast!(T, bytes) + pointer *mut T :: ptrcast!(bytes) return pointer[..count] } @@ -75,7 +75,7 @@ realloc proc($T type, allocator Allocator, memory []mut T, new_count usize) []mu old_memory ?*mut u8 := null old_size := 0 if memory.len != 0 { - old_memory = ptrcast!(u8, memory.ptr) + old_memory = ptrcast!(memory.ptr) old_size = memory.len * element_size } @@ -88,7 +88,7 @@ realloc proc($T type, allocator Allocator, memory []mut T, new_count usize) []mu ) if resized |bytes| { - pointer *mut T :: ptrcast!(T, bytes) + pointer *mut T :: ptrcast!(bytes) return pointer[..new_count] } @@ -100,7 +100,6 @@ realloc proc($T type, allocator Allocator, memory []mut T, new_count usize) []mu free proc($T type, allocator Allocator, memory []T) void { if (memory.len == 0 or sizeof!(T) == 0) return raw_free(allocator, ptrcast!( - u8, constcast!(memory).ptr), memory.len * sizeof!(T), alignof!(T), @@ -112,7 +111,7 @@ free proc($T type, allocator Allocator, memory []T) void { #! exceeds its backing storage. @hide:file empty_slice proc($T type, count usize) []mut T { - pointer *mut T :: ptrcast!(T, (&empty_storage).ptr) + pointer *mut T :: ptrcast!((&empty_storage).ptr) return pointer[..count] } @@ -142,13 +141,13 @@ power_of_two proc(value usize) bool { @hide:file c_alloc proc(_ ?@mut anyopaque, size usize, alignment usize) ?*mut u8 { if (power_of_two(alignment) == false) return null - if (alignment <= malloc_alignment) return ptrcast!(u8, c.malloc(c_ulong(size))) + if (alignment <= malloc_alignment) return ptrcast!(c.malloc(c_ulong(size))) memory [1]mut ?*mut anyopaque := [null] status := c.posix_memalign((&memory).ptr, c_ulong(alignment), c_ulong(size)) if (status != 0) return null - return ptrcast!(u8, memory[0]) + return ptrcast!(memory[0]) } @hide:file @@ -168,7 +167,7 @@ c_realloc proc( if memory |old_memory| { if alignment <= malloc_alignment { - return ptrcast!(u8, c.realloc(old_memory, c_ulong(new_size))) + return ptrcast!(c.realloc(old_memory, c_ulong(new_size))) } new_memory := c_alloc(null, new_size, alignment)