replace leading _ for private symbols with keyword hide

testbed/mem_alloc/std/mem/mem.bro

@@ -27,21 +27,21 @@ raw_free func(allocator Allocator, memory ?*mut u8, size usize, alignment usize)
 	allocator.vtable.free(allocator.context, memory, size, alignment)
 }
 
-_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]
 }
 
 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 > maxval!(usize) / element_size {
 		return .out_of_memory
@@ -61,9 +61,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
 	}
@@ -80,12 +80,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)))
 	}
 
@@ -98,8 +98,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
 	}
 
@@ -109,11 +109,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 {
@@ -128,20 +128,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,
 }