Rename `try_copy_*` to `write_*`

2 files changed, 186 insertions, 186 deletions

diff --git a/base/runtime/error_checks.odin b/base/runtime/error_checks.odin
index df6cb9485..46a8f9b1d 100644
--- a/base/runtime/error_checks.odin
+++ b/base/runtime/error_checks.odin
@@ -204,10 +204,10 @@ when ODIN_NO_RTTI {
 		@(cold, no_instrumentation)
 		handle_error :: proc "odin" (file: string, line, column: i32, from, to: typeid) -> ! {
 			do_msg :: proc "contextless" (i: ^int, buf: []byte, file: string, line, column: i32, from, to: typeid) -> bool {
-				try_copy_string(i, buf, "Invalid type assertion from ") or_return
-				try_copy_typeid(i, buf, from)                           or_return
-				try_copy_string(i, buf, " to ")                         or_return
-				try_copy_typeid(i, buf, to)                             or_return
+				write_string(i, buf, "Invalid type assertion from ") or_return
+				write_typeid(i, buf, from)                           or_return
+				write_string(i, buf, " to ")                         or_return
+				write_typeid(i, buf, to)                             or_return
 				return true
 			}
 
@@ -285,13 +285,13 @@ when ODIN_NO_RTTI {
 		@(cold, no_instrumentation)
 		handle_error :: proc "odin" (file: string, line, column: i32, from, to: typeid, from_data: rawptr) -> ! {
 			do_msg :: proc "contextless" (i: ^int, buf: []byte, file: string, line, column: i32, from, to, actual: typeid) -> bool {
-				try_copy_string(i, buf, "Invalid type assertion from ") or_return
-				try_copy_typeid(i, buf, from)                           or_return
-				try_copy_string(i, buf, " to ")                         or_return
-				try_copy_typeid(i, buf, to)                             or_return
+				write_string(i, buf, "Invalid type assertion from ") or_return
+				write_typeid(i, buf, from)                           or_return
+				write_string(i, buf, " to ")                         or_return
+				write_typeid(i, buf, to)                             or_return
 				if actual != from {
-					try_copy_string(i, buf, ", actual type: ") or_return
-					try_copy_typeid(i, buf, actual)            or_return
+					write_string(i, buf, ", actual type: ") or_return
+					write_typeid(i, buf, actual)            or_return
 				}
 				return true
 			}
diff --git a/base/runtime/print.odin b/base/runtime/print.odin
index cc51394c8..2deb0f4b1 100644
--- a/base/runtime/print.odin
+++ b/base/runtime/print.odin
@@ -519,7 +519,7 @@ print_type :: #force_no_inline proc "contextless" (ti: ^Type_Info) {
 
 
 @(require_results)
-try_copy_string :: proc "contextless" (i: ^int, dst: []byte, src: string) -> bool {
+write_string :: proc "contextless" (i: ^int, dst: []byte, src: string) -> bool {
 	if i^ < len(dst) {
 		i^ += copy(dst[i^:], src)
 		return true
@@ -529,7 +529,7 @@ try_copy_string :: proc "contextless" (i: ^int, dst: []byte, src: string) -> boo
 
 
 @(require_results)
-try_copy_byte :: proc "contextless" (i: ^int, dst: []byte, src: byte) -> bool {
+write_byte :: proc "contextless" (i: ^int, dst: []byte, src: byte) -> bool {
 	if i^ < len(dst) {
 		dst[i^] = src
 		i^ += 1
@@ -540,7 +540,7 @@ try_copy_byte :: proc "contextless" (i: ^int, dst: []byte, src: byte) -> bool {
 
 
 @(require_results)
-try_copy_u64 :: proc "contextless" (j: ^int, dst: []byte, x: u64) -> bool {
+write_u64 :: proc "contextless" (j: ^int, dst: []byte, x: u64) -> bool {
 	if j^ < len(dst) {
 		b :: u64(10)
 		u := x
@@ -553,13 +553,13 @@ try_copy_u64 :: proc "contextless" (j: ^int, dst: []byte, x: u64) -> bool {
 		}
 		i -= 1; a[i] = _INTEGER_DIGITS_VAR[u % b]
 
-		return try_copy_string(j, dst, string(a[i:]))
+		return write_string(j, dst, string(a[i:]))
 	}
 	return false
 }
 
 @(require_results)
-try_copy_i64 :: proc "contextless" (j: ^int, dst: []byte, x: i64) -> bool {
+write_i64 :: proc "contextless" (j: ^int, dst: []byte, x: i64) -> bool {
 	if j^ < len(dst) {
 		b :: u64(10)
 		u := u64(abs(x))
@@ -576,33 +576,33 @@ try_copy_i64 :: proc "contextless" (j: ^int, dst: []byte, x: i64) -> bool {
 			i -= 1; a[i] = '-'
 		}
 
-		return try_copy_string(j, dst, string(a[i:]))
+		return write_string(j, dst, string(a[i:]))
 	}
 	return false
 }
 
 
 @(require_results)
-try_copy_caller_location :: #force_no_inline proc "contextless" (i: ^int, buf: []byte, loc: Source_Code_Location) -> bool {
-	try_copy_string(i, buf, loc.file_path) or_return
+write_caller_location :: #force_no_inline proc "contextless" (i: ^int, buf: []byte, loc: Source_Code_Location) -> bool {
+	write_string(i, buf, loc.file_path) or_return
 
 	when ODIN_ERROR_POS_STYLE == .Default {
-		try_copy_byte(i, buf, '(')           or_return
-		try_copy_u64 (i, buf, u64(loc.line)) or_return
+		write_byte(i, buf, '(')           or_return
+		write_u64 (i, buf, u64(loc.line)) or_return
 		if loc.column != 0 {
-			try_copy_byte(i, buf, ':')             or_return
-			try_copy_u64 (i, buf, u64(loc.column)) or_return
+			write_byte(i, buf, ':')             or_return
+			write_u64 (i, buf, u64(loc.column)) or_return
 		}
-		try_copy_byte(i, buf, ')') or_return
+		write_byte(i, buf, ')') or_return
 		return true
 	} else when ODIN_ERROR_POS_STYLE == .Unix {
-		try_copy_byte(i, buf, ':')           or_return
-		try_copy_u64 (i, buf, u64(loc.line)) or_return
+		write_byte(i, buf, ':')           or_return
+		write_u64 (i, buf, u64(loc.line)) or_return
 		if loc.column != 0 {
-			try_copy_byte(i, buf, ':')             or_return
-			try_copy_u64 (i, buf, u64(loc.column)) or_return
+			write_byte(i, buf, ':')             or_return
+			write_u64 (i, buf, u64(loc.column)) or_return
 		}
-		try_copy_byte(i, buf, ':') or_return
+		write_byte(i, buf, ':') or_return
 		return true
 	} else {
 		#panic("unhandled ODIN_ERROR_POS_STYLE")
@@ -610,19 +610,19 @@ try_copy_caller_location :: #force_no_inline proc "contextless" (i: ^int, buf: [
 }
 
 @(require_results)
-try_copy_typeid :: #force_no_inline proc "contextless" (i: ^int, buf: []byte, id: typeid) -> bool {
+write_typeid :: #force_no_inline proc "contextless" (i: ^int, buf: []byte, id: typeid) -> bool {
 	when ODIN_NO_RTTI {
 		if id == nil {
-			try_copy_string(i, buf, "nil") or_return
+			write_string(i, buf, "nil") or_return
 		} else {
-			try_copy_string(i, buf, "<unknown type>") or_return
+			write_string(i, buf, "<unknown type>") or_return
 		}
 	} else {
 		if id == nil {
-			try_copy_string(i, buf, "nil") or_return
+			write_string(i, buf, "nil") or_return
 		} else {
 			ti := type_info_of(id)
-			try_copy_write_type(i, buf, ti) or_return
+			write_write_type(i, buf, ti) or_return
 		}
 	}
 	return true
@@ -630,304 +630,304 @@ try_copy_typeid :: #force_no_inline proc "contextless" (i: ^int, buf: []byte, id
 
 
 @(require_results)
-try_copy_rune :: #force_no_inline proc "contextless" (i: ^int, buf: []byte, r: rune) -> (written: int, ok: bool) #no_bounds_check {
+write_rune :: #force_no_inline proc "contextless" (i: ^int, buf: []byte, r: rune) -> (written: int, ok: bool) #no_bounds_check {
 	RUNE_SELF :: 0x80
 
 	if r < RUNE_SELF {
-		try_copy_byte(i, buf,byte(r)) or_return
+		write_byte(i, buf,byte(r)) or_return
 		return 1, true
 	}
 
 	b, n := encode_rune(r)
 	prev := i^
-	try_copy_string(i, buf, string(b[:n])) or_return
+	write_string(i, buf, string(b[:n])) or_return
 	return i^ - prev, true
 }
 
 @(require_results)
-try_copy_encoded_rune :: #force_no_inline proc "contextless" (i: ^int, buf: []byte, r: rune) -> bool {
-	try_copy_byte(i, buf, '\'') or_return
+write_encoded_rune :: #force_no_inline proc "contextless" (i: ^int, buf: []byte, r: rune) -> bool {
+	write_byte(i, buf, '\'') or_return
 
 	switch r {
-	case '\a': try_copy_string(i, buf, "\\a") or_return
-	case '\b': try_copy_string(i, buf, "\\b") or_return
-	case '\e': try_copy_string(i, buf, "\\e") or_return
-	case '\f': try_copy_string(i, buf, "\\f") or_return
-	case '\n': try_copy_string(i, buf, "\\n") or_return
-	case '\r': try_copy_string(i, buf, "\\r") or_return
-	case '\t': try_copy_string(i, buf, "\\t") or_return
-	case '\v': try_copy_string(i, buf, "\\v") or_return
+	case '\a': write_string(i, buf, "\\a") or_return
+	case '\b': write_string(i, buf, "\\b") or_return
+	case '\e': write_string(i, buf, "\\e") or_return
+	case '\f': write_string(i, buf, "\\f") or_return
+	case '\n': write_string(i, buf, "\\n") or_return
+	case '\r': write_string(i, buf, "\\r") or_return
+	case '\t': write_string(i, buf, "\\t") or_return
+	case '\v': write_string(i, buf, "\\v") or_return
 	case:
 		if r <= 0 {
-			try_copy_string(i, buf, "\\x00") or_return
+			write_string(i, buf, "\\x00") or_return
 		} else if r < 32 {
 			n0, n1 := u8(r) >> 4, u8(r) & 0xf
-			try_copy_string(i, buf, "\\x")                   or_return
-			try_copy_byte  (i, buf, _INTEGER_DIGITS_VAR[n0]) or_return
-			try_copy_byte  (i, buf, _INTEGER_DIGITS_VAR[n1]) or_return
+			write_string(i, buf, "\\x")                   or_return
+			write_byte  (i, buf, _INTEGER_DIGITS_VAR[n0]) or_return
+			write_byte  (i, buf, _INTEGER_DIGITS_VAR[n1]) or_return
 		} else {
-			_ = try_copy_rune(i, buf, r) or_return
+			_ = write_rune(i, buf, r) or_return
 		}
 	}
 
-	try_copy_byte(i, buf, '\'') or_return
+	write_byte(i, buf, '\'') or_return
 	return true
 }
 
 @(optimization_mode="favor_size")
-try_copy_write_type :: #force_no_inline proc "contextless" (i: ^int, buf: []byte, ti: ^Type_Info) -> bool {
+write_write_type :: #force_no_inline proc "contextless" (i: ^int, buf: []byte, ti: ^Type_Info) -> bool {
 	if ti == nil {
-		try_copy_string(i, buf, "nil") or_return
+		write_string(i, buf, "nil") or_return
 		return true
 	}
 
 	switch info in ti.variant {
 	case Type_Info_Named:
-		try_copy_string(i, buf, info.name) or_return
+		write_string(i, buf, info.name) or_return
 	case Type_Info_Integer:
 		switch ti.id {
-		case int:     try_copy_string(i, buf, "int")     or_return
-		case uint:    try_copy_string(i, buf, "uint")    or_return
-		case uintptr: try_copy_string(i, buf, "uintptr") or_return
+		case int:     write_string(i, buf, "int")     or_return
+		case uint:    write_string(i, buf, "uint")    or_return
+		case uintptr: write_string(i, buf, "uintptr") or_return
 		case:
-			try_copy_byte(i, buf, 'i' if info.signed else 'u') or_return
-			try_copy_u64 (i, buf, u64(8*ti.size))              or_return
+			write_byte(i, buf, 'i' if info.signed else 'u') or_return
+			write_u64 (i, buf, u64(8*ti.size))              or_return
 		}
 		switch info.endianness {
 		case .Platform: // nothing
-		case .Little:   try_copy_string(i, buf, "le") or_return
-		case .Big:      try_copy_string(i, buf, "be") or_return
+		case .Little:   write_string(i, buf, "le") or_return
+		case .Big:      write_string(i, buf, "be") or_return
 		}
 
 	case Type_Info_Rune:
-		try_copy_string(i, buf, "rune") or_return
+		write_string(i, buf, "rune") or_return
 	case Type_Info_Float:
-		try_copy_byte(i, buf, 'f') or_return
-		try_copy_u64(i, buf, u64(8*ti.size)) or_return
+		write_byte(i, buf, 'f') or_return
+		write_u64(i, buf, u64(8*ti.size)) or_return
 		switch info.endianness {
 		case .Platform: // nothing
-		case .Little:   try_copy_string(i, buf, "le") or_return
-		case .Big:      try_copy_string(i, buf, "be") or_return
+		case .Little:   write_string(i, buf, "le") or_return
+		case .Big:      write_string(i, buf, "be") or_return
 		}
 
 	case Type_Info_Complex:
-		try_copy_string(i, buf, "complex")      or_return
-		try_copy_u64   (i, buf, u64(8*ti.size)) or_return
+		write_string(i, buf, "complex")      or_return
+		write_u64   (i, buf, u64(8*ti.size)) or_return
 	case Type_Info_Quaternion:
-		try_copy_string(i, buf, "quaternion")   or_return
-		try_copy_u64   (i, buf, u64(8*ti.size)) or_return
+		write_string(i, buf, "quaternion")   or_return
+		write_u64   (i, buf, u64(8*ti.size)) or_return
 	case Type_Info_String:
 		if info.is_cstring {
-			try_copy_byte(i, buf, 'c') or_return
+			write_byte(i, buf, 'c') or_return
 		}
-		try_copy_string(i, buf, "string") or_return
+		write_string(i, buf, "string") or_return
 		switch info.encoding {
 		case .UTF_8:  /**/
-		case .UTF_16: try_copy_string(i, buf, "16") or_return
+		case .UTF_16: write_string(i, buf, "16") or_return
 		}
 	case Type_Info_Boolean:
 		switch ti.id {
-		case bool: try_copy_string(i, buf, "bool") or_return
+		case bool: write_string(i, buf, "bool") or_return
 		case:
-			try_copy_byte(i, buf, 'b')            or_return
-			try_copy_u64 (i, buf, u64(8*ti.size)) or_return
+			write_byte(i, buf, 'b')            or_return
+			write_u64 (i, buf, u64(8*ti.size)) or_return
 		}
 	case Type_Info_Any:
-		try_copy_string(i, buf, "any") or_return
+		write_string(i, buf, "any") or_return
 	case Type_Info_Type_Id:
-		try_copy_string(i, buf, "typeid") or_return
+		write_string(i, buf, "typeid") or_return
 
 	case Type_Info_Pointer:
 		if info.elem == nil {
-			try_copy_string(i, buf, "rawptr") or_return
+			write_string(i, buf, "rawptr") or_return
 		} else {
-			try_copy_string    (i, buf, "^")       or_return
-			try_copy_write_type(i, buf, info.elem) or_return
+			write_string    (i, buf, "^")       or_return
+			write_write_type(i, buf, info.elem) or_return
 		}
 	case Type_Info_Multi_Pointer:
-		try_copy_string    (i, buf, "[^]")     or_return
-		try_copy_write_type(i, buf, info.elem) or_return
+		write_string    (i, buf, "[^]")     or_return
+		write_write_type(i, buf, info.elem) or_return
 	case Type_Info_Soa_Pointer:
-		try_copy_string    (i, buf, "#soa ^")  or_return
-		try_copy_write_type(i, buf, info.elem) or_return
+		write_string    (i, buf, "#soa ^")  or_return
+		write_write_type(i, buf, info.elem) or_return
 	case Type_Info_Procedure:
-		try_copy_string(i, buf, "proc") or_return
+		write_string(i, buf, "proc") or_return
 		if info.params == nil {
-			try_copy_string(i, buf, "()") or_return
+			write_string(i, buf, "()") or_return
 		} else {
 			t := info.params.variant.(Type_Info_Parameters)
-			try_copy_byte(i, buf, '(') or_return
+			write_byte(i, buf, '(') or_return
 			for t, j in t.types {
-				if j > 0 { try_copy_string(i, buf, ", ") or_return }
-				try_copy_write_type(i, buf, t) or_return
+				if j > 0 { write_string(i, buf, ", ") or_return }
+				write_write_type(i, buf, t) or_return
 			}
-			try_copy_string(i, buf, ")") or_return
+			write_string(i, buf, ")") or_return
 		}
 		if info.results != nil {
-			try_copy_string    (i, buf, " -> ")       or_return
-			try_copy_write_type(i, buf, info.results) or_return
+			write_string    (i, buf, " -> ")       or_return
+			write_write_type(i, buf, info.results) or_return
 		}
 	case Type_Info_Parameters:
 		count := len(info.names)
-		if count != 1 { try_copy_byte(i, buf, '(') or_return }
+		if count != 1 { write_byte(i, buf, '(') or_return }
 		for name, j in info.names {
-			if j > 0 { try_copy_string(i, buf, ", ") or_return }
+			if j > 0 { write_string(i, buf, ", ") or_return }
 
 			t := info.types[j]
 
 			if len(name) > 0 {
-				try_copy_string(i, buf, name) or_return
-				try_copy_string(i, buf, ": ") or_return
+				write_string(i, buf, name) or_return
+				write_string(i, buf, ": ") or_return
 			}
-			try_copy_write_type(i, buf, t) or_return
+			write_write_type(i, buf, t) or_return
 		}
-		if count != 1 { try_copy_string(i, buf, ")") or_return }
+		if count != 1 { write_string(i, buf, ")") or_return }
 
 	case Type_Info_Array:
-		try_copy_byte      (i, buf, '[')             or_return
-		try_copy_u64       (i, buf, u64(info.count)) or_return
-		try_copy_byte      (i, buf, ']')             or_return
-		try_copy_write_type(i, buf, info.elem)       or_return
+		write_byte      (i, buf, '[')             or_return
+		write_u64       (i, buf, u64(info.count)) or_return
+		write_byte      (i, buf, ']')             or_return
+		write_write_type(i, buf, info.elem)       or_return
 
 	case Type_Info_Enumerated_Array:
 		if info.is_sparse {
-			try_copy_string(i, buf, "#sparse") or_return
+			write_string(i, buf, "#sparse") or_return
 		}
-		try_copy_byte      (i, buf, '[')        or_return
-		try_copy_write_type(i, buf, info.index) or_return
-		try_copy_byte      (i, buf, ']')        or_return
-		try_copy_write_type(i, buf, info.elem)  or_return
+		write_byte      (i, buf, '[')        or_return
+		write_write_type(i, buf, info.index) or_return
+		write_byte      (i, buf, ']')        or_return
+		write_write_type(i, buf, info.elem)  or_return
 
 
 	case Type_Info_Dynamic_Array:
-		try_copy_string    (i, buf, "[dynamic]") or_return
-		try_copy_write_type(i, buf, info.elem)   or_return
+		write_string    (i, buf, "[dynamic]") or_return
+		write_write_type(i, buf, info.elem)   or_return
 	case Type_Info_Slice:
-		try_copy_string    (i, buf, "[]")      or_return
-		try_copy_write_type(i, buf, info.elem) or_return
+		write_string    (i, buf, "[]")      or_return
+		write_write_type(i, buf, info.elem) or_return
 
 	case Type_Info_Map:
-		try_copy_string    (i, buf, "map[")     or_return
-		try_copy_write_type(i, buf, info.key)   or_return
-		try_copy_byte      (i, buf, ']')        or_return
-		try_copy_write_type(i, buf, info.value) or_return
+		write_string    (i, buf, "map[")     or_return
+		write_write_type(i, buf, info.key)   or_return
+		write_byte      (i, buf, ']')        or_return
+		write_write_type(i, buf, info.value) or_return
 
 	case Type_Info_Struct:
 		switch info.soa_kind {
 		case .None: // Ignore
 		case .Fixed:
-			try_copy_string    (i, buf, "#soa[")            or_return
-			try_copy_u64       (i, buf, u64(info.soa_len))  or_return
-			try_copy_byte      (i, buf, ']')                or_return
-			try_copy_write_type(i, buf, info.soa_base_type) or_return
+			write_string    (i, buf, "#soa[")            or_return
+			write_u64       (i, buf, u64(info.soa_len))  or_return
+			write_byte      (i, buf, ']')                or_return
+			write_write_type(i, buf, info.soa_base_type) or_return
 			return true
 		case .Slice:
-			try_copy_string    (i, buf, "#soa[]")           or_return
-			try_copy_write_type(i, buf, info.soa_base_type) or_return
+			write_string    (i, buf, "#soa[]")           or_return
+			write_write_type(i, buf, info.soa_base_type) or_return
 			return true
 		case .Dynamic:
-			try_copy_string    (i, buf, "#soa[dynamic]")    or_return
-			try_copy_write_type(i, buf, info.soa_base_type) or_return
+			write_string    (i, buf, "#soa[dynamic]")    or_return
+			write_write_type(i, buf, info.soa_base_type) or_return
 			return true
 		}
 
-		try_copy_string(i, buf, "struct ") or_return
-		if .packed      in info.flags { try_copy_string(i, buf, "#packed ")      or_return }
-		if .raw_union   in info.flags { try_copy_string(i, buf, "#raw_union ")   or_return }
-		if .all_or_none in info.flags { try_copy_string(i, buf, "#all_or_none ") or_return }
+		write_string(i, buf, "struct ") or_return
+		if .packed      in info.flags { write_string(i, buf, "#packed ")      or_return }
+		if .raw_union   in info.flags { write_string(i, buf, "#raw_union ")   or_return }
+		if .all_or_none in info.flags { write_string(i, buf, "#all_or_none ") or_return }
 		if .align in info.flags {
-			try_copy_string(i, buf, "#align(")     or_return
-			try_copy_u64(i,    buf, u64(ti.align)) or_return
-			try_copy_string(i, buf, ") ")          or_return
+			write_string(i, buf, "#align(")     or_return
+			write_u64(i,    buf, u64(ti.align)) or_return
+			write_string(i, buf, ") ")          or_return
 		}
-		try_copy_byte(i, buf, '{') or_return
+		write_byte(i, buf, '{') or_return
 		for name, j in info.names[:info.field_count] {
-			if j > 0 { try_copy_string(i, buf, ", ") or_return }
-			try_copy_string    (i, buf, name)          or_return
-			try_copy_string    (i, buf, ": ")          or_return
-			try_copy_write_type(i, buf, info.types[j]) or_return
+			if j > 0 { write_string(i, buf, ", ") or_return }
+			write_string    (i, buf, name)          or_return
+			write_string    (i, buf, ": ")          or_return
+			write_write_type(i, buf, info.types[j]) or_return
 		}
-		try_copy_byte(i, buf, '}') or_return
+		write_byte(i, buf, '}') or_return
 
 	case Type_Info_Union:
-		try_copy_string(i, buf, "union ") or_return
+		write_string(i, buf, "union ") or_return
 		if info.custom_align {
-			try_copy_string(i, buf, "#align(")     or_return
-			try_copy_u64   (i, buf, u64(ti.align)) or_return
-			try_copy_string(i, buf, ") ")          or_return
+			write_string(i, buf, "#align(")     or_return
+			write_u64   (i, buf, u64(ti.align)) or_return
+			write_string(i, buf, ") ")          or_return
 		}
 		if info.no_nil {
-			try_copy_string(i, buf, "#no_nil ") or_return
+			write_string(i, buf, "#no_nil ") or_return
 		}
-		try_copy_byte(i, buf, '{') or_return
+		write_byte(i, buf, '{') or_return
 		for variant, j in info.variants {
-			if j > 0 { try_copy_string(i, buf, ", ") or_return }
-			try_copy_write_type(i, buf, variant) or_return
+			if j > 0 { write_string(i, buf, ", ") or_return }
+			write_write_type(i, buf, variant) or_return
 		}
-		try_copy_string(i, buf, "}") or_return
+		write_string(i, buf, "}") or_return
 
 	case Type_Info_Enum:
-		try_copy_string    (i, buf, "enum ")   or_return
-		try_copy_write_type(i, buf, info.base) or_return
-		try_copy_string    (i, buf, " {")      or_return
+		write_string    (i, buf, "enum ")   or_return
+		write_write_type(i, buf, info.base) or_return
+		write_string    (i, buf, " {")      or_return
 		for name, j in info.names {
-			if j > 0 { try_copy_string(i, buf, ", ") or_return }
-			try_copy_string(i, buf, name) or_return
+			if j > 0 { write_string(i, buf, ", ") or_return }
+			write_string(i, buf, name) or_return
 		}
-		try_copy_string(i, buf, "}") or_return
+		write_string(i, buf, "}") or_return
 
 	case Type_Info_Bit_Set:
-		try_copy_string(i, buf, "bit_set[") or_return
+		write_string(i, buf, "bit_set[") or_return
 
 		#partial switch elem in type_info_base(info.elem).variant {
 		case Type_Info_Enum:
-			try_copy_write_type(i, buf, info.elem) or_return
+			write_write_type(i, buf, info.elem) or_return
 		case Type_Info_Rune:
-			try_copy_encoded_rune(i, buf, rune(info.lower)) or_return
-			try_copy_string      (i, buf, "..")             or_return
-			try_copy_encoded_rune(i, buf, rune(info.upper)) or_return
+			write_encoded_rune(i, buf, rune(info.lower)) or_return
+			write_string      (i, buf, "..")             or_return
+			write_encoded_rune(i, buf, rune(info.upper)) or_return
 		case:
-			try_copy_i64   (i, buf, info.lower) or_return
-			try_copy_string(i, buf, "..")       or_return
-			try_copy_i64   (i, buf, info.upper) or_return
+			write_i64   (i, buf, info.lower) or_return
+			write_string(i, buf, "..")       or_return
+			write_i64   (i, buf, info.upper) or_return
 		}
 		if info.underlying != nil {
-			try_copy_string    (i, buf, "; ")            or_return
-			try_copy_write_type(i, buf, info.underlying) or_return
+			write_string    (i, buf, "; ")            or_return
+			write_write_type(i, buf, info.underlying) or_return
 		}
-		try_copy_byte(i, buf, ']') or_return
+		write_byte(i, buf, ']') or_return
 
 	case Type_Info_Bit_Field:
-		try_copy_string    (i, buf, "bit_field ")      or_return
-		try_copy_write_type(i, buf, info.backing_type) or_return
-		try_copy_string    (i, buf, " {")              or_return
+		write_string    (i, buf, "bit_field ")      or_return
+		write_write_type(i, buf, info.backing_type) or_return
+		write_string    (i, buf, " {")              or_return
 		for name, j in info.names[:info.field_count] {
-			if j > 0 { try_copy_string(i, buf, ", ") or_return }
-			try_copy_string    (i, buf, name)                   or_return
-			try_copy_string    (i, buf, ": ")                   or_return
-			try_copy_write_type(i, buf, info.types[j])          or_return
-			try_copy_string    (i, buf, " | ")                  or_return
-			try_copy_u64       (i, buf, u64(info.bit_sizes[j])) or_return
+			if j > 0 { write_string(i, buf, ", ") or_return }
+			write_string    (i, buf, name)                   or_return
+			write_string    (i, buf, ": ")                   or_return
+			write_write_type(i, buf, info.types[j])          or_return
+			write_string    (i, buf, " | ")                  or_return
+			write_u64       (i, buf, u64(info.bit_sizes[j])) or_return
 		}
-		try_copy_byte(i, buf, '}') or_return
+		write_byte(i, buf, '}') or_return
 
 
 	case Type_Info_Simd_Vector:
-		try_copy_string    (i, buf, "#simd[")        or_return
-		try_copy_u64       (i, buf, u64(info.count)) or_return
-		try_copy_byte      (i, buf, ']')             or_return
-		try_copy_write_type(i, buf, info.elem)       or_return
+		write_string    (i, buf, "#simd[")        or_return
+		write_u64       (i, buf, u64(info.count)) or_return
+		write_byte      (i, buf, ']')             or_return
+		write_write_type(i, buf, info.elem)       or_return
 
 	case Type_Info_Matrix:
 		if info.layout == .Row_Major {
-			try_copy_string(i, buf, "#row_major ") or_return
-		}
-		try_copy_string    (i, buf, "matrix[")              or_return
-		try_copy_u64       (i, buf, u64(info.row_count))    or_return
-		try_copy_string    (i, buf, ", ")                   or_return
-		try_copy_u64       (i, buf, u64(info.column_count)) or_return
-		try_copy_string    (i, buf, "]")                    or_return
-		try_copy_write_type(i, buf, info.elem)              or_return
+			write_string(i, buf, "#row_major ") or_return
+		}
+		write_string    (i, buf, "matrix[")              or_return
+		write_u64       (i, buf, u64(info.row_count))    or_return
+		write_string    (i, buf, ", ")                   or_return
+		write_u64       (i, buf, u64(info.column_count)) or_return
+		write_string    (i, buf, "]")                    or_return
+		write_write_type(i, buf, info.elem)              or_return
 	}
 	return true
 }
\ No newline at end of file