replace leading _ for private symbols with keyword hide

std/io/io.bro

@@ -74,7 +74,7 @@ write_all func(writer Writer, bytes []u8) void ! WriteError {
 	return
 }
 
-_system_read func(_ ?*mut anyopaque, stream ReadStream, buffer []mut u8) usize ! ReadError {
+hide system_read func(_ ?*mut anyopaque, stream ReadStream, buffer []mut u8) usize ! ReadError {
 	request usize = buffer.len
 	maximum usize :: usize(maxval!(c_long))
 	if request > maximum {
@@ -91,7 +91,7 @@ _system_read func(_ ?*mut anyopaque, stream ReadStream, buffer []mut u8) usize !
 	}
 }
 
-_system_write func(_ ?*mut anyopaque, stream WriteStream, bytes []u8) usize ! WriteError {
+hide system_write func(_ ?*mut anyopaque, stream WriteStream, bytes []u8) usize ! WriteError {
 	fd c_int :: c_int(stream)
 	request usize = bytes.len
 	maximum usize :: usize(maxval!(c_long))
@@ -109,14 +109,14 @@ _system_write func(_ ?*mut anyopaque, stream WriteStream, bytes []u8) usize ! Wr
 	}
 }
 
-_system_vtable IoVTable :: IoVTable {
-	read = _system_read,
-	write = _system_write,
+hide system_vtable IoVTable :: IoVTable {
+	read = system_read,
+	write = system_write,
 }
 
-_system func() Io {
+hide system func() Io {
 	return Io {
 		context = none,
-		vtable = &_system_vtable,
+		vtable = &system_vtable,
 	}
 }

std/mem/mem.bro

@@ -41,25 +41,25 @@ eql func($T type, left, right []T) bool {
 	return true
 }
 
-_empty_storage [1]mut u64 = [0]
+hide empty_storage [1]mut u64 = [0]
 
-_empty_slice func($T type, count usize) []mut T {
-	pointer *mut T :: ptrcast!(T, (&_empty_storage).ptr)
+hide empty_slice func($T type, count usize) []mut T {
+	pointer *mut T :: ptrcast!(T, (&empty_storage).ptr)
 	return pointer[..count]
 }
 
 empty func($T type) []mut T {
-	return _empty_slice(T, 0)
+	return empty_slice(T, 0)
 }
 
 alloc func($T type, allocator Allocator, count usize) []mut T ! AllocError {
 	if count == 0 {
-		return _empty_slice(T, 0)
+		return empty_slice(T, 0)
 	}
 
 	element_size usize :: sizeof!(T)
 	if element_size == 0 {
-		return _empty_slice(T, count)
+		return empty_slice(T, count)
 	}
 	if count > divtrunc!(maxval!(usize), element_size) {
 		return .out_of_memory
@@ -79,12 +79,12 @@ realloc func($T type, allocator Allocator, memory []mut T, new_count usize) []mu
 	}
 	if new_count == 0 {
 		free(allocator, memory)
-		return _empty_slice(T, 0)
+		return empty_slice(T, 0)
 	}
 
 	element_size usize :: sizeof!(T)
 	if element_size == 0 {
-		return _empty_slice(T, new_count)
+		return empty_slice(T, new_count)
 	}
 	if new_count > divtrunc!(maxval!(usize), element_size) {
 		return .out_of_memory
@@ -116,9 +116,9 @@ free func($T type, allocator Allocator, memory []mut T) void {
 	}
 }
 
-_malloc_alignment usize :: 16 # ponytail: aarch64-macos libc malloc alignment assumption.
+hide malloc_alignment usize :: 16 # ponytail: aarch64-macos libc malloc alignment assumption.
 
-_power_of_two func(value usize) bool {
+hide power_of_two func(value usize) bool {
 	if value == 0 {
 		return false
 	}
@@ -135,12 +135,12 @@ _power_of_two func(value usize) bool {
 	return true
 }
 
-_c_alloc func(_ ?*mut anyopaque, size usize, alignment usize) ?*mut u8 {
-	if _power_of_two(alignment) == false {
+hide c_alloc func(_ ?*mut anyopaque, size usize, alignment usize) ?*mut u8 {
+	if power_of_two(alignment) == false {
 		return none
 	}
 
-	if alignment <= _malloc_alignment {
+	if alignment <= malloc_alignment {
 		return ptrcast!(u8, c.malloc(c_ulong(size)))
 	}
 
@@ -153,8 +153,8 @@ _c_alloc func(_ ?*mut anyopaque, size usize, alignment usize) ?*mut u8 {
 	return ptrcast!(u8, memory[0])
 }
 
-_c_realloc func(_ ?*mut anyopaque, memory ?*mut u8, old_size usize, new_size usize, alignment usize) ?*mut u8 {
-	if _power_of_two(alignment) == false {
+hide c_realloc func(_ ?*mut anyopaque, memory ?*mut u8, old_size usize, new_size usize, alignment usize) ?*mut u8 {
+	if power_of_two(alignment) == false {
 		return none
 	}
 
@@ -164,11 +164,11 @@ _c_realloc func(_ ?*mut anyopaque, memory ?*mut u8, old_size usize, new_size usi
 	}
 
 	if memory |old_memory| {
-		if alignment <= _malloc_alignment {
+		if alignment <= malloc_alignment {
 			return ptrcast!(u8, c.realloc(old_memory, c_ulong(new_size)))
 		}
 
-		new_memory ?*mut u8 = _c_alloc(none, new_size, alignment)
+		new_memory ?*mut u8 = c_alloc(none, new_size, alignment)
 		if new_memory |new_bytes| {
 			copy_size usize = old_size
 			if new_size < copy_size {
@@ -183,20 +183,20 @@ _c_realloc func(_ ?*mut anyopaque, memory ?*mut u8, old_size usize, new_size usi
 		return new_memory
 	}
 
-	return _c_alloc(none, new_size, alignment)
+	return c_alloc(none, new_size, alignment)
 }
 
-_c_free func(_ ?*mut anyopaque, memory ?*mut u8, _ usize, _ usize) void {
+hide c_free func(_ ?*mut anyopaque, memory ?*mut u8, _ usize, _ usize) void {
 	c.free(memory)
 }
 
-_c_vtable AllocatorVTable :: AllocatorVTable {
-	alloc = _c_alloc,
-	realloc = _c_realloc,
-	free = _c_free,
+hide c_vtable AllocatorVTable :: AllocatorVTable {
+	alloc = c_alloc,
+	realloc = c_realloc,
+	free = c_free,
 }
 
 c_allocator Allocator :: Allocator {
 	context = none,
-	vtable = &_c_vtable,
+	vtable = &c_vtable,
 }

std/std.bro

@@ -1,3 +1,5 @@
+import "io"
 import "arraylist"
 
+Io :: alias io.Io
 ArrayList :: alias arraylist.ArrayList