vlib: change byte to u8 (#19930)

kimshrier · web-flow · commit cc220e60a5a0 · 2023-11-19T04:23:32.000+03:00
diff --git a/vlib/builtin/linux_bare/memory_managment.v b/vlib/builtin/linux_bare/memory_managment.v
@@ -2,7 +2,7 @@ module builtin
 
 import dlmalloc
 
-fn mm_alloc(size u64) (&byte, Errno) {
+fn mm_alloc(size u64) (&u8, Errno) {
 	// BEGIN CONSTS
 	// the constants need to be here, since the initialization of other constants,
 	// which happen before these ones would, require malloc
diff --git a/vlib/builtin/linux_bare/old/linuxsys_bare.v b/vlib/builtin/linux_bare/old/linuxsys_bare.v
@@ -337,16 +337,16 @@ fn split_int_errno(rc_in u64) (i64, Errno) {
 }
 
 // 0 sys_read unsigned int fd char *buf size_t count
-pub fn sys_read(fd i64, buf &byte, count u64) (i64, Errno) {
+pub fn sys_read(fd i64, buf &u8, count u64) (i64, Errno) {
 	return split_int_errno(sys_call3(0, u64(fd), u64(buf), count))
 }
 
 // 1 sys_write unsigned int fd, const char *buf, size_t count
-pub fn sys_write(fd i64, buf &byte, count u64) (i64, Errno) {
+pub fn sys_write(fd i64, buf &u8, count u64) (i64, Errno) {
 	return split_int_errno(sys_call3(1, u64(fd), u64(buf), count))
 }
 
-pub fn sys_open(filename &byte, flags i64, mode int) (i64, Errno) {
+pub fn sys_open(filename &u8, flags i64, mode int) (i64, Errno) {
 	// 2 sys_open  const char *filename  int flags int mode
 	return split_int_errno(sys_call3(2, u64(filename), u64(flags), u64(mode)))
 }
@@ -357,7 +357,7 @@ pub fn sys_close(fd i64) Errno {
 }
 
 // 9 sys_mmap unsigned long addr  unsigned long len unsigned long prot  unsigned long flags unsigned long fd  unsigned long off
-pub fn sys_mmap(addr &byte, len u64, prot Mm_prot, flags Map_flags, fildes u64, off u64) (&byte, Errno) {
+pub fn sys_mmap(addr &u8, len u64, prot Mm_prot, flags Map_flags, fildes u64, off u64) (&u8, Errno) {
 	rc := sys_call6(9, u64(addr), len, u64(prot), u64(flags), fildes, off)
 	a, e := split_int_errno(rc)
 	return &u8(a), e
diff --git a/vlib/builtin/linux_bare/old/mm_bare.v b/vlib/builtin/linux_bare/old/mm_bare.v
@@ -11,7 +11,7 @@ pub fn mm_pages(size u64) u32 {
 	return u32(pages)
 }
 
-pub fn mm_alloc(size u64) (&byte, Errno) {
+pub fn mm_alloc(size u64) (&u8, Errno) {
 	pages := mm_pages(size)
 	n_bytes := u64(pages * u32(Linux_mem.page_size))
 
@@ -24,7 +24,7 @@ pub fn mm_alloc(size u64) (&byte, Errno) {
 	return &u8(0), e
 }
 
-pub fn mm_free(addr &byte) Errno {
+pub fn mm_free(addr &u8) Errno {
 	ap := &int(addr - 4)
 	size := u64(*ap) * u64(Linux_mem.page_size)
 
@@ -41,7 +41,7 @@ pub fn mem_copy(dest0 voidptr, src0 voidptr, n isize) voidptr {
 }
 
 @[unsafe]
-pub fn malloc(n isize) &byte {
+pub fn malloc(n isize) &u8 {
 	if n < 0 {
 		panic('malloc(<0)')
 	}
diff --git a/vlib/builtin/linux_bare/old/string_bare.v b/vlib/builtin/linux_bare/old/string_bare.v
@@ -2,17 +2,17 @@ module builtin
 
 pub struct string {
 pub:
-	str &byte
+	str &u8
 	len int
 }
 
-pub fn strlen(s &byte) int {
+pub fn strlen(s &u8) int {
 	mut i := 0
 	for ; s[i] != 0; i++ {}
 	return i
 }
 
-pub fn tos(s &byte, len int) string {
+pub fn tos(s &u8, len int) string {
 	if s == 0 {
 		panic('tos(): nil string')
 	}
@@ -49,7 +49,7 @@ pub fn tos_clone(s byteptr) string {
 
 // Same as `tos`, but calculates the length. Called by `string(bytes)` casts.
 // Used only internally.
-pub fn tos2(s &byte) string {
+pub fn tos2(s &u8) string {
 	if s == 0 {
 		panic('tos2: nil string')
 	}
@@ -85,7 +85,7 @@ pub fn string_ne(s1 string, s2 string) bool {
 	return !string_eq(s1, s2)
 }
 
-pub fn i64_tos(buf &byte, len int, n0 i64, base int) string {
+pub fn i64_tos(buf &u8, len int, n0 i64, base int) string {
 	if base < 2 {
 		panic('base must be >= 2')
 	}
diff --git a/vlib/builtin/map.c.v b/vlib/builtin/map.c.v
@@ -1,6 +1,6 @@
 module builtin
 
-fn C.wyhash(&byte, u64, u64, &u64) u64
+fn C.wyhash(&u8, u64, u64, &u64) u64
 
 fn C.wyhash64(u64, u64) u64
 
diff --git a/vlib/builtin/wasm_bare/libc_impl.c.v b/vlib/builtin/wasm_bare/libc_impl.c.v
@@ -105,11 +105,11 @@ fn memcmp(a &C.void, b &C.void, n usize) int {
 	return 0
 }
 
-fn vsprintf(str &char, format &char, ap &byte) int {
+fn vsprintf(str &char, format &char, ap &u8) int {
 	panic('vsprintf(): string interpolation is not supported in `-freestanding`')
 }
 
-fn vsnprintf(str &char, size usize, format &char, ap &byte) int {
+fn vsnprintf(str &char, size usize, format &char, ap &u8) int {
 	panic('vsnprintf(): string interpolation is not supported in `-freestanding`')
 }
 
@@ -119,17 +119,17 @@ enum Errno {
 }
 
 // not really needed
-fn bare_read(buf &byte, count u64) (i64, Errno) {
+fn bare_read(buf &u8, count u64) (i64, Errno) {
 	return 0, Errno.eerror
 }
 
-pub fn bare_print(buf &byte, len u64) {
+pub fn bare_print(buf &u8, len u64) {
 }
 
-fn bare_eprint(buf &byte, len u64) {
+fn bare_eprint(buf &u8, len u64) {
 }
 
-pub fn write(_fd i64, _buf &byte, _count u64) i64 {
+pub fn write(_fd i64, _buf &u8, _count u64) i64 {
 	return -1
 }
 
diff --git a/vlib/crypto/rand/rand_freebsd.c.v b/vlib/crypto/rand/rand_freebsd.c.v
@@ -6,7 +6,7 @@ module rand
 
 #include <stdlib.h>
 
-fn C.arc4random_buf(p &byte, n usize)
+fn C.arc4random_buf(p &u8, n usize)
 
 // read returns an array of `bytes_needed` random bytes read from the OS.
 pub fn read(bytes_needed int) ![]u8 {
diff --git a/vlib/crypto/rand/rand_openbsd.c.v b/vlib/crypto/rand/rand_openbsd.c.v
@@ -6,7 +6,7 @@ module rand
 
 #include <stdlib.h>
 
-fn C.arc4random_buf(p &byte, n usize)
+fn C.arc4random_buf(p &u8, n usize)
 
 // read returns an array of `bytes_needed` random bytes read from the OS.
 pub fn read(bytes_needed int) ![]u8 {
diff --git a/vlib/crypto/rand/rand_solaris.c.v b/vlib/crypto/rand/rand_solaris.c.v
@@ -6,7 +6,7 @@ module rand
 
 #include <sys/random.h>
 
-fn C.getrandom(p &byte, n usize, flags u32) int
+fn C.getrandom(p &u8, n usize, flags u32) int
 
 const (
 	read_batch_size = 256
diff --git a/vlib/encoding/base32/base32.v b/vlib/encoding/base32/base32.v
@@ -351,7 +351,7 @@ fn (enc &Encoding) decode_(src_ []u8, mut dst []u8) !(int, bool) {
 
 // strip_newlines removes newline characters and returns the number
 // of non-newline characters copied to dst.
-// fn strip_newlines(mut dst []u8, src []byte) int {
+// fn strip_newlines(mut dst []u8, src []u8) int {
 // 	mut offset := 0
 // 	for b in src {
 // 		if b in [`\r`, `\n`] {
diff --git a/vlib/math/math_test.v b/vlib/math/math_test.v
@@ -1148,7 +1148,6 @@ fn test_maxof_minof() {
 	assert maxof[i32]() == 2147483647
 	assert maxof[i64]() == 9223372036854775807
 	assert maxof[u8]() == 255
-	assert maxof[byte]() == 255
 	assert maxof[u16]() == 65535
 	assert maxof[u32]() == 4294967295
 	assert maxof[u64]() == 18446744073709551615
@@ -1161,7 +1160,6 @@ fn test_maxof_minof() {
 	assert minof[i32]() == -2147483648
 	assert minof[i64]() == -9223372036854775807 - 1
 	assert minof[u8]() == 0
-	assert minof[byte]() == 0
 	assert minof[u16]() == 0
 	assert minof[u32]() == 0
 	assert minof[u64]() == 0
diff --git a/vlib/stbi/stbi.c.v b/vlib/stbi/stbi.c.v
@@ -188,7 +188,7 @@ fn C.stbi_write_bmp(filename &char, w int, h int, comp int, buffer &u8) int
 fn C.stbi_write_tga(filename &char, w int, h int, comp int, buffer &u8) int
 fn C.stbi_write_jpg(filename &char, w int, h int, comp int, buffer &u8, quality int) int
 
-// fn C.stbi_write_hdr(filename &char, w int, h int, comp int, buffer &byte) int // buffer &byte => buffer &f32
+// fn C.stbi_write_hdr(filename &char, w int, h int, comp int, buffer &u8) int // buffer &u8 => buffer &f32
 
 // stbi_write_png write on path a PNG file
 // row_stride_in_bytes is usually equal to: w * comp
@@ -222,7 +222,7 @@ pub fn stbi_write_jpg(path string, w int, h int, comp int, buf &u8, quality int)
 }
 
 /*
-pub fn stbi_write_hdr(path string, w int, h int, comp int, buf &byte) ! {
+pub fn stbi_write_hdr(path string, w int, h int, comp int, buf &u8) ! {
 	if 0 == C.stbi_write_hdr(&char(path.str), w , h , comp , buf){
 		return error('stbi_image failed to write hdr file to "$path"')
 	}
diff --git a/vlib/v/checker/assign.v b/vlib/v/checker/assign.v
@@ -537,7 +537,7 @@ or use an explicit `unsafe{ a[..] }`, if you do not want a copy of the slice.',
 			}
 			if node.op == .assign {
 				// `mut arr := [u8(1),2,3]`
-				// `arr = [byte(4),5,6]`
+				// `arr = [u8(4),5,6]`
 				left_info := left_sym.info as ast.Array
 				left_elem_type := c.table.unaliased_type(left_info.elem_type)
 				if left_type_unwrapped.nr_muls() == right_type_unwrapped.nr_muls()
diff --git a/vlib/v/tests/aliased_array_method_call_test.v b/vlib/v/tests/aliased_array_method_call_test.v
@@ -1,10 +1,10 @@
-fn get_bytes_array() []byte {
-	return [byte(97), 98, 99]
+fn get_bytes_array() []u8 {
+	return [u8(97), 98, 99]
 }
 
 fn test_element_aliased_array_method_call() {
 	assert get_bytes_array().bytestr() == 'abc'
 
-	arr := [byte(97), 98, 99]
+	arr := [u8(97), 98, 99]
 	assert arr.bytestr() == 'abc'
 }
diff --git a/vlib/v/tests/assign_array_of_aliases_test.v b/vlib/v/tests/assign_array_of_aliases_test.v
@@ -1,6 +1,6 @@
 fn test_assign_array_of_aliases() {
 	mut arr := [u8(1), 2, 3]
-	arr = [byte(4), 5, 6]
+	arr = [u8(4), 5, 6]
 
 	println(arr)
 	assert arr.len == 3
diff --git a/vlib/v/tests/check_init_value_for_arrays_of_option_test.v b/vlib/v/tests/check_init_value_for_arrays_of_option_test.v
@@ -32,7 +32,6 @@ fn test_primitives() {
 	check_init_value_for_arrays_of_option[i64]()
 
 	check_init_value_for_arrays_of_option[u8]()
-	check_init_value_for_arrays_of_option[byte]()
 	check_init_value_for_arrays_of_option[u16]()
 	check_init_value_for_arrays_of_option[u32]()
 	check_init_value_for_arrays_of_option[u64]()
diff --git a/vlib/v/tests/const_from_bytes_test.v b/vlib/v/tests/const_from_bytes_test.v
@@ -1,7 +1,7 @@
-type UUID = [16]byte
+type UUID = [16]u8
 
-const codec_test_uuid = UUID([byte(0x6b), 0xa7, 0xb8, 0x10, 0x9d, 0xad, 0x11, 0xd1, 0x80, 0xb4,
-	0x00, 0xc0, 0x4f, 0xd4, 0x30, 0xc8]!)
+const codec_test_uuid = UUID([u8(0x6b), 0xa7, 0xb8, 0x10, 0x9d, 0xad, 0x11, 0xd1, 0x80, 0xb4, 0x00,
+	0xc0, 0x4f, 0xd4, 0x30, 0xc8]!)
 
 fn test_const_from_bytes() {
 	println(codec_test_uuid)
diff --git a/vlib/v/tests/fn_call_mut_array_of_aliases_args_test.v b/vlib/v/tests/fn_call_mut_array_of_aliases_args_test.v
@@ -1,8 +1,8 @@
-fn f1(mut b []byte) string {
+fn f1(mut b []u8) string {
 	return '${b}'
 }
 
-fn f2(b []byte) string {
+fn f2(b []u8) string {
 	return '${b}'
 }
 
diff --git a/vlib/v/tests/fn_with_array_of_aliases_argument_test.v b/vlib/v/tests/fn_with_array_of_aliases_argument_test.v
@@ -11,7 +11,7 @@ fn (f Foo) show_array_of_u8(data []u8) string {
 }
 
 fn test_fn_with_array_of_aliases_argument() {
-	a := [byte(1), 2, 3]
+	a := [u8(1), 2, 3]
 
 	s1 := show_array_of_u8(a)
 	println(s1)
diff --git a/vlib/v/tests/typeof_simple_types_test.v b/vlib/v/tests/typeof_simple_types_test.v
@@ -27,7 +27,6 @@ fn test_typeof_for_builtin_int_types() {
 	assert typeof(u32(1)).name == 'u32'
 	assert typeof(u64(1)).name == 'u64'
 	//
-	assert typeof(byte(1)).name == 'byte'
 	assert typeof(char(1)).name == 'char'
 }
 
diff --git a/vlib/x/json2/encoder.v b/vlib/x/json2/encoder.v
@@ -429,8 +429,6 @@ fn (e &Encoder) encode_array[U](val []U, level int, mut wr io.Writer) ! {
 			e.encode_any(i64(val[i]), level + 1, mut wr)!
 		} $else $if U is u8 {
 			e.encode_any(u8(val[i]), level + 1, mut wr)!
-		} $else $if U is byte {
-			e.encode_any(u8(val[i]), level + 1, mut wr)!
 		} $else $if U is u16 {
 			e.encode_any(u16(val[i]), level + 1, mut wr)!
 		} $else $if U is u32 {
diff --git a/vlib/x/json2/json_module_compatibility_test/json_test.v b/vlib/x/json2/json_module_compatibility_test/json_test.v
@@ -176,11 +176,11 @@ fn test_encode_alias_struct() {
 }
 
 struct StByteArray {
-	ba []byte
+	ba []u8
 }
 
 fn test_byte_array() {
-	assert json.encode(StByteArray{ ba: [byte(1), 2, 3, 4, 5] }) == '{"ba":[1,2,3,4,5]}'
+	assert json.encode(StByteArray{ ba: [u8(1), 2, 3, 4, 5] }) == '{"ba":[1,2,3,4,5]}'
 }
 
 struct Bar {

Original file line number	Diff line number	Diff line change
`@@ -337,16 +337,16 @@ fn split_int_errno(rc_in u64) (i64, Errno) {`
`337`	`337`	`}`
`338`	`338`
`339`	`339`	`// 0 sys_read unsigned int fd char *buf size_t count`
`340`		`-pub fn sys_read(fd i64, buf &byte, count u64) (i64, Errno) {`
	`340`	`+pub fn sys_read(fd i64, buf &u8, count u64) (i64, Errno) {`
`341`	`341`	`return split_int_errno(sys_call3(0, u64(fd), u64(buf), count))`
`342`	`342`	`}`
`343`	`343`
`344`	`344`	`// 1 sys_write unsigned int fd, const char *buf, size_t count`
`345`		`-pub fn sys_write(fd i64, buf &byte, count u64) (i64, Errno) {`
	`345`	`+pub fn sys_write(fd i64, buf &u8, count u64) (i64, Errno) {`
`346`	`346`	`return split_int_errno(sys_call3(1, u64(fd), u64(buf), count))`
`347`	`347`	`}`
`348`	`348`
`349`		`-pub fn sys_open(filename &byte, flags i64, mode int) (i64, Errno) {`
	`349`	`+pub fn sys_open(filename &u8, flags i64, mode int) (i64, Errno) {`
`350`	`350`	`// 2 sys_open const char *filename int flags int mode`
`351`	`351`	`return split_int_errno(sys_call3(2, u64(filename), u64(flags), u64(mode)))`
`352`	`352`	`}`
`@@ -357,7 +357,7 @@ pub fn sys_close(fd i64) Errno {`
`357`	`357`	`}`
`358`	`358`
`359`	`359`	`// 9 sys_mmap unsigned long addr unsigned long len unsigned long prot unsigned long flags unsigned long fd unsigned long off`
`360`		`-pub fn sys_mmap(addr &byte, len u64, prot Mm_prot, flags Map_flags, fildes u64, off u64) (&byte, Errno) {`
	`360`	`+pub fn sys_mmap(addr &u8, len u64, prot Mm_prot, flags Map_flags, fildes u64, off u64) (&u8, Errno) {`
`361`	`361`	`rc := sys_call6(9, u64(addr), len, u64(prot), u64(flags), fildes, off)`
`362`	`362`	`a, e := split_int_errno(rc)`
`363`	`363`	`return &u8(a), e`
Original file line number	Diff line number	Diff line change
`@@ -11,7 +11,7 @@ pub fn mm_pages(size u64) u32 {`
`11`	`11`	`return u32(pages)`
`12`	`12`	`}`
`13`	`13`
`14`		`-pub fn mm_alloc(size u64) (&byte, Errno) {`
	`14`	`+pub fn mm_alloc(size u64) (&u8, Errno) {`
`15`	`15`	`pages := mm_pages(size)`
`16`	`16`	`n_bytes := u64(pages * u32(Linux_mem.page_size))`
`17`	`17`
`@@ -24,7 +24,7 @@ pub fn mm_alloc(size u64) (&byte, Errno) {`
`24`	`24`	`return &u8(0), e`
`25`	`25`	`}`
`26`	`26`
`27`		`-pub fn mm_free(addr &byte) Errno {`
	`27`	`+pub fn mm_free(addr &u8) Errno {`
`28`	`28`	`ap := &int(addr - 4)`
`29`	`29`	`size := u64(ap) u64(Linux_mem.page_size)`
`30`	`30`
`@@ -41,7 +41,7 @@ pub fn mem_copy(dest0 voidptr, src0 voidptr, n isize) voidptr {`
`41`	`41`	`}`
`42`	`42`
`43`	`43`	`@[unsafe]`
`44`		`-pub fn malloc(n isize) &byte {`
	`44`	`+pub fn malloc(n isize) &u8 {`
`45`	`45`	`if n < 0 {`
`46`	`46`	`panic('malloc(<0)')`
`47`	`47`	`}`
Original file line number	Diff line number	Diff line change
`@@ -2,17 +2,17 @@ module builtin`
`2`	`2`
`3`	`3`	`pub struct string {`
`4`	`4`	`pub:`
`5`		`- str &byte`
	`5`	`+ str &u8`
`6`	`6`	`len int`
`7`	`7`	`}`
`8`	`8`
`9`		`-pub fn strlen(s &byte) int {`
	`9`	`+pub fn strlen(s &u8) int {`
`10`	`10`	`mut i := 0`
`11`	`11`	`for ; s[i] != 0; i++ {}`
`12`	`12`	`return i`
`13`	`13`	`}`
`14`	`14`
`15`		`-pub fn tos(s &byte, len int) string {`
	`15`	`+pub fn tos(s &u8, len int) string {`
`16`	`16`	`if s == 0 {`
`17`	`17`	`panic('tos(): nil string')`
`18`	`18`	`}`
`@@ -49,7 +49,7 @@ pub fn tos_clone(s byteptr) string {`
`49`	`49`
`50`	`50`	// Same as `tos`, but calculates the length. Called by `string(bytes)` casts.
`51`	`51`	`// Used only internally.`
`52`		`-pub fn tos2(s &byte) string {`
	`52`	`+pub fn tos2(s &u8) string {`
`53`	`53`	`if s == 0 {`
`54`	`54`	`panic('tos2: nil string')`
`55`	`55`	`}`
`@@ -85,7 +85,7 @@ pub fn string_ne(s1 string, s2 string) bool {`
`85`	`85`	`return !string_eq(s1, s2)`
`86`	`86`	`}`
`87`	`87`
`88`		`-pub fn i64_tos(buf &byte, len int, n0 i64, base int) string {`
	`88`	`+pub fn i64_tos(buf &u8, len int, n0 i64, base int) string {`
`89`	`89`	`if base < 2 {`
`90`	`90`	`panic('base must be >= 2')`
`91`	`91`	`}`
Original file line number	Diff line number	Diff line change
`@@ -105,11 +105,11 @@ fn memcmp(a &C.void, b &C.void, n usize) int {`
`105`	`105`	`return 0`
`106`	`106`	`}`
`107`	`107`
`108`		`-fn vsprintf(str &char, format &char, ap &byte) int {`
	`108`	`+fn vsprintf(str &char, format &char, ap &u8) int {`
`109`	`109`	panic('vsprintf(): string interpolation is not supported in `-freestanding`')
`110`	`110`	`}`
`111`	`111`
`112`		`-fn vsnprintf(str &char, size usize, format &char, ap &byte) int {`
	`112`	`+fn vsnprintf(str &char, size usize, format &char, ap &u8) int {`
`113`	`113`	panic('vsnprintf(): string interpolation is not supported in `-freestanding`')
`114`	`114`	`}`
`115`	`115`
`@@ -119,17 +119,17 @@ enum Errno {`
`119`	`119`	`}`
`120`	`120`
`121`	`121`	`// not really needed`
`122`		`-fn bare_read(buf &byte, count u64) (i64, Errno) {`
	`122`	`+fn bare_read(buf &u8, count u64) (i64, Errno) {`
`123`	`123`	`return 0, Errno.eerror`
`124`	`124`	`}`
`125`	`125`
`126`		`-pub fn bare_print(buf &byte, len u64) {`
	`126`	`+pub fn bare_print(buf &u8, len u64) {`
`127`	`127`	`}`
`128`	`128`
`129`		`-fn bare_eprint(buf &byte, len u64) {`
	`129`	`+fn bare_eprint(buf &u8, len u64) {`
`130`	`130`	`}`
`131`	`131`
`132`		`-pub fn write(_fd i64, _buf &byte, _count u64) i64 {`
	`132`	`+pub fn write(_fd i64, _buf &u8, _count u64) i64 {`
`133`	`133`	`return -1`
`134`	`134`	`}`
`135`	`135`