Strip even more semicolons if followed by a `}` or `)` on the same line

core/encoding/base64/base64.odin

@@ -53,8 +53,8 @@ encode :: proc(data: []byte, ENC_TBL := ENC_TABLE, allocator := context.allocato
     for i, d := 0, 0; i < length; i, d = i + 3, d + 4 {
         c0, c1, c2 = int(data[i]), -1, -1
 
-        if i + 1 < length { c1 = int(data[i + 1]); }
-        if i + 2 < length { c2 = int(data[i + 2]); }
+        if i + 1 < length { c1 = int(data[i + 1]) }
+        if i + 2 < length { c2 = int(data[i + 2]) }
 
         block = (c0 << 16) | (max(c1, 0) << 8) | max(c2, 0)
 

core/encoding/json/marshal.odin

@@ -163,7 +163,7 @@ marshal_arg :: proc(b: ^strings.Builder, v: any) -> Marshal_Error {
 	case runtime.Type_Info_Array:
 		strings.write_byte(b, '[')
 		for i in 0..<info.count {
-			if i > 0 { strings.write_string(b, ", "); }
+			if i > 0 { strings.write_string(b, ", ") }
 
 			data := uintptr(v.data) + uintptr(i*info.elem_size)
 			marshal_arg(b, any{rawptr(data), info.elem.id})
@@ -174,7 +174,7 @@ marshal_arg :: proc(b: ^strings.Builder, v: any) -> Marshal_Error {
 		strings.write_byte(b, '[')
 		array := cast(^mem.Raw_Dynamic_Array)v.data
 		for i in 0..<array.len {
-			if i > 0 { strings.write_string(b, ", "); }
+			if i > 0 { strings.write_string(b, ", ") }
 
 			data := uintptr(array.data) + uintptr(i*info.elem_size)
 			marshal_arg(b, any{rawptr(data), info.elem.id})
@@ -185,7 +185,7 @@ marshal_arg :: proc(b: ^strings.Builder, v: any) -> Marshal_Error {
 		strings.write_byte(b, '[')
 		slice := cast(^mem.Raw_Slice)v.data
 		for i in 0..<slice.len {
-			if i > 0 { strings.write_string(b, ", "); }
+			if i > 0 { strings.write_string(b, ", ") }
 
 			data := uintptr(slice.data) + uintptr(i*info.elem_size)
 			marshal_arg(b, any{rawptr(data), info.elem.id})
@@ -207,7 +207,7 @@ marshal_arg :: proc(b: ^strings.Builder, v: any) -> Marshal_Error {
 			entry_size := ed.elem_size
 
 			for i in 0..<entries.len {
-				if i > 0 { strings.write_string(b, ", "); }
+				if i > 0 { strings.write_string(b, ", ") }
 
 				data := uintptr(entries.data) + uintptr(i*entry_size)
 				key   := rawptr(data + entry_type.offsets[2])
@@ -223,7 +223,7 @@ marshal_arg :: proc(b: ^strings.Builder, v: any) -> Marshal_Error {
 	case runtime.Type_Info_Struct:
 		strings.write_byte(b, '{')
 		for name, i in info.names {
-			if i > 0 { strings.write_string(b, ", "); }
+			if i > 0 { strings.write_string(b, ", ") }
 			strings.write_quoted_string(b, name)
 			strings.write_string(b, ": ")
 

core/fmt/fmt.odin

@@ -85,13 +85,13 @@ fprint_typeid :: proc(fd: os.Handle, id: typeid) -> int {
 }
 
 // print* procedures return the number of bytes written
-print   :: proc(args: ..any, sep := " ") -> int { return fprint(fd=os.stdout, args=args, sep=sep); }
-println :: proc(args: ..any, sep := " ") -> int { return fprintln(fd=os.stdout, args=args, sep=sep); }
-printf  :: proc(fmt: string, args: ..any) -> int { return fprintf(os.stdout, fmt, ..args); }
+print   :: proc(args: ..any, sep := " ") -> int { return fprint(fd=os.stdout, args=args, sep=sep) }
+println :: proc(args: ..any, sep := " ") -> int { return fprintln(fd=os.stdout, args=args, sep=sep) }
+printf  :: proc(fmt: string, args: ..any) -> int { return fprintf(os.stdout, fmt, ..args) }
 
-eprint   :: proc(args: ..any, sep := " ") -> int { return fprint(fd=os.stderr, args=args, sep=sep); }
-eprintln :: proc(args: ..any, sep := " ") -> int { return fprintln(fd=os.stderr, args=args, sep=sep); }
-eprintf  :: proc(fmt: string, args: ..any) -> int { return fprintf(os.stderr, fmt, ..args); }
+eprint   :: proc(args: ..any, sep := " ") -> int { return fprint(fd=os.stderr, args=args, sep=sep) }
+eprintln :: proc(args: ..any, sep := " ") -> int { return fprintln(fd=os.stderr, args=args, sep=sep) }
+eprintf  :: proc(fmt: string, args: ..any) -> int { return fprintf(os.stderr, fmt, ..args) }
 
 
 // aprint* procedures return a string that was allocated with the current context
@@ -688,9 +688,9 @@ _fmt_int :: proc(fi: ^Info, u: u64, base: int, is_signed: bool, bit_size: int, d
 	start := 0
 
 	flags: strconv.Int_Flags
-	if fi.hash && !fi.zero { flags |= {.Prefix}; }
-	if fi.plus             { flags |= {.Plus};   }
-	if fi.space            { flags |= {.Space};  }
+	if fi.hash && !fi.zero { flags |= {.Prefix} }
+	if fi.plus             { flags |= {.Plus}   }
+	if fi.space            { flags |= {.Space}  }
 	s := strconv.append_bits(buf[start:], u, base, is_signed, bit_size, digits, flags)
 
 	if fi.hash && fi.zero && fi.indent == 0 {
@@ -754,9 +754,9 @@ _fmt_int_128 :: proc(fi: ^Info, u: u128, base: int, is_signed: bool, bit_size: i
 	start := 0
 
 	flags: strconv.Int_Flags
-	if fi.hash && !fi.zero { flags |= {.Prefix}; }
-	if fi.plus             { flags |= {.Plus};   }
-	if fi.space            { flags |= {.Space};  }
+	if fi.hash && !fi.zero { flags |= {.Prefix} }
+	if fi.plus             { flags |= {.Plus}   }
+	if fi.space            { flags |= {.Space}  }
 	s := strconv.append_bits_128(buf[start:], u, base, is_signed, bit_size, digits, flags)
 
 	if fi.hash && fi.zero && fi.indent == 0 {
@@ -1154,19 +1154,19 @@ fmt_bit_set :: proc(fi: ^Info, v: any, name: string = "") {
 			bits = u128(x)
 		case 16:
 			x := (^u16)(v.data)^
-			if do_byte_swap { x = byte_swap(x); }
+			if do_byte_swap { x = byte_swap(x) }
 			bits = u128(x)
 		case 32:
 			x := (^u32)(v.data)^
-			if do_byte_swap { x = byte_swap(x); }
+			if do_byte_swap { x = byte_swap(x) }
 			bits = u128(x)
 		case 64:
 			x := (^u64)(v.data)^
-			if do_byte_swap { x = byte_swap(x); }
+			if do_byte_swap { x = byte_swap(x) }
 			bits = u128(x)
 		case 128:
 			x := (^u128)(v.data)^
-			if do_byte_swap { x = byte_swap(x); }
+			if do_byte_swap { x = byte_swap(x) }
 			bits = x
 		case: panic("unknown bit_size size")
 		}
@@ -1237,7 +1237,7 @@ fmt_write_array :: proc(fi: ^Info, array_data: rawptr, count: int, elem_size: in
 		}
 	} else {
 		for i in 0..<count {
-			if i > 0 { io.write_string(fi.writer, ", "); }
+			if i > 0 { io.write_string(fi.writer, ", ") }
 
 			data := uintptr(array_data) + uintptr(i*elem_size)
 			fmt_arg(fi, any{rawptr(data), elem_id}, verb)
@@ -1437,7 +1437,7 @@ fmt_value :: proc(fi: ^Info, v: any, verb: rune) {
 			}
 			defer {
 				if hash {
-					for in 0..<indent { io.write_byte(fi.writer, '\t'); }
+					for in 0..<indent { io.write_byte(fi.writer, '\t') }
 				}
 				io.write_byte(fi.writer, ']' if is_soa else '}')
 			}
@@ -1452,11 +1452,11 @@ fmt_value :: proc(fi: ^Info, v: any, verb: rune) {
 				}
 
 				for index in 0..<uintptr(b.soa_len) {
-					if !hash && index > 0 { io.write_string(fi.writer, ", "); }
+					if !hash && index > 0 { io.write_string(fi.writer, ", ") }
 
 					field_count := -1
 
-					if !hash && field_count > 0 { io.write_string(fi.writer, ", "); }
+					if !hash && field_count > 0 { io.write_string(fi.writer, ", ") }
 
 					io.write_string(fi.writer, base_type_name)
 					io.write_byte(fi.writer, '{')
@@ -1465,7 +1465,7 @@ fmt_value :: proc(fi: ^Info, v: any, verb: rune) {
 					for name, i in b.names {
 						field_count += 1
 
-						if !hash && field_count > 0 { io.write_string(fi.writer, ", "); }
+						if !hash && field_count > 0 { io.write_string(fi.writer, ", ") }
 						if hash {
 							fmt_write_indent(fi)
 						}
@@ -1482,7 +1482,7 @@ fmt_value :: proc(fi: ^Info, v: any, verb: rune) {
 							fmt_arg(fi, any{data, t.id}, 'v')
 						}
 
-						if hash { io.write_string(fi.writer, ",\n"); }
+						if hash { io.write_string(fi.writer, ",\n") }
 					}
 				}
 			} else {
@@ -1490,7 +1490,7 @@ fmt_value :: proc(fi: ^Info, v: any, verb: rune) {
 				for name, i in b.names {
 					field_count += 1
 
-					if !hash && field_count > 0 { io.write_string(fi.writer, ", "); }
+					if !hash && field_count > 0 { io.write_string(fi.writer, ", ") }
 					if hash {
 						fmt_write_indent(fi)
 					}
@@ -1505,7 +1505,7 @@ fmt_value :: proc(fi: ^Info, v: any, verb: rune) {
 						fmt_arg(fi, any{data, t.id}, 'v')
 					}
 
-					if hash { io.write_string(fi.writer, ",\n"); }
+					if hash { io.write_string(fi.writer, ",\n") }
 				}
 			}
 
@@ -1652,7 +1652,7 @@ fmt_value :: proc(fi: ^Info, v: any, verb: rune) {
 			io.write_byte(fi.writer, '[')
 			defer io.write_byte(fi.writer, ']')
 			for i in 0..<info.count {
-				if i > 0 { io.write_string(fi.writer, ", "); }
+				if i > 0 { io.write_string(fi.writer, ", ") }
 
 				idx, ok := stored_enum_value_to_string(info.index, info.min_value, i)
 				if ok {
@@ -1683,7 +1683,7 @@ fmt_value :: proc(fi: ^Info, v: any, verb: rune) {
 		io.write_byte(fi.writer, '<')
 		defer io.write_byte(fi.writer, '>')
 		for i in 0..<info.count {
-			if i > 0 { io.write_string(fi.writer, ", "); }
+			if i > 0 { io.write_string(fi.writer, ", ") }
 
 			data := uintptr(v.data) + uintptr(i*info.elem_size)
 			fmt_arg(fi, any{rawptr(data), info.elem.id}, verb)
@@ -1721,7 +1721,7 @@ fmt_value :: proc(fi: ^Info, v: any, verb: rune) {
 			entry_size := ed.elem_size
 
 			for i in 0..<entries.len {
-				if i > 0 { io.write_string(fi.writer, ", "); }
+				if i > 0 { io.write_string(fi.writer, ", ") }
 
 				data := uintptr(entries.data) + uintptr(i*entry_size)
 
@@ -1751,7 +1751,7 @@ fmt_value :: proc(fi: ^Info, v: any, verb: rune) {
 		// fi.hash = false;
 
 
-		if hash	{ io.write_byte(fi.writer, '\n'); }
+		if hash	{ io.write_byte(fi.writer, '\n') }
 
 		if is_soa {
 			fi.indent += 1
@@ -1780,11 +1780,11 @@ fmt_value :: proc(fi: ^Info, v: any, verb: rune) {
 
 
 			for index in 0..<n {
-				if !hash && index > 0 { io.write_string(fi.writer, ", "); }
+				if !hash && index > 0 { io.write_string(fi.writer, ", ") }
 
 				field_count := -1
 
-				if !hash && field_count > 0 { io.write_string(fi.writer, ", "); }
+				if !hash && field_count > 0 { io.write_string(fi.writer, ", ") }
 
 				io.write_string(fi.writer, base_type_name)
 				io.write_byte(fi.writer, '{')
@@ -1794,7 +1794,7 @@ fmt_value :: proc(fi: ^Info, v: any, verb: rune) {
 					name := info.names[i]
 					field_count += 1
 
-					if !hash && field_count > 0 { io.write_string(fi.writer, ", "); }
+					if !hash && field_count > 0 { io.write_string(fi.writer, ", ") }
 					if hash {
 						fmt_write_indent(fi)
 					}
@@ -1823,7 +1823,7 @@ fmt_value :: proc(fi: ^Info, v: any, verb: rune) {
 						}
 					}
 
-					if hash { io.write_string(fi.writer, ",\n"); }
+					if hash { io.write_string(fi.writer, ",\n") }
 				}
 			}
 		} else {
@@ -1831,7 +1831,7 @@ fmt_value :: proc(fi: ^Info, v: any, verb: rune) {
 			for name, i in info.names {
 				field_count += 1
 
-				if !hash && field_count > 0 { io.write_string(fi.writer, ", "); }
+				if !hash && field_count > 0 { io.write_string(fi.writer, ", ") }
 				if hash {
 					fmt_write_indent(fi)
 				}
@@ -1942,7 +1942,7 @@ fmt_value :: proc(fi: ^Info, v: any, verb: rune) {
 			defer io.write_byte(fi.writer, ']')
 
 			for i in 0..<len {
-				if i > 0 { io.write_string(fi.writer, ", "); }
+				if i > 0 { io.write_string(fi.writer, ", ") }
 
 				data := uintptr(ptr) + uintptr(i*slice_type.elem_size)
 				fmt_arg(fi, any{rawptr(data), slice_type.elem.id}, verb)

core/log/file_console_logger.odin

@@ -77,8 +77,8 @@ file_console_logger_proc :: proc(logger_data: rawptr, level: Level, text: string
 			t := time.now()
 			y, m, d := time.date(t)
 			h, min, s := time.clock(t)
-			if .Date in options { fmt.sbprintf(&buf, "%d-%02d-%02d ", y, m, d);    }
-			if .Time in options { fmt.sbprintf(&buf, "%02d:%02d:%02d", h, min, s); }
+			if .Date in options { fmt.sbprintf(&buf, "%d-%02d-%02d ", y, m, d)    }
+			if .Time in options { fmt.sbprintf(&buf, "%02d:%02d:%02d", h, min, s) }
 			fmt.sbprint(&buf, "] ")
 		}
 	}

core/math/big/common.odin

@@ -87,7 +87,7 @@ FACTORIAL_BINARY_SPLIT_MAX_RECURSIONS := 100
 */
 MATH_BIG_FORCE_64_BIT :: #config(MATH_BIG_FORCE_64_BIT, false)
 MATH_BIG_FORCE_32_BIT :: #config(MATH_BIG_FORCE_32_BIT, false)
-when (MATH_BIG_FORCE_32_BIT && MATH_BIG_FORCE_64_BIT) { #panic("Cannot force 32-bit and 64-bit big backend simultaneously."); }
+when (MATH_BIG_FORCE_32_BIT && MATH_BIG_FORCE_64_BIT) { #panic("Cannot force 32-bit and 64-bit big backend simultaneously.") }
 
 _LOW_MEMORY           :: #config(BIGINT_SMALL_MEMORY, false)
 when _LOW_MEMORY {

core/math/big/helpers.odin

@@ -56,7 +56,7 @@ int_copy :: proc(dest, src: ^Int, minimize := false, allocator := context.alloca
 	/*
 		If dest == src, do nothing
 	*/
-	if (dest == src) { return nil; }
+	if (dest == src) { return nil }
 
 	/*
 		Check that `src` is usable and `dest` isn't immutable.
@@ -383,7 +383,7 @@ assert_initialized :: proc(a: ^Int, loc := #caller_location) {
 
 zero_unused :: proc(dest: ^Int, old_used := -1) {
 	assert_if_nil(dest)
-	if ! #force_inline is_initialized(dest) { return; }
+	if ! #force_inline is_initialized(dest) { return }
 
 	#force_inline internal_zero_unused(dest, old_used)
 }
@@ -405,13 +405,13 @@ clear_if_uninitialized_multi :: proc(args: ..^Int, allocator := context.allocato
 clear_if_uninitialized :: proc {clear_if_uninitialized_single, clear_if_uninitialized_multi, }
 
 error_if_immutable_single :: proc(arg: ^Int) -> (err: Error) {
-	if arg != nil && .Immutable in arg.flags { return .Assignment_To_Immutable; }
+	if arg != nil && .Immutable in arg.flags { return .Assignment_To_Immutable }
 	return nil
 }
 
 error_if_immutable_multi :: proc(args: ..^Int) -> (err: Error) {
 	for i in args {
-		if i != nil && .Immutable in i.flags { return .Assignment_To_Immutable; }
+		if i != nil && .Immutable in i.flags { return .Assignment_To_Immutable }
 	}
 	return nil
 }
@@ -489,7 +489,7 @@ int_to_bytes_little :: proc(a: ^Int, buf: []u8, signed := false, allocator := co
 
 	size_in_bytes := int_to_bytes_size(a, signed, allocator) or_return
 	l := len(buf)
-	if size_in_bytes > l { return .Buffer_Overflow; }
+	if size_in_bytes > l { return .Buffer_Overflow }
 
 	size_in_bits := internal_count_bits(a)
 	i := 0
@@ -512,7 +512,7 @@ int_to_bytes_big :: proc(a: ^Int, buf: []u8, signed := false, allocator := conte
 
 	size_in_bytes := int_to_bytes_size(a, signed, allocator) or_return
 	l := len(buf)
-	if size_in_bytes > l { return .Buffer_Overflow; }
+	if size_in_bytes > l { return .Buffer_Overflow }
 
 	size_in_bits := internal_count_bits(a)
 	i := l - 1
@@ -534,11 +534,11 @@ int_to_bytes_big :: proc(a: ^Int, buf: []u8, signed := false, allocator := conte
 int_to_bytes_little_python :: proc(a: ^Int, buf: []u8, signed := false, allocator := context.allocator) -> (err: Error) {
 	assert_if_nil(a)
 
-	if !signed && a.sign == .Negative { return .Invalid_Argument; }
+	if !signed && a.sign == .Negative { return .Invalid_Argument }
 
 	l := len(buf)
 	size_in_bytes := int_to_bytes_size(a, signed, allocator) or_return
-	if size_in_bytes > l { return .Buffer_Overflow;  }
+	if size_in_bytes > l { return .Buffer_Overflow  }
 
 	if a.sign == .Negative {
 		t := &Int{}
@@ -570,12 +570,12 @@ int_to_bytes_little_python :: proc(a: ^Int, buf: []u8, signed := false, allocato
 int_to_bytes_big_python :: proc(a: ^Int, buf: []u8, signed := false, allocator := context.allocator) -> (err: Error) {
 	assert_if_nil(a)
 
-	if !signed && a.sign == .Negative { return .Invalid_Argument; }
-	if a.sign == .Zero_or_Positive    { return int_to_bytes_big(a, buf, signed, allocator); }
+	if !signed && a.sign == .Negative { return .Invalid_Argument }
+	if a.sign == .Zero_or_Positive    { return int_to_bytes_big(a, buf, signed, allocator) }
 
 	l := len(buf)
 	size_in_bytes := int_to_bytes_size(a, signed, allocator) or_return
-	if size_in_bytes > l { return .Buffer_Overflow;  }
+	if size_in_bytes > l { return .Buffer_Overflow  }
 
 	t := &Int{}
 	defer destroy(t)
@@ -601,7 +601,7 @@ int_from_bytes_big :: proc(a: ^Int, buf: []u8, signed := false, allocator := con
 	assert_if_nil(a)
 	buf := buf
 	l := len(buf)
-	if l == 0 { return .Invalid_Argument; }
+	if l == 0 { return .Invalid_Argument }
 
 	sign: Sign
 	size_in_bits := l * 8
@@ -638,7 +638,7 @@ int_from_bytes_big_python :: proc(a: ^Int, buf: []u8, signed := false, allocator
 	assert_if_nil(a)
 	buf := buf
 	l := len(buf)
-	if l == 0 { return .Invalid_Argument; }
+	if l == 0 { return .Invalid_Argument }
 
 	sign: Sign
 	size_in_bits := l * 8
@@ -684,7 +684,7 @@ int_from_bytes_little :: proc(a: ^Int, buf: []u8, signed := false, allocator :=
 	assert_if_nil(a)
 	buf := buf
 	l := len(buf)
-	if l == 0 { return .Invalid_Argument; }
+	if l == 0 { return .Invalid_Argument }
 
 	sign: Sign
 	size_in_bits   := l * 8
@@ -722,7 +722,7 @@ int_from_bytes_little_python :: proc(a: ^Int, buf: []u8, signed := false, alloca
 	assert_if_nil(a)
 	buf := buf
 	l := len(buf)
-	if l == 0 { return .Invalid_Argument; }
+	if l == 0 { return .Invalid_Argument }
 
 	sign: Sign
 	size_in_bits := l * 8

core/math/big/internal.odin

@@ -628,7 +628,7 @@ internal_int_mul :: proc(dest, src, multiplier: ^Int, allocator := context.alloc
 	/*
 		Early out for `multiplier` is zero; Set `dest` to zero.
 	*/
-	if multiplier.used == 0 || src.used == 0 { return internal_zero(dest); }
+	if multiplier.used == 0 || src.used == 0 { return internal_zero(dest) }
 
 	neg := src.sign != multiplier.sign
 
@@ -715,7 +715,7 @@ internal_sqr :: proc (dest, src: ^Int, allocator := context.allocator) -> (res:
 */
 internal_int_divmod :: proc(quotient, remainder, numerator, denominator: ^Int, allocator := context.allocator) -> (err: Error) {
 	context.allocator = allocator
-	if denominator.used == 0 { return .Division_by_Zero; }
+	if denominator.used == 0 { return .Division_by_Zero }
 	/*
 		If numerator < denominator then quotient = 0, remainder = numerator.
 	*/
@@ -757,7 +757,7 @@ internal_int_divmod_digit :: proc(quotient, numerator: ^Int, denominator: DIGIT,
 	/*
 		Cannot divide by zero.
 	*/
-	if denominator == 0 { return 0, .Division_by_Zero; }
+	if denominator == 0 { return 0, .Division_by_Zero }
 
 	/*
 		Quick outs.
@@ -854,7 +854,7 @@ internal_div :: proc { internal_int_div, }
 internal_int_mod :: proc(remainder, numerator, denominator: ^Int, allocator := context.allocator) -> (err: Error) {
 	#force_inline internal_int_divmod(nil, remainder, numerator, denominator, allocator) or_return
 
-	if remainder.used == 0 || denominator.sign == remainder.sign { return nil; }
+	if remainder.used == 0 || denominator.sign == remainder.sign { return nil }
 
 	return #force_inline internal_add(remainder, remainder, numerator, allocator)
 }
@@ -937,7 +937,7 @@ internal_int_factorial :: proc(res: ^Int, n: int, allocator := context.allocator
 	`res_gcd` and `res_lcm` can be nil or ^Int depending on which results are desired.
 */
 internal_int_gcd_lcm :: proc(res_gcd, res_lcm, a, b: ^Int, allocator := context.allocator) -> (err: Error) {
-	if res_gcd == nil && res_lcm == nil { return nil; }
+	if res_gcd == nil && res_lcm == nil { return nil }
 
 	return #force_inline _private_int_gcd_lcm(res_gcd, res_lcm, a, b, allocator)
 }
@@ -951,7 +951,7 @@ internal_int_mod_bits :: proc(remainder, numerator: ^Int, bits: int, allocator :
 	/*
 		Everything is divisible by 1 << 0 == 1, so this returns 0.
 	*/
-	if bits == 0 { return internal_zero(remainder); }
+	if bits == 0 { return internal_zero(remainder) }
 
 	/*
 		If the modulus is larger than the value, return the value.
@@ -1034,7 +1034,7 @@ internal_is_negative :: proc { internal_int_is_negative, }
 	Assumes `a` not to be `nil`.
 */
 internal_int_is_even :: #force_inline proc(a: ^Int) -> (even: bool) {
-	if internal_is_zero(a) { return true; }
+	if internal_is_zero(a) { return true }
 
 	/*
 		`a.used` > 0 here, because the above handled `is_zero`.
@@ -1062,23 +1062,23 @@ internal_int_is_power_of_two :: #force_inline proc(a: ^Int) -> (power_of_two: bo
 	/*
 		Early out for Int == 0.
 	*/
-	if #force_inline internal_is_zero(a) { return true; }
+	if #force_inline internal_is_zero(a) { return true }
 
 	/*
 		For an `Int` to be a power of two, its bottom limb has to be a power of two.
 	*/
-	if ! #force_inline platform_int_is_power_of_two(int(a.digit[a.used - 1])) { return false; }
+	if ! #force_inline platform_int_is_power_of_two(int(a.digit[a.used - 1])) { return false }
 
 	/*
 		We've established that the bottom limb is a power of two.
 		If it's the only limb, that makes the entire Int a power of two.
 	*/
-	if a.used == 1 { return true; }
+	if a.used == 1 { return true }
 
 	/*
 		For an `Int` to be a power of two, all limbs except the top one have to be zero.
 	*/
-	for i := 1; i < a.used && a.digit[i - 1] != 0; i += 1 { return false; }
+	for i := 1; i < a.used && a.digit[i - 1] != 0; i += 1 { return false }
 
 	return true
 }
@@ -1096,11 +1096,11 @@ internal_int_compare :: #force_inline proc(a, b: ^Int) -> (comparison: int) {
 	/*
 		Compare based on sign.
 	*/
-	if a.sign != b.sign { return -1 if a_is_negative else +1; }
+	if a.sign != b.sign { return -1 if a_is_negative else +1 }
 
 	/*
 		If `a` is negative, compare in the opposite direction */
-	if a_is_negative { return #force_inline internal_compare_magnitude(b, a); }
+	if a_is_negative { return #force_inline internal_compare_magnitude(b, a) }
 
 	return #force_inline internal_compare_magnitude(a, b)
 }
@@ -1186,20 +1186,20 @@ internal_int_is_square :: proc(a: ^Int, allocator := context.allocator) -> (squa
 	*/
 	square = false
 
-	if internal_is_negative(a)                                       { return; }
-	if internal_is_zero(a)                                           { return; }
+	if internal_is_negative(a)                                       { return }
+	if internal_is_zero(a)                                           { return }
 
 	/*
 		First check mod 128 (suppose that _DIGIT_BITS is at least 7).
 	*/
-	if _private_int_rem_128[127 & a.digit[0]] == 1                   { return; }
+	if _private_int_rem_128[127 & a.digit[0]] == 1                   { return }
 
 	/*
 		Next check mod 105 (3*5*7).
 	*/
 	c: DIGIT
 	c, err = internal_mod(a, 105)
-	if _private_int_rem_105[c] == 1                                  { return; }
+	if _private_int_rem_105[c] == 1                                  { return }
 
 	t := &Int{}
 	defer destroy(t)
@@ -1215,13 +1215,13 @@ internal_int_is_square :: proc(a: ^Int, allocator := context.allocator) -> (squa
 		free "t" so the easiest way is to goto LBL_ERR.  We know that err
 		is already equal to MP_OKAY from the mp_mod call
 	*/
-	if (1 << (r % 11) &      0x5C4) != 0                             { return; }
-	if (1 << (r % 13) &      0x9E4) != 0                             { return; }
-	if (1 << (r % 17) &     0x5CE8) != 0                             { return; }
-	if (1 << (r % 19) &    0x4F50C) != 0                             { return; }
-	if (1 << (r % 23) &   0x7ACCA0) != 0                             { return; }
-	if (1 << (r % 29) &  0xC2EDD0C) != 0                             { return; }
-	if (1 << (r % 31) & 0x6DE2B848) != 0                             { return; }
+	if (1 << (r % 11) &      0x5C4) != 0                             { return }
+	if (1 << (r % 13) &      0x9E4) != 0                             { return }
+	if (1 << (r % 17) &     0x5CE8) != 0                             { return }
+	if (1 << (r % 19) &    0x4F50C) != 0                             { return }
+	if (1 << (r % 23) &   0x7ACCA0) != 0                             { return }
+	if (1 << (r % 29) &  0xC2EDD0C) != 0                             { return }
+	if (1 << (r % 31) & 0x6DE2B848) != 0                             { return }
 
 	/*
 		Final check - is sqr(sqrt(arg)) == arg?
@@ -1243,20 +1243,20 @@ internal_int_is_square :: proc(a: ^Int, allocator := context.allocator) -> (squa
 	Assumes `a` to not be `nil` and have been iniialized.
 */
 internal_int_log :: proc(a: ^Int, base: DIGIT) -> (res: int, err: Error) {
-	if base < 2 || DIGIT(base) > _DIGIT_MAX { return -1, .Invalid_Argument; }
+	if base < 2 || DIGIT(base) > _DIGIT_MAX { return -1, .Invalid_Argument }
 
-	if internal_is_negative(a) { return -1, .Math_Domain_Error; }
-	if internal_is_zero(a)     { return -1, .Math_Domain_Error; }
+	if internal_is_negative(a) { return -1, .Math_Domain_Error }
+	if internal_is_zero(a)     { return -1, .Math_Domain_Error }
 
 	/*
 		Fast path for bases that are a power of two.
 	*/
-	if platform_int_is_power_of_two(int(base)) { return _private_log_power_of_two(a, base); }
+	if platform_int_is_power_of_two(int(base)) { return _private_log_power_of_two(a, base) }
 
 	/*
 		Fast path for `Int`s that fit within a single `DIGIT`.
 	*/
-	if a.used == 1 { return internal_log(a.digit[0], DIGIT(base)); }
+	if a.used == 1 { return internal_log(a.digit[0], DIGIT(base)) }
 
 	return _private_int_log(a, base)
 
@@ -1270,12 +1270,12 @@ internal_digit_log :: proc(a: DIGIT, base: DIGIT) -> (log: int, err: Error) {
 		If the number is smaller than the base, it fits within a fraction.
 		Therefore, we return 0.
 	*/
-	if a  < base { return 0, nil; }
+	if a  < base { return 0, nil }
 
 	/*
 		If a number equals the base, the log is 1.
 	*/
-	if a == base { return 1, nil; }
+	if a == base { return 1, nil }
 
 	N := _WORD(a)
 	bracket_low  := _WORD(1)
@@ -1334,8 +1334,8 @@ internal_int_pow :: proc(dest, base: ^Int, power: int, allocator := context.allo
 			internal_zero(dest) or_return
 			return .Math_Domain_Error
 		}
-		if power == 0 { return  internal_one(dest); }
-		if power  > 0 { return internal_zero(dest); }
+		if power == 0 { return  internal_one(dest) }
+		if power  > 0 { return internal_zero(dest) }
 
 	}
 	if power < 0 {
@@ -1435,12 +1435,12 @@ internal_int_sqrt :: proc(dest, src: ^Int, allocator := context.allocator) -> (e
 	/*
 		Must be positive.
 	*/
-	if #force_inline internal_is_negative(src)  { return .Invalid_Argument; }
+	if #force_inline internal_is_negative(src)  { return .Invalid_Argument }
 
 	/*
 		Easy out. If src is zero, so is dest.
 	*/
-	if #force_inline internal_is_zero(src)      { return internal_zero(dest); }
+	if #force_inline internal_is_zero(src)      { return internal_zero(dest) }
 
 	/*
 		Set up temporaries.
@@ -1489,11 +1489,11 @@ internal_int_root_n :: proc(dest, src: ^Int, n: int, allocator := context.alloca
 	/*
 		Fast path for n == 2
 	*/
-	if n == 2 { return #force_inline internal_sqrt(dest, src); }
+	if n == 2 { return #force_inline internal_sqrt(dest, src) }
 
-	if n < 0 || n > int(_DIGIT_MAX) { return .Invalid_Argument; }
+	if n < 0 || n > int(_DIGIT_MAX) { return .Invalid_Argument }
 
-	if n & 1 == 0 && #force_inline internal_is_negative(src) { return .Invalid_Argument; }
+	if n & 1 == 0 && #force_inline internal_is_negative(src) { return .Invalid_Argument }
 
 	/*
 		Set up temporaries.
@@ -1576,8 +1576,8 @@ internal_int_root_n :: proc(dest, src: ^Int, n: int, allocator := context.alloca
 			 Number of rounds is at most log_2(root). If it is more it
 			 got stuck, so break out of the loop and do the rest manually.
 		*/
-		if ilog2 -= 1;    ilog2 == 0 { break; }
-		if internal_cmp(t1, t2) == 0 { break; }
+		if ilog2 -= 1;    ilog2 == 0 { break }
+		if internal_cmp(t1, t2) == 0 { break }
 
 		iterations += 1
 		if iterations == MAX_ITERATIONS_ROOT_N {
@@ -1615,7 +1615,7 @@ internal_int_root_n :: proc(dest, src: ^Int, n: int, allocator := context.alloca
 	for {
 		internal_pow(t2, t1, n) or_return
 	
-		if internal_cmp(t2, a) != 1 { break; }
+		if internal_cmp(t2, a) != 1 { break }
 		
 		internal_sub(t1, t1, DIGIT(1)) or_return
 
@@ -1712,7 +1712,7 @@ internal_int_copy :: proc(dest, src: ^Int, minimize := false, allocator := conte
 	/*
 		If dest == src, do nothing
 	*/
-	if (dest == src) { return nil; }
+	if (dest == src) { return nil }
 
 	internal_error_if_immutable(dest) or_return
 
@@ -1821,17 +1821,17 @@ internal_int_inverse_modulo :: proc(dest, a, b: ^Int, allocator := context.alloc
 	/*
 		For all n in N and n > 0, n = 0 mod 1.
 	*/
-	if internal_is_positive(a) && internal_cmp(b, 1) == 0 { return internal_zero(dest);	}
+	if internal_is_positive(a) && internal_cmp(b, 1) == 0 { return internal_zero(dest)	}
 
 	/*
 		`b` cannot be negative and has to be > 1
 	*/
-	if internal_is_negative(b) && internal_cmp(b, 1) != 1 { return .Invalid_Argument; }
+	if internal_is_negative(b) && internal_cmp(b, 1) != 1 { return .Invalid_Argument }
 
 	/*
 		If the modulus is odd we can use a faster routine instead.
 	*/
-	if internal_is_odd(b) { return _private_inverse_modulo_odd(dest, a, b); }
+	if internal_is_odd(b) { return _private_inverse_modulo_odd(dest, a, b) }
 
 	return _private_inverse_modulo(dest, a, b)
 }
@@ -1850,12 +1850,12 @@ internal_int_bitfield_extract :: proc(a: ^Int, offset, count: int) -> (res: _WOR
 	*/
 	if count == 1 {
 		limb := offset / _DIGIT_BITS
-		if limb < 0 || limb >= a.used  { return 0, .Invalid_Argument; }
+		if limb < 0 || limb >= a.used  { return 0, .Invalid_Argument }
 		i := _WORD(1 << _WORD((offset % _DIGIT_BITS)))
 		return 1 if ((_WORD(a.digit[limb]) & i) != 0) else 0, nil
 	}
 
-	if count > _WORD_BITS || count < 1 { return 0, .Invalid_Argument; }
+	if count > _WORD_BITS || count < 1 { return 0, .Invalid_Argument }
 
 	/*
 		There are 3 possible cases.
@@ -1880,7 +1880,7 @@ internal_int_bitfield_extract :: proc(a: ^Int, offset, count: int) -> (res: _WOR
 	res          = (_WORD(a.digit[limb]) >> uint(shift)) & mask
 
 	bits_left -= num_bits
-	if bits_left == 0 { return res, nil; }
+	if bits_left == 0 { return res, nil }
 
 	res_shift := num_bits
 	num_bits   = min(bits_left, _DIGIT_BITS)
@@ -1889,7 +1889,7 @@ internal_int_bitfield_extract :: proc(a: ^Int, offset, count: int) -> (res: _WOR
 	res |= (_WORD(a.digit[limb + 1]) & mask) << uint(res_shift)
 
 	bits_left -= num_bits
-	if bits_left == 0 { return res, nil; }
+	if bits_left == 0 { return res, nil }
 
 	mask     = (1 << uint(bits_left)) - 1
 	res_shift += _DIGIT_BITS
@@ -1908,7 +1908,7 @@ internal_int_bitfield_extract :: proc(a: ^Int, offset, count: int) -> (res: _WOR
 internal_int_shrink :: proc(a: ^Int) -> (err: Error) {
 	needed := max(_MIN_DIGIT_COUNT, a.used)
 
-	if a.used != needed { return internal_grow(a, needed, true); }
+	if a.used != needed { return internal_grow(a, needed, true) }
 	return nil
 }
 internal_shrink :: proc { internal_int_shrink, }
@@ -2006,7 +2006,7 @@ internal_nan :: proc { internal_int_nan, }
 internal_int_power_of_two :: proc(a: ^Int, power: int, allocator := context.allocator) -> (err: Error) {
 	context.allocator = allocator
 
-	if power < 0 || power > _MAX_BIT_COUNT { return .Invalid_Argument; }
+	if power < 0 || power > _MAX_BIT_COUNT { return .Invalid_Argument }
 
 	/*
 		Grow to accomodate the single bit.
@@ -2080,7 +2080,7 @@ internal_int_get :: proc(a: ^Int, $T: typeid) -> (res: T, err: Error) where intr
 		/*
 			Set the sign.
 		*/
-		if a.sign == .Negative { res = -res; }
+		if a.sign == .Negative { res = -res }
 	}
 	return
 }
@@ -2326,7 +2326,7 @@ internal_int_shrmod :: proc(quotient, remainder, numerator: ^Int, bits: int, all
 	context.allocator = allocator
 
 	bits := bits
-	if bits < 0 { return .Invalid_Argument; }
+	if bits < 0 { return .Invalid_Argument }
 
 	internal_copy(quotient, numerator) or_return
 
@@ -2387,12 +2387,12 @@ internal_shr :: proc { internal_int_shr, }
 internal_int_shr_digit :: proc(quotient: ^Int, digits: int, allocator := context.allocator) -> (err: Error) {
 	context.allocator = allocator
 
-	if digits <= 0 { return nil; }
+	if digits <= 0 { return nil }
 
 	/*
 		If digits > used simply zero and return.
 	*/
-	if digits > quotient.used { return internal_zero(quotient); }
+	if digits > quotient.used { return internal_zero(quotient) }
 
 	/*
 		Much like `int_shl_digit`, this is implemented using a sliding window,
@@ -2436,7 +2436,7 @@ internal_int_shl :: proc(dest, src: ^Int, bits: int, allocator := context.alloca
 
 	bits := bits
 
-	if bits < 0 { return .Invalid_Argument; }
+	if bits < 0 { return .Invalid_Argument }
 
 	internal_copy(dest, src) or_return
 
@@ -2487,7 +2487,7 @@ internal_shl :: proc { internal_int_shl, }
 internal_int_shl_digit :: proc(quotient: ^Int, digits: int, allocator := context.allocator) -> (err: Error) {
 	context.allocator = allocator
 
-	if digits <= 0 { return nil; }
+	if digits <= 0 { return nil }
 
 	/*
 		No need to shift a zero.
@@ -2527,7 +2527,7 @@ internal_count_bits :: proc(a: ^Int) -> (count: int) {
 	/*
 		Fast path for zero.
 	*/
-	if #force_inline internal_is_zero(a) { return {}; }
+	if #force_inline internal_is_zero(a) { return {} }
 	/*
 		Get the number of DIGITs and use it.
 	*/
@@ -2550,7 +2550,7 @@ internal_int_count_lsb :: proc(a: ^Int) -> (count: int, err: Error) {
 	/*
 		Easy out.
 	*/
-	if #force_inline internal_is_zero(a) { return {}, nil; }
+	if #force_inline internal_is_zero(a) { return {}, nil }
 
 	/*
 		Scan lower digits until non-zero.
@@ -2588,7 +2588,7 @@ internal_int_rand :: proc(dest: ^Int, bits: int, r: ^rnd.Rand = nil, allocator :
 
 	bits := bits
 
-	if bits <= 0 { return .Invalid_Argument; }
+	if bits <= 0 { return .Invalid_Argument }
 
 	digits := bits / _DIGIT_BITS
 	bits   %= _DIGIT_BITS
@@ -2632,7 +2632,7 @@ internal_clear_if_uninitialized_multi :: proc(args: ..^Int, allocator := context
 	for i in args {
 		if ! #force_inline internal_is_initialized(i) {
 			e := #force_inline internal_grow(i, _DEFAULT_DIGIT_COUNT)
-			if e != nil { err = e; }
+			if e != nil { err = e }
 		}
 	}
 	return err
@@ -2640,13 +2640,13 @@ internal_clear_if_uninitialized_multi :: proc(args: ..^Int, allocator := context
 internal_clear_if_uninitialized :: proc {internal_clear_if_uninitialized_single, internal_clear_if_uninitialized_multi, }
 
 internal_error_if_immutable_single :: proc(arg: ^Int) -> (err: Error) {
-	if arg != nil && .Immutable in arg.flags { return .Assignment_To_Immutable; }
+	if arg != nil && .Immutable in arg.flags { return .Assignment_To_Immutable }
 	return nil
 }
 
 internal_error_if_immutable_multi :: proc(args: ..^Int) -> (err: Error) {
 	for i in args {
-		if i != nil && .Immutable in i.flags { return .Assignment_To_Immutable; }
+		if i != nil && .Immutable in i.flags { return .Assignment_To_Immutable }
 	}
 	return nil
 }
@@ -2674,9 +2674,9 @@ internal_init_multi :: proc { internal_int_init_multi, }
 	Typically very fast.  Also fixes the sign if there are no more leading digits.
 */
 internal_clamp :: proc(a: ^Int) -> (err: Error) {
-	for a.used > 0 && a.digit[a.used - 1] == 0 { a.used -= 1; }
+	for a.used > 0 && a.digit[a.used - 1] == 0 { a.used -= 1 }
 
-	if #force_inline internal_is_zero(a) { a.sign = .Zero_or_Positive; }
+	if #force_inline internal_is_zero(a) { a.sign = .Zero_or_Positive }
 
 	return nil
 }

core/math/big/logical.odin

@@ -77,7 +77,7 @@ int_shrmod :: proc(quotient, remainder, numerator: ^Int, bits: int, allocator :=
 	assert_if_nil(quotient, numerator)
 	context.allocator = allocator
 
-	if err = internal_clear_if_uninitialized(quotient, numerator);  err != nil { return err; }
+	if err = internal_clear_if_uninitialized(quotient, numerator);  err != nil { return err }
 	return #force_inline internal_int_shrmod(quotient, remainder, numerator, bits)
 }
 shrmod :: proc { int_shrmod, }

core/math/big/prime.odin

@@ -183,7 +183,7 @@ internal_int_montgomery_setup :: proc(n: ^Int) -> (rho: DIGIT, err: Error) {
 		                  =>  2*(1) - (1)     = 1
 	*/
 	b := n.digit[0]
-	if b & 1 == 0 { return 0, .Invalid_Argument; }
+	if b & 1 == 0 { return 0, .Invalid_Argument }
 
 	x := (((b + 2) & 4) << 1) + b /* here x*a==1 mod 2**4 */
 	x *= 2 - (b * x)              /* here x*a==1 mod 2**8 */

core/math/big/private.odin

@@ -1088,7 +1088,7 @@ _private_int_div_school :: proc(quotient, remainder, numerator, denominator: ^In
 		Step 3. for i from n down to (t + 1).
 	*/
 	#no_bounds_check for i := n; i >= (t + 1); i -= 1 {
-		if (i > x.used) { continue; }
+		if (i > x.used) { continue }
 
 		/*
 			step 3.1 if xi == yt then set q{i-t-1} to b-1, otherwise set q{i-t-1} to (xi*b + x{i-1})/yt
@@ -1744,7 +1744,7 @@ _private_montgomery_reduce_comba :: proc(x, n: ^Int, rho: DIGIT, allocator := co
 	context.allocator = allocator
 	W: [_WARRAY]_WORD = ---
 
-	if x.used > _WARRAY { return .Invalid_Argument; }
+	if x.used > _WARRAY { return .Invalid_Argument }
 
 	/*
 		Get old used count.
@@ -2022,7 +2022,7 @@ _private_inverse_modulo_odd :: proc(dest, a, b: ^Int, allocator := context.alloc
 	/*
 		2. [modified] `b` must be odd.
 	*/
-	if internal_is_even(b) { return .Invalid_Argument; }
+	if internal_is_even(b) { return .Invalid_Argument }
 
 	/*
 		Init all our temps.
@@ -2042,7 +2042,7 @@ _private_inverse_modulo_odd :: proc(dest, a, b: ^Int, allocator := context.alloc
 	/*
 		If one of `x`, `y` is zero return an error!
 	*/
-	if internal_is_zero(x) || internal_is_zero(y) { return .Invalid_Argument; }
+	if internal_is_zero(x) || internal_is_zero(y) { return .Invalid_Argument }
 
 	/*
 		3. `u` = `x`, `v` = `y`, `A` = 1, `B` = 0, `C` = 0, `D` = 1
@@ -2122,7 +2122,7 @@ _private_inverse_modulo_odd :: proc(dest, a, b: ^Int, allocator := context.alloc
 		/*
 			If not zero goto step 4.
 		*/
-		if internal_is_zero(u) { break; }
+		if internal_is_zero(u) { break }
 	}
 
 	/*

core/math/big/public.odin

@@ -120,7 +120,7 @@ int_double :: proc(dest, src: ^Int, allocator := context.allocator) -> (err: Err
 	/*
 		Grow destination as required.
 	*/
-	if dest != src { grow(dest, src.used + 1) or_return; }
+	if dest != src { grow(dest, src.used + 1) or_return }
 
 	return #force_inline internal_int_shl1(dest, src)
 }
@@ -153,7 +153,7 @@ int_mul :: proc(dest, src, multiplier: ^Int, allocator := context.allocator) ->
 
 mul :: proc { int_mul, int_mul_digit, }
 
-sqr :: proc(dest, src: ^Int) -> (err: Error) { return mul(dest, src, src); }
+sqr :: proc(dest, src: ^Int) -> (err: Error) { return mul(dest, src, src) }
 
 /*
 	divmod.
@@ -165,7 +165,7 @@ int_divmod :: proc(quotient, remainder, numerator, denominator: ^Int, allocator
 	/*
 		Early out if neither of the results is wanted.
 	*/
-	if quotient == nil && remainder == nil { return nil; }
+	if quotient == nil && remainder == nil { return nil }
 	internal_clear_if_uninitialized(numerator, denominator) or_return
 
 	return #force_inline internal_divmod(quotient, remainder, numerator, denominator)
@@ -275,7 +275,7 @@ sqrmod :: proc { int_sqrmod, }
 
 
 int_factorial :: proc(res: ^Int, n: int, allocator := context.allocator) -> (err: Error) {
-	if n < 0 || n > FACTORIAL_MAX_N { return .Invalid_Argument; }
+	if n < 0 || n > FACTORIAL_MAX_N { return .Invalid_Argument }
 	assert_if_nil(res)
 
 	return #force_inline internal_int_factorial(res, n, allocator)
@@ -302,8 +302,8 @@ int_choose_digit :: proc(res: ^Int, n, k: int, allocator := context.allocator) -
 	assert_if_nil(res)
 	context.allocator = allocator
 
-	if n < 0 || n > FACTORIAL_MAX_N { return .Invalid_Argument; }
-	if k > n { return internal_zero(res); }
+	if n < 0 || n > FACTORIAL_MAX_N { return .Invalid_Argument }
+	if k > n { return internal_zero(res) }
 
 	/*
 		res = n! / (k! * (n - k)!)
@@ -326,7 +326,7 @@ choose :: proc { int_choose_digit, }
 	Function computing both GCD and (if target isn't `nil`) also LCM.
 */
 int_gcd_lcm :: proc(res_gcd, res_lcm, a, b: ^Int, allocator := context.allocator) -> (err: Error) {
-	if res_gcd == nil && res_lcm == nil { return nil; }
+	if res_gcd == nil && res_lcm == nil { return nil }
 	assert_if_nil(a, b)
 	context.allocator = allocator
 
@@ -359,7 +359,7 @@ int_mod_bits :: proc(remainder, numerator: ^Int, bits: int, allocator := context
 	context.allocator = allocator
 
 	internal_clear_if_uninitialized(remainder, numerator) or_return
-	if bits < 0 { return .Invalid_Argument; }
+	if bits < 0 { return .Invalid_Argument }
 
 	return #force_inline internal_int_mod_bits(remainder, numerator, bits)
 }
@@ -439,7 +439,7 @@ int_root_n :: proc(dest, src: ^Int, n: int, allocator := context.allocator) -> (
 	/*
 		Fast path for n == 2.
 	*/
-	if n == 2 { return sqrt(dest, src); }
+	if n == 2 { return sqrt(dest, src) }
 
 	assert_if_nil(dest, src)
 	/*
@@ -456,7 +456,7 @@ root_n :: proc { int_root_n, }
 */
 
 int_is_initialized :: proc(a: ^Int) -> bool {
-	if a == nil { return false; }
+	if a == nil { return false }
 
 	return #force_inline internal_int_is_initialized(a)
 }

core/math/big/radix.odin

@@ -244,7 +244,7 @@ int_atoi :: proc(res: ^Int, input: string, radix := i8(10), allocator := context
 		Make sure the radix is ok.
 	*/
 
-	if radix < 2 || radix > 64 { return .Invalid_Argument; }
+	if radix < 2 || radix > 64 { return .Invalid_Argument }
 
 	/*
 		Set the integer to the default of zero.
@@ -327,7 +327,7 @@ radix_size :: proc(a: ^Int, radix: i8, zero_terminate := false, allocator := con
 	a := a
 	assert_if_nil(a)
 
-	if radix < 2 || radix > 64                     { return -1, .Invalid_Argument; }
+	if radix < 2 || radix > 64                     { return -1, .Invalid_Argument }
 	clear_if_uninitialized(a) or_return
 
 	if internal_is_zero(a) {

core/math/big/test.odin

@@ -44,17 +44,17 @@ PyRes :: struct {
 	aa, bb, sum := &Int{}, &Int{}, &Int{}
 	defer internal_destroy(aa, bb, sum)
 
-	if err = atoi(aa, string(a), 16); err != nil { return PyRes{res=":add:atoi(a):", err=err}; }
-	if err = atoi(bb, string(b), 16); err != nil { return PyRes{res=":add:atoi(b):", err=err}; }
+	if err = atoi(aa, string(a), 16); err != nil { return PyRes{res=":add:atoi(a):", err=err} }
+	if err = atoi(bb, string(b), 16); err != nil { return PyRes{res=":add:atoi(b):", err=err} }
 	if bb.used == 1 {
-		if err = #force_inline internal_add(sum, aa, bb.digit[0]); err != nil { return PyRes{res=":add:add(sum,a,b):", err=err}; }	
+		if err = #force_inline internal_add(sum, aa, bb.digit[0]); err != nil { return PyRes{res=":add:add(sum,a,b):", err=err} }	
 	} else {
-		if err = #force_inline internal_add(sum, aa, bb); err != nil { return PyRes{res=":add:add(sum,a,b):", err=err}; }
+		if err = #force_inline internal_add(sum, aa, bb); err != nil { return PyRes{res=":add:add(sum,a,b):", err=err} }
 	}
 
 	r: cstring
 	r, err = int_itoa_cstring(sum, 16, context.temp_allocator)
-	if err != nil { return PyRes{res=":add:itoa(sum):", err=err}; }
+	if err != nil { return PyRes{res=":add:itoa(sum):", err=err} }
 	return PyRes{res = r, err = nil}
 }
 
@@ -65,17 +65,17 @@ PyRes :: struct {
 	aa, bb, sum := &Int{}, &Int{}, &Int{}
 	defer internal_destroy(aa, bb, sum)
 
-	if err = atoi(aa, string(a), 16); err != nil { return PyRes{res=":sub:atoi(a):", err=err}; }
-	if err = atoi(bb, string(b), 16); err != nil { return PyRes{res=":sub:atoi(b):", err=err}; }
+	if err = atoi(aa, string(a), 16); err != nil { return PyRes{res=":sub:atoi(a):", err=err} }
+	if err = atoi(bb, string(b), 16); err != nil { return PyRes{res=":sub:atoi(b):", err=err} }
 	if bb.used == 1 {
-		if err = #force_inline internal_sub(sum, aa, bb.digit[0]); err != nil { return PyRes{res=":sub:sub(sum,a,b):", err=err}; }
+		if err = #force_inline internal_sub(sum, aa, bb.digit[0]); err != nil { return PyRes{res=":sub:sub(sum,a,b):", err=err} }
 	} else {
-		if err = #force_inline internal_sub(sum, aa, bb); err != nil { return PyRes{res=":sub:sub(sum,a,b):", err=err}; }
+		if err = #force_inline internal_sub(sum, aa, bb); err != nil { return PyRes{res=":sub:sub(sum,a,b):", err=err} }
 	}
 
 	r: cstring
 	r, err = int_itoa_cstring(sum, 16, context.temp_allocator)
-	if err != nil { return PyRes{res=":sub:itoa(sum):", err=err}; }
+	if err != nil { return PyRes{res=":sub:itoa(sum):", err=err} }
 	return PyRes{res = r, err = nil}
 }
 
@@ -86,13 +86,13 @@ PyRes :: struct {
 	aa, bb, product := &Int{}, &Int{}, &Int{}
 	defer internal_destroy(aa, bb, product)
 
-	if err = atoi(aa, string(a), 16); err != nil { return PyRes{res=":mul:atoi(a):", err=err}; }
-	if err = atoi(bb, string(b), 16); err != nil { return PyRes{res=":mul:atoi(b):", err=err}; }
-	if err = #force_inline internal_mul(product, aa, bb); err != nil { return PyRes{res=":mul:mul(product,a,b):", err=err}; }
+	if err = atoi(aa, string(a), 16); err != nil { return PyRes{res=":mul:atoi(a):", err=err} }
+	if err = atoi(bb, string(b), 16); err != nil { return PyRes{res=":mul:atoi(b):", err=err} }
+	if err = #force_inline internal_mul(product, aa, bb); err != nil { return PyRes{res=":mul:mul(product,a,b):", err=err} }
 
 	r: cstring
 	r, err = int_itoa_cstring(product, 16, context.temp_allocator)
-	if err != nil { return PyRes{res=":mul:itoa(product):", err=err}; }
+	if err != nil { return PyRes{res=":mul:itoa(product):", err=err} }
 	return PyRes{res = r, err = nil}
 }
 
@@ -103,12 +103,12 @@ PyRes :: struct {
 	aa, square := &Int{}, &Int{}
 	defer internal_destroy(aa, square)
 
-	if err = atoi(aa, string(a), 16); err != nil { return PyRes{res=":sqr:atoi(a):", err=err}; }
-	if err = #force_inline internal_sqr(square, aa); err != nil { return PyRes{res=":sqr:sqr(square,a):", err=err}; }
+	if err = atoi(aa, string(a), 16); err != nil { return PyRes{res=":sqr:atoi(a):", err=err} }
+	if err = #force_inline internal_sqr(square, aa); err != nil { return PyRes{res=":sqr:sqr(square,a):", err=err} }
 
 	r: cstring
 	r, err = int_itoa_cstring(square, 16, context.temp_allocator)
-	if err != nil { return PyRes{res=":sqr:itoa(square):", err=err}; }
+	if err != nil { return PyRes{res=":sqr:itoa(square):", err=err} }
 	return PyRes{res = r, err = nil}
 }
 
@@ -122,13 +122,13 @@ PyRes :: struct {
 	aa, bb, quotient := &Int{}, &Int{}, &Int{}
 	defer internal_destroy(aa, bb, quotient)
 
-	if err = atoi(aa, string(a), 16); err != nil { return PyRes{res=":div:atoi(a):", err=err}; }
-	if err = atoi(bb, string(b), 16); err != nil { return PyRes{res=":div:atoi(b):", err=err}; }
-	if err = #force_inline internal_div(quotient, aa, bb); err != nil { return PyRes{res=":div:div(quotient,a,b):", err=err}; }
+	if err = atoi(aa, string(a), 16); err != nil { return PyRes{res=":div:atoi(a):", err=err} }
+	if err = atoi(bb, string(b), 16); err != nil { return PyRes{res=":div:atoi(b):", err=err} }
+	if err = #force_inline internal_div(quotient, aa, bb); err != nil { return PyRes{res=":div:div(quotient,a,b):", err=err} }
 
 	r: cstring
 	r, err = int_itoa_cstring(quotient, 16, context.temp_allocator)
-	if err != nil { return PyRes{res=":div:itoa(quotient):", err=err}; }
+	if err != nil { return PyRes{res=":div:itoa(quotient):", err=err} }
 	return PyRes{res = r, err = nil}
 }
 
@@ -144,8 +144,8 @@ PyRes :: struct {
 	aa := &Int{}
 	defer internal_destroy(aa)
 
-	if err = atoi(aa, string(a), 16); err != nil { return PyRes{res=":log:atoi(a):", err=err}; }
-	if l, err = #force_inline internal_log(aa, base); err != nil { return PyRes{res=":log:log(a, base):", err=err}; }
+	if err = atoi(aa, string(a), 16); err != nil { return PyRes{res=":log:atoi(a):", err=err} }
+	if l, err = #force_inline internal_log(aa, base); err != nil { return PyRes{res=":log:log(a, base):", err=err} }
 
 	#force_inline internal_zero(aa)
 	aa.digit[0] = DIGIT(l)  & _MASK
@@ -155,7 +155,7 @@ PyRes :: struct {
 
 	r: cstring
 	r, err = int_itoa_cstring(aa, 16, context.temp_allocator)
-	if err != nil { return PyRes{res=":log:itoa(res):", err=err}; }
+	if err != nil { return PyRes{res=":log:itoa(res):", err=err} }
 	return PyRes{res = r, err = nil}
 }
 
@@ -169,12 +169,12 @@ PyRes :: struct {
 	dest, bb := &Int{}, &Int{}
 	defer internal_destroy(dest, bb)
 
-	if err = atoi(bb, string(base), 16); err != nil { return PyRes{res=":pow:atoi(base):", err=err}; }
-	if err = #force_inline internal_pow(dest, bb, power); err != nil { return PyRes{res=":pow:pow(dest, base, power):", err=err}; }
+	if err = atoi(bb, string(base), 16); err != nil { return PyRes{res=":pow:atoi(base):", err=err} }
+	if err = #force_inline internal_pow(dest, bb, power); err != nil { return PyRes{res=":pow:pow(dest, base, power):", err=err} }
 
 	r: cstring
 	r, err = int_itoa_cstring(dest, 16, context.temp_allocator)
-	if err != nil { return PyRes{res=":log:itoa(res):", err=err}; }
+	if err != nil { return PyRes{res=":log:itoa(res):", err=err} }
 	return PyRes{res = r, err = nil}
 }
 
@@ -188,12 +188,12 @@ PyRes :: struct {
 	src := &Int{}
 	defer internal_destroy(src)
 
-	if err = atoi(src, string(source), 16); err != nil { return PyRes{res=":sqrt:atoi(src):", err=err}; }
-	if err = #force_inline internal_sqrt(src, src); err != nil { return PyRes{res=":sqrt:sqrt(src):", err=err}; }
+	if err = atoi(src, string(source), 16); err != nil { return PyRes{res=":sqrt:atoi(src):", err=err} }
+	if err = #force_inline internal_sqrt(src, src); err != nil { return PyRes{res=":sqrt:sqrt(src):", err=err} }
 
 	r: cstring
 	r, err = int_itoa_cstring(src, 16, context.temp_allocator)
-	if err != nil { return PyRes{res=":log:itoa(res):", err=err}; }
+	if err != nil { return PyRes{res=":log:itoa(res):", err=err} }
 	return PyRes{res = r, err = nil}
 }
 
@@ -207,12 +207,12 @@ PyRes :: struct {
 	src := &Int{}
 	defer internal_destroy(src)
 
-	if err = atoi(src, string(source), 16); err != nil { return PyRes{res=":root_n:atoi(src):", err=err}; }
-	if err = #force_inline internal_root_n(src, src, power); err != nil { return PyRes{res=":root_n:root_n(src):", err=err}; }
+	if err = atoi(src, string(source), 16); err != nil { return PyRes{res=":root_n:atoi(src):", err=err} }
+	if err = #force_inline internal_root_n(src, src, power); err != nil { return PyRes{res=":root_n:root_n(src):", err=err} }
 
 	r: cstring
 	r, err = int_itoa_cstring(src, 16, context.temp_allocator)
-	if err != nil { return PyRes{res=":root_n:itoa(res):", err=err}; }
+	if err != nil { return PyRes{res=":root_n:itoa(res):", err=err} }
 	return PyRes{res = r, err = nil}
 }
 
@@ -226,12 +226,12 @@ PyRes :: struct {
 	src := &Int{}
 	defer internal_destroy(src)
 
-	if err = atoi(src, string(source), 16); err != nil { return PyRes{res=":shr_digit:atoi(src):", err=err}; }
-	if err = #force_inline internal_shr_digit(src, digits); err != nil { return PyRes{res=":shr_digit:shr_digit(src):", err=err}; }
+	if err = atoi(src, string(source), 16); err != nil { return PyRes{res=":shr_digit:atoi(src):", err=err} }
+	if err = #force_inline internal_shr_digit(src, digits); err != nil { return PyRes{res=":shr_digit:shr_digit(src):", err=err} }
 
 	r: cstring
 	r, err = int_itoa_cstring(src, 16, context.temp_allocator)
-	if err != nil { return PyRes{res=":shr_digit:itoa(res):", err=err}; }
+	if err != nil { return PyRes{res=":shr_digit:itoa(res):", err=err} }
 	return PyRes{res = r, err = nil}
 }
 
@@ -245,12 +245,12 @@ PyRes :: struct {
 	src := &Int{}
 	defer internal_destroy(src)
 
-	if err = atoi(src, string(source), 16); err != nil { return PyRes{res=":shl_digit:atoi(src):", err=err}; }
-	if err = #force_inline internal_shl_digit(src, digits); err != nil { return PyRes{res=":shl_digit:shr_digit(src):", err=err}; }
+	if err = atoi(src, string(source), 16); err != nil { return PyRes{res=":shl_digit:atoi(src):", err=err} }
+	if err = #force_inline internal_shl_digit(src, digits); err != nil { return PyRes{res=":shl_digit:shr_digit(src):", err=err} }
 
 	r: cstring
 	r, err = int_itoa_cstring(src, 16, context.temp_allocator)
-	if err != nil { return PyRes{res=":shl_digit:itoa(res):", err=err}; }
+	if err != nil { return PyRes{res=":shl_digit:itoa(res):", err=err} }
 	return PyRes{res = r, err = nil}
 }
 
@@ -264,12 +264,12 @@ PyRes :: struct {
 	src := &Int{}
 	defer internal_destroy(src)
 
-	if err = atoi(src, string(source), 16); err != nil { return PyRes{res=":shr:atoi(src):", err=err}; }
-	if err = #force_inline internal_shr(src, src, bits); err != nil { return PyRes{res=":shr:shr(src, bits):", err=err}; }
+	if err = atoi(src, string(source), 16); err != nil { return PyRes{res=":shr:atoi(src):", err=err} }
+	if err = #force_inline internal_shr(src, src, bits); err != nil { return PyRes{res=":shr:shr(src, bits):", err=err} }
 
 	r: cstring
 	r, err = int_itoa_cstring(src, 16, context.temp_allocator)
-	if err != nil { return PyRes{res=":shr:itoa(res):", err=err}; }
+	if err != nil { return PyRes{res=":shr:itoa(res):", err=err} }
 	return PyRes{res = r, err = nil}
 }
 
@@ -283,12 +283,12 @@ PyRes :: struct {
 	src := &Int{}
 	defer internal_destroy(src)
 
-	if err = atoi(src, string(source), 16); err != nil { return PyRes{res=":shr_signed:atoi(src):", err=err}; }
-	if err = #force_inline internal_shr_signed(src, src, bits); err != nil { return PyRes{res=":shr_signed:shr_signed(src, bits):", err=err}; }
+	if err = atoi(src, string(source), 16); err != nil { return PyRes{res=":shr_signed:atoi(src):", err=err} }
+	if err = #force_inline internal_shr_signed(src, src, bits); err != nil { return PyRes{res=":shr_signed:shr_signed(src, bits):", err=err} }
 
 	r: cstring
 	r, err = int_itoa_cstring(src, 16, context.temp_allocator)
-	if err != nil { return PyRes{res=":shr_signed:itoa(res):", err=err}; }
+	if err != nil { return PyRes{res=":shr_signed:itoa(res):", err=err} }
 	return PyRes{res = r, err = nil}
 }
 
@@ -302,12 +302,12 @@ PyRes :: struct {
 	src := &Int{}
 	defer internal_destroy(src)
 
-	if err = atoi(src, string(source), 16); err != nil { return PyRes{res=":shl:atoi(src):", err=err}; }
-	if err = #force_inline internal_shl(src, src, bits); err != nil { return PyRes{res=":shl:shl(src, bits):", err=err}; }
+	if err = atoi(src, string(source), 16); err != nil { return PyRes{res=":shl:atoi(src):", err=err} }
+	if err = #force_inline internal_shl(src, src, bits); err != nil { return PyRes{res=":shl:shl(src, bits):", err=err} }
 
 	r: cstring
 	r, err = int_itoa_cstring(src, 16, context.temp_allocator)
-	if err != nil { return PyRes{res=":shl:itoa(res):", err=err}; }
+	if err != nil { return PyRes{res=":shl:itoa(res):", err=err} }
 	return PyRes{res = r, err = nil}
 }
 
@@ -321,11 +321,11 @@ PyRes :: struct {
 	dest := &Int{}
 	defer internal_destroy(dest)
 
-	if err = #force_inline internal_int_factorial(dest, n); err != nil { return PyRes{res=":factorial:factorial(n):", err=err}; }
+	if err = #force_inline internal_int_factorial(dest, n); err != nil { return PyRes{res=":factorial:factorial(n):", err=err} }
 
 	r: cstring
 	r, err = int_itoa_cstring(dest, 16, context.temp_allocator)
-	if err != nil { return PyRes{res=":factorial:itoa(res):", err=err}; }
+	if err != nil { return PyRes{res=":factorial:itoa(res):", err=err} }
 	return PyRes{res = r, err = nil}
 }
 
@@ -339,13 +339,13 @@ PyRes :: struct {
 	ai, bi, dest := &Int{}, &Int{}, &Int{}
 	defer internal_destroy(ai, bi, dest)
 
-	if err = atoi(ai, string(a), 16); err != nil { return PyRes{res=":gcd:atoi(a):", err=err}; }
-	if err = atoi(bi, string(b), 16); err != nil { return PyRes{res=":gcd:atoi(b):", err=err}; }
-	if err = #force_inline internal_int_gcd_lcm(dest, nil, ai, bi); err != nil { return PyRes{res=":gcd:gcd(a, b):", err=err}; }
+	if err = atoi(ai, string(a), 16); err != nil { return PyRes{res=":gcd:atoi(a):", err=err} }
+	if err = atoi(bi, string(b), 16); err != nil { return PyRes{res=":gcd:atoi(b):", err=err} }
+	if err = #force_inline internal_int_gcd_lcm(dest, nil, ai, bi); err != nil { return PyRes{res=":gcd:gcd(a, b):", err=err} }
 
 	r: cstring
 	r, err = int_itoa_cstring(dest, 16, context.temp_allocator)
-	if err != nil { return PyRes{res=":gcd:itoa(res):", err=err}; }
+	if err != nil { return PyRes{res=":gcd:itoa(res):", err=err} }
 	return PyRes{res = r, err = nil}
 }
 
@@ -359,13 +359,13 @@ PyRes :: struct {
 	ai, bi, dest := &Int{}, &Int{}, &Int{}
 	defer internal_destroy(ai, bi, dest)
 
-	if err = atoi(ai, string(a), 16); err != nil { return PyRes{res=":lcm:atoi(a):", err=err}; }
-	if err = atoi(bi, string(b), 16); err != nil { return PyRes{res=":lcm:atoi(b):", err=err}; }
-	if err = #force_inline internal_int_gcd_lcm(nil, dest, ai, bi); err != nil { return PyRes{res=":lcm:lcm(a, b):", err=err}; }
+	if err = atoi(ai, string(a), 16); err != nil { return PyRes{res=":lcm:atoi(a):", err=err} }
+	if err = atoi(bi, string(b), 16); err != nil { return PyRes{res=":lcm:atoi(b):", err=err} }
+	if err = #force_inline internal_int_gcd_lcm(nil, dest, ai, bi); err != nil { return PyRes{res=":lcm:lcm(a, b):", err=err} }
 
 	r: cstring
 	r, err = int_itoa_cstring(dest, 16, context.temp_allocator)
-	if err != nil { return PyRes{res=":lcm:itoa(res):", err=err}; }
+	if err != nil { return PyRes{res=":lcm:itoa(res):", err=err} }
 	return PyRes{res = r, err = nil}
 }
 
@@ -380,8 +380,8 @@ PyRes :: struct {
 	ai := &Int{}
 	defer internal_destroy(ai)
 
-	if err = atoi(ai, string(a), 16); err != nil { return PyRes{res=":is_square:atoi(a):", err=err}; }
-	if square, err = #force_inline internal_int_is_square(ai); err != nil { return PyRes{res=":is_square:is_square(a):", err=err}; }
+	if err = atoi(ai, string(a), 16); err != nil { return PyRes{res=":is_square:atoi(a):", err=err} }
+	if square, err = #force_inline internal_int_is_square(ai); err != nil { return PyRes{res=":is_square:is_square(a):", err=err} }
 
 	if square {
 		return PyRes{"True", nil}

core/math/bits/bits.odin

@@ -64,30 +64,30 @@ rotate_left :: proc(x: uint, k: int) -> uint {
 	return x <<s | x>>(n-s)
 }
 
-from_be_u8   :: proc(i:   u8) ->   u8 { return i; }
-from_be_u16  :: proc(i:  u16) ->  u16 { when ODIN_ENDIAN == "big" { return i; } else { return byte_swap(i); } }
-from_be_u32  :: proc(i:  u32) ->  u32 { when ODIN_ENDIAN == "big" { return i; } else { return byte_swap(i); } }
-from_be_u64  :: proc(i:  u64) ->  u64 { when ODIN_ENDIAN == "big" { return i; } else { return byte_swap(i); } }
-from_be_uint :: proc(i: uint) -> uint { when ODIN_ENDIAN == "big" { return i; } else { return byte_swap(i); } }
+from_be_u8   :: proc(i:   u8) ->   u8 { return i }
+from_be_u16  :: proc(i:  u16) ->  u16 { when ODIN_ENDIAN == "big" { return i } else { return byte_swap(i) } }
+from_be_u32  :: proc(i:  u32) ->  u32 { when ODIN_ENDIAN == "big" { return i } else { return byte_swap(i) } }
+from_be_u64  :: proc(i:  u64) ->  u64 { when ODIN_ENDIAN == "big" { return i } else { return byte_swap(i) } }
+from_be_uint :: proc(i: uint) -> uint { when ODIN_ENDIAN == "big" { return i } else { return byte_swap(i) } }
 
-from_le_u8   :: proc(i:   u8) ->   u8 { return i; }
-from_le_u16  :: proc(i:  u16) ->  u16 { when ODIN_ENDIAN == "little" { return i; } else { return byte_swap(i); } }
-from_le_u32  :: proc(i:  u32) ->  u32 { when ODIN_ENDIAN == "little" { return i; } else { return byte_swap(i); } }
-from_le_u64  :: proc(i:  u64) ->  u64 { when ODIN_ENDIAN == "little" { return i; } else { return byte_swap(i); } }
-from_le_uint :: proc(i: uint) -> uint { when ODIN_ENDIAN == "little" { return i; } else { return byte_swap(i); } }
+from_le_u8   :: proc(i:   u8) ->   u8 { return i }
+from_le_u16  :: proc(i:  u16) ->  u16 { when ODIN_ENDIAN == "little" { return i } else { return byte_swap(i) } }
+from_le_u32  :: proc(i:  u32) ->  u32 { when ODIN_ENDIAN == "little" { return i } else { return byte_swap(i) } }
+from_le_u64  :: proc(i:  u64) ->  u64 { when ODIN_ENDIAN == "little" { return i } else { return byte_swap(i) } }
+from_le_uint :: proc(i: uint) -> uint { when ODIN_ENDIAN == "little" { return i } else { return byte_swap(i) } }
 
-to_be_u8   :: proc(i:   u8) ->   u8 { return i; }
-to_be_u16  :: proc(i:  u16) ->  u16 { when ODIN_ENDIAN == "big" { return i; } else { return byte_swap(i); } }
-to_be_u32  :: proc(i:  u32) ->  u32 { when ODIN_ENDIAN == "big" { return i; } else { return byte_swap(i); } }
-to_be_u64  :: proc(i:  u64) ->  u64 { when ODIN_ENDIAN == "big" { return i; } else { return byte_swap(i); } }
-to_be_uint :: proc(i: uint) -> uint { when ODIN_ENDIAN == "big" { return i; } else { return byte_swap(i); } }
+to_be_u8   :: proc(i:   u8) ->   u8 { return i }
+to_be_u16  :: proc(i:  u16) ->  u16 { when ODIN_ENDIAN == "big" { return i } else { return byte_swap(i) } }
+to_be_u32  :: proc(i:  u32) ->  u32 { when ODIN_ENDIAN == "big" { return i } else { return byte_swap(i) } }
+to_be_u64  :: proc(i:  u64) ->  u64 { when ODIN_ENDIAN == "big" { return i } else { return byte_swap(i) } }
+to_be_uint :: proc(i: uint) -> uint { when ODIN_ENDIAN == "big" { return i } else { return byte_swap(i) } }
 
 
-to_le_u8   :: proc(i:   u8) ->   u8 { return i; }
-to_le_u16  :: proc(i:  u16) ->  u16 { when ODIN_ENDIAN == "little" { return i; } else { return byte_swap(i); } }
-to_le_u32  :: proc(i:  u32) ->  u32 { when ODIN_ENDIAN == "little" { return i; } else { return byte_swap(i); } }
-to_le_u64  :: proc(i:  u64) ->  u64 { when ODIN_ENDIAN == "little" { return i; } else { return byte_swap(i); } }
-to_le_uint :: proc(i: uint) -> uint { when ODIN_ENDIAN == "little" { return i; } else { return byte_swap(i); } }
+to_le_u8   :: proc(i:   u8) ->   u8 { return i }
+to_le_u16  :: proc(i:  u16) ->  u16 { when ODIN_ENDIAN == "little" { return i } else { return byte_swap(i) } }
+to_le_u32  :: proc(i:  u32) ->  u32 { when ODIN_ENDIAN == "little" { return i } else { return byte_swap(i) } }
+to_le_u64  :: proc(i:  u64) ->  u64 { when ODIN_ENDIAN == "little" { return i } else { return byte_swap(i) } }
+to_le_uint :: proc(i: uint) -> uint { when ODIN_ENDIAN == "little" { return i } else { return byte_swap(i) } }
 
 
 
@@ -294,16 +294,16 @@ div :: proc{div_u32, div_u64, div_uint}
 
 
 
-is_power_of_two_u8   :: proc(i:   u8) -> bool { return i > 0 && (i & (i-1)) == 0; }
-is_power_of_two_i8   :: proc(i:   i8) -> bool { return i > 0 && (i & (i-1)) == 0; }
-is_power_of_two_u16  :: proc(i:  u16) -> bool { return i > 0 && (i & (i-1)) == 0; }
-is_power_of_two_i16  :: proc(i:  i16) -> bool { return i > 0 && (i & (i-1)) == 0; }
-is_power_of_two_u32  :: proc(i:  u32) -> bool { return i > 0 && (i & (i-1)) == 0; }
-is_power_of_two_i32  :: proc(i:  i32) -> bool { return i > 0 && (i & (i-1)) == 0; }
-is_power_of_two_u64  :: proc(i:  u64) -> bool { return i > 0 && (i & (i-1)) == 0; }
-is_power_of_two_i64  :: proc(i:  i64) -> bool { return i > 0 && (i & (i-1)) == 0; }
-is_power_of_two_uint :: proc(i: uint) -> bool { return i > 0 && (i & (i-1)) == 0; }
-is_power_of_two_int  :: proc(i:  int) -> bool { return i > 0 && (i & (i-1)) == 0; }
+is_power_of_two_u8   :: proc(i:   u8) -> bool { return i > 0 && (i & (i-1)) == 0 }
+is_power_of_two_i8   :: proc(i:   i8) -> bool { return i > 0 && (i & (i-1)) == 0 }
+is_power_of_two_u16  :: proc(i:  u16) -> bool { return i > 0 && (i & (i-1)) == 0 }
+is_power_of_two_i16  :: proc(i:  i16) -> bool { return i > 0 && (i & (i-1)) == 0 }
+is_power_of_two_u32  :: proc(i:  u32) -> bool { return i > 0 && (i & (i-1)) == 0 }
+is_power_of_two_i32  :: proc(i:  i32) -> bool { return i > 0 && (i & (i-1)) == 0 }
+is_power_of_two_u64  :: proc(i:  u64) -> bool { return i > 0 && (i & (i-1)) == 0 }
+is_power_of_two_i64  :: proc(i:  i64) -> bool { return i > 0 && (i & (i-1)) == 0 }
+is_power_of_two_uint :: proc(i: uint) -> bool { return i > 0 && (i & (i-1)) == 0 }
+is_power_of_two_int  :: proc(i:  int) -> bool { return i > 0 && (i & (i-1)) == 0 }
 
 is_power_of_two :: proc{
 	is_power_of_two_u8,   is_power_of_two_i8,
@@ -328,12 +328,12 @@ len_u8_table := [256]u8{
 }
 
 
-bitfield_extract_u8   :: proc(value:   u8, offset, bits: uint) ->   u8 { return (value >> offset) &   u8(1<<bits - 1); }
-bitfield_extract_u16  :: proc(value:  u16, offset, bits: uint) ->  u16 { return (value >> offset) &  u16(1<<bits - 1); }
-bitfield_extract_u32  :: proc(value:  u32, offset, bits: uint) ->  u32 { return (value >> offset) &  u32(1<<bits - 1); }
-bitfield_extract_u64  :: proc(value:  u64, offset, bits: uint) ->  u64 { return (value >> offset) &  u64(1<<bits - 1); }
-bitfield_extract_u128 :: proc(value: u128, offset, bits: uint) -> u128 { return (value >> offset) & u128(1<<bits - 1); }
-bitfield_extract_uint :: proc(value: uint, offset, bits: uint) -> uint { return (value >> offset) & uint(1<<bits - 1); }
+bitfield_extract_u8   :: proc(value:   u8, offset, bits: uint) ->   u8 { return (value >> offset) &   u8(1<<bits - 1) }
+bitfield_extract_u16  :: proc(value:  u16, offset, bits: uint) ->  u16 { return (value >> offset) &  u16(1<<bits - 1) }
+bitfield_extract_u32  :: proc(value:  u32, offset, bits: uint) ->  u32 { return (value >> offset) &  u32(1<<bits - 1) }
+bitfield_extract_u64  :: proc(value:  u64, offset, bits: uint) ->  u64 { return (value >> offset) &  u64(1<<bits - 1) }
+bitfield_extract_u128 :: proc(value: u128, offset, bits: uint) -> u128 { return (value >> offset) & u128(1<<bits - 1) }
+bitfield_extract_uint :: proc(value: uint, offset, bits: uint) -> uint { return (value >> offset) & uint(1<<bits - 1) }
 
 bitfield_extract_i8 :: proc(value: i8, offset, bits: uint) -> i8 {
 	v := (u8(value) >> offset) & u8(1<<bits - 1)

core/math/linalg/extended.odin

@@ -478,12 +478,12 @@ is_inf :: proc{is_inf_single, is_inf_array}
 classify :: proc{classify_single, classify_array}
 
 
-less_than_single          :: proc(x, y: $T) -> (out: bool) where !IS_ARRAY(T), IS_FLOAT(T) { return x < y; }
-less_than_equal_single    :: proc(x, y: $T) -> (out: bool) where !IS_ARRAY(T), IS_FLOAT(T) { return x <= y; }
-greater_than_single       :: proc(x, y: $T) -> (out: bool) where !IS_ARRAY(T), IS_FLOAT(T) { return x > y; }
-greater_than_equal_single :: proc(x, y: $T) -> (out: bool) where !IS_ARRAY(T), IS_FLOAT(T) { return x >= y; }
-equal_single              :: proc(x, y: $T) -> (out: bool) where !IS_ARRAY(T), IS_FLOAT(T) { return x == y; }
-not_equal_single          :: proc(x, y: $T) -> (out: bool) where !IS_ARRAY(T), IS_FLOAT(T) { return x != y; }
+less_than_single          :: proc(x, y: $T) -> (out: bool) where !IS_ARRAY(T), IS_FLOAT(T) { return x < y }
+less_than_equal_single    :: proc(x, y: $T) -> (out: bool) where !IS_ARRAY(T), IS_FLOAT(T) { return x <= y }
+greater_than_single       :: proc(x, y: $T) -> (out: bool) where !IS_ARRAY(T), IS_FLOAT(T) { return x > y }
+greater_than_equal_single :: proc(x, y: $T) -> (out: bool) where !IS_ARRAY(T), IS_FLOAT(T) { return x >= y }
+equal_single              :: proc(x, y: $T) -> (out: bool) where !IS_ARRAY(T), IS_FLOAT(T) { return x == y }
+not_equal_single          :: proc(x, y: $T) -> (out: bool) where !IS_ARRAY(T), IS_FLOAT(T) { return x != y }
 
 less_than_array :: proc(x, y: $A/[$N]$T) -> (out: [N]bool) where IS_ARRAY(A), IS_FLOAT(ELEM_TYPE(A)) {
 	for i in 0..<N {

core/math/linalg/general.odin

@@ -339,24 +339,24 @@ matrix_cast :: proc(v: $A/[$M][$N]$T, $Elem_Type: typeid) -> (w: [M][N]Elem_Type
 	return
 }
 
-to_f32  :: #force_inline proc(v: $A/[$N]$T) -> [N]f32  { return array_cast(v, f32);  }
-to_f64  :: #force_inline proc(v: $A/[$N]$T) -> [N]f64  { return array_cast(v, f64);  }
-
-to_i8   :: #force_inline proc(v: $A/[$N]$T) -> [N]i8   { return array_cast(v, i8);   }
-to_i16  :: #force_inline proc(v: $A/[$N]$T) -> [N]i16  { return array_cast(v, i16);  }
-to_i32  :: #force_inline proc(v: $A/[$N]$T) -> [N]i32  { return array_cast(v, i32);  }
-to_i64  :: #force_inline proc(v: $A/[$N]$T) -> [N]i64  { return array_cast(v, i64);  }
-to_int  :: #force_inline proc(v: $A/[$N]$T) -> [N]int  { return array_cast(v, int);  }
-
-to_u8   :: #force_inline proc(v: $A/[$N]$T) -> [N]u8   { return array_cast(v, u8);   }
-to_u16  :: #force_inline proc(v: $A/[$N]$T) -> [N]u16  { return array_cast(v, u16);  }
-to_u32  :: #force_inline proc(v: $A/[$N]$T) -> [N]u32  { return array_cast(v, u32);  }
-to_u64  :: #force_inline proc(v: $A/[$N]$T) -> [N]u64  { return array_cast(v, u64);  }
-to_uint :: #force_inline proc(v: $A/[$N]$T) -> [N]uint { return array_cast(v, uint); }
-
-to_complex32     :: #force_inline proc(v: $A/[$N]$T) -> [N]complex32     { return array_cast(v, complex32);     }
-to_complex64     :: #force_inline proc(v: $A/[$N]$T) -> [N]complex64     { return array_cast(v, complex64);     }
-to_complex128    :: #force_inline proc(v: $A/[$N]$T) -> [N]complex128    { return array_cast(v, complex128);    }
-to_quaternion64  :: #force_inline proc(v: $A/[$N]$T) -> [N]quaternion64 { return array_cast(v, quaternion64); }
-to_quaternion128 :: #force_inline proc(v: $A/[$N]$T) -> [N]quaternion128 { return array_cast(v, quaternion128); }
-to_quaternion256 :: #force_inline proc(v: $A/[$N]$T) -> [N]quaternion256 { return array_cast(v, quaternion256); }
+to_f32  :: #force_inline proc(v: $A/[$N]$T) -> [N]f32  { return array_cast(v, f32)  }
+to_f64  :: #force_inline proc(v: $A/[$N]$T) -> [N]f64  { return array_cast(v, f64)  }
+
+to_i8   :: #force_inline proc(v: $A/[$N]$T) -> [N]i8   { return array_cast(v, i8)   }
+to_i16  :: #force_inline proc(v: $A/[$N]$T) -> [N]i16  { return array_cast(v, i16)  }
+to_i32  :: #force_inline proc(v: $A/[$N]$T) -> [N]i32  { return array_cast(v, i32)  }
+to_i64  :: #force_inline proc(v: $A/[$N]$T) -> [N]i64  { return array_cast(v, i64)  }
+to_int  :: #force_inline proc(v: $A/[$N]$T) -> [N]int  { return array_cast(v, int)  }
+
+to_u8   :: #force_inline proc(v: $A/[$N]$T) -> [N]u8   { return array_cast(v, u8)   }
+to_u16  :: #force_inline proc(v: $A/[$N]$T) -> [N]u16  { return array_cast(v, u16)  }
+to_u32  :: #force_inline proc(v: $A/[$N]$T) -> [N]u32  { return array_cast(v, u32)  }
+to_u64  :: #force_inline proc(v: $A/[$N]$T) -> [N]u64  { return array_cast(v, u64)  }
+to_uint :: #force_inline proc(v: $A/[$N]$T) -> [N]uint { return array_cast(v, uint) }
+
+to_complex32     :: #force_inline proc(v: $A/[$N]$T) -> [N]complex32     { return array_cast(v, complex32)     }
+to_complex64     :: #force_inline proc(v: $A/[$N]$T) -> [N]complex64     { return array_cast(v, complex64)     }
+to_complex128    :: #force_inline proc(v: $A/[$N]$T) -> [N]complex128    { return array_cast(v, complex128)    }
+to_quaternion64  :: #force_inline proc(v: $A/[$N]$T) -> [N]quaternion64 { return array_cast(v, quaternion64) }
+to_quaternion128 :: #force_inline proc(v: $A/[$N]$T) -> [N]quaternion128 { return array_cast(v, quaternion128) }
+to_quaternion256 :: #force_inline proc(v: $A/[$N]$T) -> [N]quaternion256 { return array_cast(v, quaternion256) }

core/math/linalg/specific.odin

@@ -260,8 +260,8 @@ vector4_linear_to_srgb :: proc{
 vector4_hsl_to_rgb_f16 :: proc(h, s, l: f16, a: f16 = 1) -> Vector4f16 {
 	hue_to_rgb :: proc(p, q, t: f16) -> f16 {
 		t := t
-		if t < 0 { t += 1; }
-		if t > 1 { t -= 1; }
+		if t < 0 { t += 1 }
+		if t > 1 { t -= 1 }
 		switch {
 		case t < 1.0/6.0: return p + (q - p) * 6.0 * t
 		case t < 1.0/2.0: return q
@@ -287,8 +287,8 @@ vector4_hsl_to_rgb_f16 :: proc(h, s, l: f16, a: f16 = 1) -> Vector4f16 {
 vector4_hsl_to_rgb_f32 :: proc(h, s, l: f32, a: f32 = 1) -> Vector4f32 {
 	hue_to_rgb :: proc(p, q, t: f32) -> f32 {
 		t := t
-		if t < 0 { t += 1; }
-		if t > 1 { t -= 1; }
+		if t < 0 { t += 1 }
+		if t > 1 { t -= 1 }
 		switch {
 		case t < 1.0/6.0: return p + (q - p) * 6.0 * t
 		case t < 1.0/2.0: return q
@@ -314,8 +314,8 @@ vector4_hsl_to_rgb_f32 :: proc(h, s, l: f32, a: f32 = 1) -> Vector4f32 {
 vector4_hsl_to_rgb_f64 :: proc(h, s, l: f64, a: f64 = 1) -> Vector4f64 {
 	hue_to_rgb :: proc(p, q, t: f64) -> f64 {
 		t := t
-		if t < 0 { t += 1; }
-		if t > 1 { t -= 1; }
+		if t < 0 { t += 1 }
+		if t > 1 { t -= 1 }
 		switch {
 		case t < 1.0/6.0: return p + (q - p) * 6.0 * t
 		case t < 1.0/2.0: return q

core/math/math.odin

@@ -96,96 +96,96 @@ foreign _ {
 	ldexp_f64 :: proc(val: f64, exp: i32) -> f64 ---
 }
 
-sqrt_f16le :: proc(x: f16le) -> f16le { return #force_inline f16le(sqrt_f16(f16(x))); }
-sqrt_f16be :: proc(x: f16be) -> f16be { return #force_inline f16be(sqrt_f16(f16(x))); }
-sqrt_f32le :: proc(x: f32le) -> f32le { return #force_inline f32le(sqrt_f32(f32(x))); }
-sqrt_f32be :: proc(x: f32be) -> f32be { return #force_inline f32be(sqrt_f32(f32(x))); }
-sqrt_f64le :: proc(x: f64le) -> f64le { return #force_inline f64le(sqrt_f64(f64(x))); }
-sqrt_f64be :: proc(x: f64be) -> f64be { return #force_inline f64be(sqrt_f64(f64(x))); }
+sqrt_f16le :: proc(x: f16le) -> f16le { return #force_inline f16le(sqrt_f16(f16(x))) }
+sqrt_f16be :: proc(x: f16be) -> f16be { return #force_inline f16be(sqrt_f16(f16(x))) }
+sqrt_f32le :: proc(x: f32le) -> f32le { return #force_inline f32le(sqrt_f32(f32(x))) }
+sqrt_f32be :: proc(x: f32be) -> f32be { return #force_inline f32be(sqrt_f32(f32(x))) }
+sqrt_f64le :: proc(x: f64le) -> f64le { return #force_inline f64le(sqrt_f64(f64(x))) }
+sqrt_f64be :: proc(x: f64be) -> f64be { return #force_inline f64be(sqrt_f64(f64(x))) }
 sqrt       :: proc{
 	sqrt_f16, sqrt_f16le, sqrt_f16be,
 	sqrt_f32, sqrt_f32le, sqrt_f32be,
 	sqrt_f64, sqrt_f64le, sqrt_f64be,
 }
 
-sin_f16le :: proc(θ: f16le) -> f16le { return #force_inline f16le(sin_f16(f16(θ))); }
-sin_f16be :: proc(θ: f16be) -> f16be { return #force_inline f16be(sin_f16(f16(θ))); }
-sin_f32le :: proc(θ: f32le) -> f32le { return #force_inline f32le(sin_f32(f32(θ))); }
-sin_f32be :: proc(θ: f32be) -> f32be { return #force_inline f32be(sin_f32(f32(θ))); }
-sin_f64le :: proc(θ: f64le) -> f64le { return #force_inline f64le(sin_f64(f64(θ))); }
-sin_f64be :: proc(θ: f64be) -> f64be { return #force_inline f64be(sin_f64(f64(θ))); }
+sin_f16le :: proc(θ: f16le) -> f16le { return #force_inline f16le(sin_f16(f16(θ))) }
+sin_f16be :: proc(θ: f16be) -> f16be { return #force_inline f16be(sin_f16(f16(θ))) }
+sin_f32le :: proc(θ: f32le) -> f32le { return #force_inline f32le(sin_f32(f32(θ))) }
+sin_f32be :: proc(θ: f32be) -> f32be { return #force_inline f32be(sin_f32(f32(θ))) }
+sin_f64le :: proc(θ: f64le) -> f64le { return #force_inline f64le(sin_f64(f64(θ))) }
+sin_f64be :: proc(θ: f64be) -> f64be { return #force_inline f64be(sin_f64(f64(θ))) }
 sin       :: proc{
 	sin_f16, sin_f16le, sin_f16be,
 	sin_f32, sin_f32le, sin_f32be,
 	sin_f64, sin_f64le, sin_f64be,
 }
 
-cos_f16le :: proc(θ: f16le) -> f16le { return #force_inline f16le(cos_f16(f16(θ))); }
-cos_f16be :: proc(θ: f16be) -> f16be { return #force_inline f16be(cos_f16(f16(θ))); }
-cos_f32le :: proc(θ: f32le) -> f32le { return #force_inline f32le(cos_f32(f32(θ))); }
-cos_f32be :: proc(θ: f32be) -> f32be { return #force_inline f32be(cos_f32(f32(θ))); }
-cos_f64le :: proc(θ: f64le) -> f64le { return #force_inline f64le(cos_f64(f64(θ))); }
-cos_f64be :: proc(θ: f64be) -> f64be { return #force_inline f64be(cos_f64(f64(θ))); }
+cos_f16le :: proc(θ: f16le) -> f16le { return #force_inline f16le(cos_f16(f16(θ))) }
+cos_f16be :: proc(θ: f16be) -> f16be { return #force_inline f16be(cos_f16(f16(θ))) }
+cos_f32le :: proc(θ: f32le) -> f32le { return #force_inline f32le(cos_f32(f32(θ))) }
+cos_f32be :: proc(θ: f32be) -> f32be { return #force_inline f32be(cos_f32(f32(θ))) }
+cos_f64le :: proc(θ: f64le) -> f64le { return #force_inline f64le(cos_f64(f64(θ))) }
+cos_f64be :: proc(θ: f64be) -> f64be { return #force_inline f64be(cos_f64(f64(θ))) }
 cos       :: proc{
 	cos_f16, cos_f16le, cos_f16be,
 	cos_f32, cos_f32le, cos_f32be,
 	cos_f64, cos_f64le, cos_f64be,
 }
 
-pow_f16le :: proc(x, power: f16le) -> f16le { return #force_inline f16le(pow_f16(f16(x), f16(power))); }
-pow_f16be :: proc(x, power: f16be) -> f16be { return #force_inline f16be(pow_f16(f16(x), f16(power))); }
-pow_f32le :: proc(x, power: f32le) -> f32le { return #force_inline f32le(pow_f32(f32(x), f32(power))); }
-pow_f32be :: proc(x, power: f32be) -> f32be { return #force_inline f32be(pow_f32(f32(x), f32(power))); }
-pow_f64le :: proc(x, power: f64le) -> f64le { return #force_inline f64le(pow_f64(f64(x), f64(power))); }
-pow_f64be :: proc(x, power: f64be) -> f64be { return #force_inline f64be(pow_f64(f64(x), f64(power))); }
+pow_f16le :: proc(x, power: f16le) -> f16le { return #force_inline f16le(pow_f16(f16(x), f16(power))) }
+pow_f16be :: proc(x, power: f16be) -> f16be { return #force_inline f16be(pow_f16(f16(x), f16(power))) }
+pow_f32le :: proc(x, power: f32le) -> f32le { return #force_inline f32le(pow_f32(f32(x), f32(power))) }
+pow_f32be :: proc(x, power: f32be) -> f32be { return #force_inline f32be(pow_f32(f32(x), f32(power))) }
+pow_f64le :: proc(x, power: f64le) -> f64le { return #force_inline f64le(pow_f64(f64(x), f64(power))) }
+pow_f64be :: proc(x, power: f64be) -> f64be { return #force_inline f64be(pow_f64(f64(x), f64(power))) }
 pow       :: proc{
 	pow_f16, pow_f16le, pow_f16be,
 	pow_f32, pow_f32le, pow_f32be,
 	pow_f64, pow_f64le, pow_f64be,
 }
 
-fmuladd_f16le :: proc(a, b, c: f16le) -> f16le { return #force_inline f16le(fmuladd_f16(f16(a), f16(b), f16(c))); }
-fmuladd_f16be :: proc(a, b, c: f16be) -> f16be { return #force_inline f16be(fmuladd_f16(f16(a), f16(b), f16(c))); }
-fmuladd_f32le :: proc(a, b, c: f32le) -> f32le { return #force_inline f32le(fmuladd_f32(f32(a), f32(b), f32(c))); }
-fmuladd_f32be :: proc(a, b, c: f32be) -> f32be { return #force_inline f32be(fmuladd_f32(f32(a), f32(b), f32(c))); }
-fmuladd_f64le :: proc(a, b, c: f64le) -> f64le { return #force_inline f64le(fmuladd_f64(f64(a), f64(b), f64(c))); }
-fmuladd_f64be :: proc(a, b, c: f64be) -> f64be { return #force_inline f64be(fmuladd_f64(f64(a), f64(b), f64(c))); }
+fmuladd_f16le :: proc(a, b, c: f16le) -> f16le { return #force_inline f16le(fmuladd_f16(f16(a), f16(b), f16(c))) }
+fmuladd_f16be :: proc(a, b, c: f16be) -> f16be { return #force_inline f16be(fmuladd_f16(f16(a), f16(b), f16(c))) }
+fmuladd_f32le :: proc(a, b, c: f32le) -> f32le { return #force_inline f32le(fmuladd_f32(f32(a), f32(b), f32(c))) }
+fmuladd_f32be :: proc(a, b, c: f32be) -> f32be { return #force_inline f32be(fmuladd_f32(f32(a), f32(b), f32(c))) }
+fmuladd_f64le :: proc(a, b, c: f64le) -> f64le { return #force_inline f64le(fmuladd_f64(f64(a), f64(b), f64(c))) }
+fmuladd_f64be :: proc(a, b, c: f64be) -> f64be { return #force_inline f64be(fmuladd_f64(f64(a), f64(b), f64(c))) }
 fmuladd       :: proc{
 	fmuladd_f16, fmuladd_f16le, fmuladd_f16be,
 	fmuladd_f32, fmuladd_f32le, fmuladd_f32be,
 	fmuladd_f64, fmuladd_f64le, fmuladd_f64be,
 }
 
-ln_f16le :: proc(x: f16le) -> f16le { return #force_inline f16le(ln_f16(f16(x))); }
-ln_f16be :: proc(x: f16be) -> f16be { return #force_inline f16be(ln_f16(f16(x))); }
-ln_f32le :: proc(x: f32le) -> f32le { return #force_inline f32le(ln_f32(f32(x))); }
-ln_f32be :: proc(x: f32be) -> f32be { return #force_inline f32be(ln_f32(f32(x))); }
-ln_f64le :: proc(x: f64le) -> f64le { return #force_inline f64le(ln_f64(f64(x))); }
-ln_f64be :: proc(x: f64be) -> f64be { return #force_inline f64be(ln_f64(f64(x))); }
+ln_f16le :: proc(x: f16le) -> f16le { return #force_inline f16le(ln_f16(f16(x))) }
+ln_f16be :: proc(x: f16be) -> f16be { return #force_inline f16be(ln_f16(f16(x))) }
+ln_f32le :: proc(x: f32le) -> f32le { return #force_inline f32le(ln_f32(f32(x))) }
+ln_f32be :: proc(x: f32be) -> f32be { return #force_inline f32be(ln_f32(f32(x))) }
+ln_f64le :: proc(x: f64le) -> f64le { return #force_inline f64le(ln_f64(f64(x))) }
+ln_f64be :: proc(x: f64be) -> f64be { return #force_inline f64be(ln_f64(f64(x))) }
 ln       :: proc{
 	ln_f16, ln_f16le, ln_f16be,
 	ln_f32, ln_f32le, ln_f32be,
 	ln_f64, ln_f64le, ln_f64be,
 }
 
-exp_f16le :: proc(x: f16le) -> f16le { return #force_inline f16le(exp_f16(f16(x))); }
-exp_f16be :: proc(x: f16be) -> f16be { return #force_inline f16be(exp_f16(f16(x))); }
-exp_f32le :: proc(x: f32le) -> f32le { return #force_inline f32le(exp_f32(f32(x))); }
-exp_f32be :: proc(x: f32be) -> f32be { return #force_inline f32be(exp_f32(f32(x))); }
-exp_f64le :: proc(x: f64le) -> f64le { return #force_inline f64le(exp_f64(f64(x))); }
-exp_f64be :: proc(x: f64be) -> f64be { return #force_inline f64be(exp_f64(f64(x))); }
+exp_f16le :: proc(x: f16le) -> f16le { return #force_inline f16le(exp_f16(f16(x))) }
+exp_f16be :: proc(x: f16be) -> f16be { return #force_inline f16be(exp_f16(f16(x))) }
+exp_f32le :: proc(x: f32le) -> f32le { return #force_inline f32le(exp_f32(f32(x))) }
+exp_f32be :: proc(x: f32be) -> f32be { return #force_inline f32be(exp_f32(f32(x))) }
+exp_f64le :: proc(x: f64le) -> f64le { return #force_inline f64le(exp_f64(f64(x))) }
+exp_f64be :: proc(x: f64be) -> f64be { return #force_inline f64be(exp_f64(f64(x))) }
 exp       :: proc{
 	exp_f16, exp_f16le, exp_f16be,
 	exp_f32, exp_f32le, exp_f32be,
 	exp_f64, exp_f64le, exp_f64be,
 }
 
-ldexp_f16le :: proc(val: f16le, exp: i32) -> f16le { return #force_inline f16le(ldexp_f16(f16(val), exp)); }
-ldexp_f16be :: proc(val: f16be, exp: i32) -> f16be { return #force_inline f16be(ldexp_f16(f16(val), exp)); }
-ldexp_f32le :: proc(val: f32le, exp: i32) -> f32le { return #force_inline f32le(ldexp_f32(f32(val), exp)); }
-ldexp_f32be :: proc(val: f32be, exp: i32) -> f32be { return #force_inline f32be(ldexp_f32(f32(val), exp)); }
-ldexp_f64le :: proc(val: f64le, exp: i32) -> f64le { return #force_inline f64le(ldexp_f64(f64(val), exp)); }
-ldexp_f64be :: proc(val: f64be, exp: i32) -> f64be { return #force_inline f64be(ldexp_f64(f64(val), exp)); }
+ldexp_f16le :: proc(val: f16le, exp: i32) -> f16le { return #force_inline f16le(ldexp_f16(f16(val), exp)) }
+ldexp_f16be :: proc(val: f16be, exp: i32) -> f16be { return #force_inline f16be(ldexp_f16(f16(val), exp)) }
+ldexp_f32le :: proc(val: f32le, exp: i32) -> f32le { return #force_inline f32le(ldexp_f32(f32(val), exp)) }
+ldexp_f32be :: proc(val: f32be, exp: i32) -> f32be { return #force_inline f32be(ldexp_f32(f32(val), exp)) }
+ldexp_f64le :: proc(val: f64le, exp: i32) -> f64le { return #force_inline f64le(ldexp_f64(f64(val), exp)) }
+ldexp_f64be :: proc(val: f64be, exp: i32) -> f64be { return #force_inline f64be(ldexp_f64(f64(val), exp)) }
 ldexp       :: proc{
 	ldexp_f16, ldexp_f16le, ldexp_f16be,
 	ldexp_f32, ldexp_f32le, ldexp_f32be,
@@ -193,76 +193,76 @@ ldexp       :: proc{
 }
 
 
-log_f16   :: proc(x, base: f16)   -> f16   { return ln(x) / ln(base); }
-log_f16le :: proc(x, base: f16le) -> f16le { return f16le(log_f16(f16(x), f16(base))); }
-log_f16be :: proc(x, base: f16be) -> f16be { return f16be(log_f16(f16(x), f16(base))); }
+log_f16   :: proc(x, base: f16)   -> f16   { return ln(x) / ln(base) }
+log_f16le :: proc(x, base: f16le) -> f16le { return f16le(log_f16(f16(x), f16(base))) }
+log_f16be :: proc(x, base: f16be) -> f16be { return f16be(log_f16(f16(x), f16(base))) }
 
-log_f32   :: proc(x, base: f32)   -> f32   { return ln(x) / ln(base); }
-log_f32le :: proc(x, base: f32le) -> f32le { return f32le(log_f32(f32(x), f32(base))); }
-log_f32be :: proc(x, base: f32be) -> f32be { return f32be(log_f32(f32(x), f32(base))); }
+log_f32   :: proc(x, base: f32)   -> f32   { return ln(x) / ln(base) }
+log_f32le :: proc(x, base: f32le) -> f32le { return f32le(log_f32(f32(x), f32(base))) }
+log_f32be :: proc(x, base: f32be) -> f32be { return f32be(log_f32(f32(x), f32(base))) }
 
-log_f64   :: proc(x, base: f64)   -> f64   { return ln(x) / ln(base); }
-log_f64le :: proc(x, base: f64le) -> f64le { return f64le(log_f64(f64(x), f64(base))); }
-log_f64be :: proc(x, base: f64be) -> f64be { return f64be(log_f64(f64(x), f64(base))); }
+log_f64   :: proc(x, base: f64)   -> f64   { return ln(x) / ln(base) }
+log_f64le :: proc(x, base: f64le) -> f64le { return f64le(log_f64(f64(x), f64(base))) }
+log_f64be :: proc(x, base: f64be) -> f64be { return f64be(log_f64(f64(x), f64(base))) }
 log       :: proc{
 	log_f16, log_f16le, log_f16be,
 	log_f32, log_f32le, log_f32be,
 	log_f64, log_f64le, log_f64be,
 }
 
-log2_f16   :: proc(x: f16)   -> f16   { return ln(x)/LN2; }
-log2_f16le :: proc(x: f16le) -> f16le { return f16le(log2_f16(f16(x))); }
-log2_f16be :: proc(x: f16be) -> f16be { return f16be(log2_f16(f16(x))); }
+log2_f16   :: proc(x: f16)   -> f16   { return ln(x)/LN2 }
+log2_f16le :: proc(x: f16le) -> f16le { return f16le(log2_f16(f16(x))) }
+log2_f16be :: proc(x: f16be) -> f16be { return f16be(log2_f16(f16(x))) }
 
-log2_f32   :: proc(x: f32)   -> f32   { return ln(x)/LN2; }
-log2_f32le :: proc(x: f32le) -> f32le { return f32le(log2_f32(f32(x))); }
-log2_f32be :: proc(x: f32be) -> f32be { return f32be(log2_f32(f32(x))); }
+log2_f32   :: proc(x: f32)   -> f32   { return ln(x)/LN2 }
+log2_f32le :: proc(x: f32le) -> f32le { return f32le(log2_f32(f32(x))) }
+log2_f32be :: proc(x: f32be) -> f32be { return f32be(log2_f32(f32(x))) }
 
-log2_f64   :: proc(x: f64)   -> f64   { return ln(x)/LN2; }
-log2_f64le :: proc(x: f64le) -> f64le { return f64le(log2_f64(f64(x))); }
-log2_f64be :: proc(x: f64be) -> f64be { return f64be(log2_f64(f64(x))); }
+log2_f64   :: proc(x: f64)   -> f64   { return ln(x)/LN2 }
+log2_f64le :: proc(x: f64le) -> f64le { return f64le(log2_f64(f64(x))) }
+log2_f64be :: proc(x: f64be) -> f64be { return f64be(log2_f64(f64(x))) }
 log2       :: proc{
 	log2_f16, log2_f16le, log2_f16be,
 	log2_f32, log2_f32le, log2_f32be,
 	log2_f64, log2_f64le, log2_f64be,
 }
 
-log10_f16   :: proc(x: f16)   -> f16   { return ln(x)/LN10; }
-log10_f16le :: proc(x: f16le) -> f16le { return f16le(log10_f16(f16(x))); }
-log10_f16be :: proc(x: f16be) -> f16be { return f16be(log10_f16(f16(x))); }
+log10_f16   :: proc(x: f16)   -> f16   { return ln(x)/LN10 }
+log10_f16le :: proc(x: f16le) -> f16le { return f16le(log10_f16(f16(x))) }
+log10_f16be :: proc(x: f16be) -> f16be { return f16be(log10_f16(f16(x))) }
 
-log10_f32   :: proc(x: f32)   -> f32   { return ln(x)/LN10; }
-log10_f32le :: proc(x: f32le) -> f32le { return f32le(log10_f32(f32(x))); }
-log10_f32be :: proc(x: f32be) -> f32be { return f32be(log10_f32(f32(x))); }
+log10_f32   :: proc(x: f32)   -> f32   { return ln(x)/LN10 }
+log10_f32le :: proc(x: f32le) -> f32le { return f32le(log10_f32(f32(x))) }
+log10_f32be :: proc(x: f32be) -> f32be { return f32be(log10_f32(f32(x))) }
 
-log10_f64   :: proc(x: f64)   -> f64   { return ln(x)/LN10; }
-log10_f64le :: proc(x: f64le) -> f64le { return f64le(log10_f64(f64(x))); }
-log10_f64be :: proc(x: f64be) -> f64be { return f64be(log10_f64(f64(x))); }
+log10_f64   :: proc(x: f64)   -> f64   { return ln(x)/LN10 }
+log10_f64le :: proc(x: f64le) -> f64le { return f64le(log10_f64(f64(x))) }
+log10_f64be :: proc(x: f64be) -> f64be { return f64be(log10_f64(f64(x))) }
 log10       :: proc{
 	log10_f16, log10_f16le, log10_f16be,
 	log10_f32, log10_f32le, log10_f32be,
 	log10_f64, log10_f64le, log10_f64be,
 }
 
-tan_f16   :: proc(θ: f16)   -> f16   { return sin(θ)/cos(θ); }
-tan_f16le :: proc(θ: f16le) -> f16le { return f16le(tan_f16(f16(θ))); }
-tan_f16be :: proc(θ: f16be) -> f16be { return f16be(tan_f16(f16(θ))); }
+tan_f16   :: proc(θ: f16)   -> f16   { return sin(θ)/cos(θ) }
+tan_f16le :: proc(θ: f16le) -> f16le { return f16le(tan_f16(f16(θ))) }
+tan_f16be :: proc(θ: f16be) -> f16be { return f16be(tan_f16(f16(θ))) }
 
-tan_f32   :: proc(θ: f32)   -> f32   { return sin(θ)/cos(θ); }
-tan_f32le :: proc(θ: f32le) -> f32le { return f32le(tan_f32(f32(θ))); }
-tan_f32be :: proc(θ: f32be) -> f32be { return f32be(tan_f32(f32(θ))); }
+tan_f32   :: proc(θ: f32)   -> f32   { return sin(θ)/cos(θ) }
+tan_f32le :: proc(θ: f32le) -> f32le { return f32le(tan_f32(f32(θ))) }
+tan_f32be :: proc(θ: f32be) -> f32be { return f32be(tan_f32(f32(θ))) }
 
-tan_f64   :: proc(θ: f64)   -> f64   { return sin(θ)/cos(θ); }
-tan_f64le :: proc(θ: f64le) -> f64le { return f64le(tan_f64(f64(θ))); }
-tan_f64be :: proc(θ: f64be) -> f64be { return f64be(tan_f64(f64(θ))); }
+tan_f64   :: proc(θ: f64)   -> f64   { return sin(θ)/cos(θ) }
+tan_f64le :: proc(θ: f64le) -> f64le { return f64le(tan_f64(f64(θ))) }
+tan_f64be :: proc(θ: f64be) -> f64be { return f64be(tan_f64(f64(θ))) }
 tan       :: proc{
 	tan_f16, tan_f16le, tan_f16be,
 	tan_f32, tan_f32le, tan_f32be,
 	tan_f64, tan_f64le, tan_f64be,
 }
 
-lerp :: proc(a, b: $T, t: $E) -> (x: T) { return a*(1-t) + b*t; }
-saturate :: proc(a: $T) -> (x: T) { return clamp(a, 0, 1); }
+lerp :: proc(a, b: $T, t: $E) -> (x: T) { return a*(1-t) + b*t }
+saturate :: proc(a: $T) -> (x: T) { return clamp(a, 0, 1) }
 
 unlerp :: proc(a, b, x: $T) -> (t: T)  where intrinsics.type_is_float(T), !intrinsics.type_is_array(T) {
 	return (x-a)/(b-a)
@@ -311,15 +311,15 @@ gain :: proc(t, g: $T) -> T where intrinsics.type_is_numeric(T) {
 }
 
 
-sign_f16   :: proc(x: f16)   -> f16   { return f16(int(0 < x) - int(x < 0)); }
-sign_f16le :: proc(x: f16le) -> f16le { return f16le(int(0 < x) - int(x < 0)); }
-sign_f16be :: proc(x: f16be) -> f16be { return f16be(int(0 < x) - int(x < 0)); }
-sign_f32   :: proc(x: f32)   -> f32   { return f32(int(0 < x) - int(x < 0)); }
-sign_f32le :: proc(x: f32le) -> f32le { return f32le(int(0 < x) - int(x < 0)); }
-sign_f32be :: proc(x: f32be) -> f32be { return f32be(int(0 < x) - int(x < 0)); }
-sign_f64   :: proc(x: f64)   -> f64   { return f64(int(0 < x) - int(x < 0)); }
-sign_f64le :: proc(x: f64le) -> f64le { return f64le(int(0 < x) - int(x < 0)); }
-sign_f64be :: proc(x: f64be) -> f64be { return f64be(int(0 < x) - int(x < 0)); }
+sign_f16   :: proc(x: f16)   -> f16   { return f16(int(0 < x) - int(x < 0)) }
+sign_f16le :: proc(x: f16le) -> f16le { return f16le(int(0 < x) - int(x < 0)) }
+sign_f16be :: proc(x: f16be) -> f16be { return f16be(int(0 < x) - int(x < 0)) }
+sign_f32   :: proc(x: f32)   -> f32   { return f32(int(0 < x) - int(x < 0)) }
+sign_f32le :: proc(x: f32le) -> f32le { return f32le(int(0 < x) - int(x < 0)) }
+sign_f32be :: proc(x: f32be) -> f32be { return f32be(int(0 < x) - int(x < 0)) }
+sign_f64   :: proc(x: f64)   -> f64   { return f64(int(0 < x) - int(x < 0)) }
+sign_f64le :: proc(x: f64le) -> f64le { return f64le(int(0 < x) - int(x < 0)) }
+sign_f64be :: proc(x: f64be) -> f64be { return f64be(int(0 < x) - int(x < 0)) }
 sign       :: proc{
 	sign_f16, sign_f16le, sign_f16be,
 	sign_f32, sign_f32le, sign_f32be,
@@ -329,18 +329,18 @@ sign       :: proc{
 sign_bit_f16 :: proc(x: f16)     -> bool {
 	return (transmute(u16)x) & (1<<15) != 0
 }
-sign_bit_f16le :: proc(x: f16le) -> bool { return #force_inline sign_bit_f16(f16(x)); }
-sign_bit_f16be :: proc(x: f16be) -> bool { return #force_inline sign_bit_f16(f16(x)); }
+sign_bit_f16le :: proc(x: f16le) -> bool { return #force_inline sign_bit_f16(f16(x)) }
+sign_bit_f16be :: proc(x: f16be) -> bool { return #force_inline sign_bit_f16(f16(x)) }
 sign_bit_f32   :: proc(x: f32)   -> bool {
 	return (transmute(u32)x) & (1<<31) != 0
 }
-sign_bit_f32le :: proc(x: f32le) -> bool { return #force_inline sign_bit_f32(f32(x)); }
-sign_bit_f32be :: proc(x: f32be) -> bool { return #force_inline sign_bit_f32(f32(x)); }
+sign_bit_f32le :: proc(x: f32le) -> bool { return #force_inline sign_bit_f32(f32(x)) }
+sign_bit_f32be :: proc(x: f32be) -> bool { return #force_inline sign_bit_f32(f32(x)) }
 sign_bit_f64   :: proc(x: f64)   -> bool {
 	return (transmute(u64)x) & (1<<63) != 0
 }
-sign_bit_f64le :: proc(x: f64le) -> bool { return #force_inline sign_bit_f64(f64(x)); }
-sign_bit_f64be :: proc(x: f64be) -> bool { return #force_inline sign_bit_f64(f64(x)); }
+sign_bit_f64le :: proc(x: f64le) -> bool { return #force_inline sign_bit_f64(f64(x)) }
+sign_bit_f64be :: proc(x: f64be) -> bool { return #force_inline sign_bit_f64(f64(x)) }
 sign_bit       :: proc{
 	sign_bit_f16, sign_bit_f16le, sign_bit_f16be,
 	sign_bit_f32, sign_bit_f32le, sign_bit_f32be,
@@ -354,8 +354,8 @@ copy_sign_f16   :: proc(x, y: f16) -> f16 {
 	ix |= iy & 0x8000
 	return transmute(f16)ix
 }
-copy_sign_f16le :: proc(x, y: f16le) -> f16le { return #force_inline f16le(copy_sign_f16(f16(x), f16(y))); }
-copy_sign_f16be :: proc(x, y: f16be) -> f16be { return #force_inline f16be(copy_sign_f16(f16(x), f16(y))); }
+copy_sign_f16le :: proc(x, y: f16le) -> f16le { return #force_inline f16le(copy_sign_f16(f16(x), f16(y))) }
+copy_sign_f16be :: proc(x, y: f16be) -> f16be { return #force_inline f16be(copy_sign_f16(f16(x), f16(y))) }
 copy_sign_f32   :: proc(x, y: f32) -> f32 {
 	ix := transmute(u32)x
 	iy := transmute(u32)y
@@ -363,8 +363,8 @@ copy_sign_f32   :: proc(x, y: f32) -> f32 {
 	ix |= iy & 0x8000_0000
 	return transmute(f32)ix
 }
-copy_sign_f32le :: proc(x, y: f32le) -> f32le { return #force_inline f32le(copy_sign_f32(f32(x), f32(y))); }
-copy_sign_f32be :: proc(x, y: f32be) -> f32be { return #force_inline f32be(copy_sign_f32(f32(x), f32(y))); }
+copy_sign_f32le :: proc(x, y: f32le) -> f32le { return #force_inline f32le(copy_sign_f32(f32(x), f32(y))) }
+copy_sign_f32be :: proc(x, y: f32be) -> f32be { return #force_inline f32be(copy_sign_f32(f32(x), f32(y))) }
 copy_sign_f64   :: proc(x, y: f64) -> f64 {
 	ix := transmute(u64)x
 	iy := transmute(u64)y
@@ -372,32 +372,32 @@ copy_sign_f64   :: proc(x, y: f64) -> f64 {
 	ix |= iy & 0x8000_0000_0000_0000
 	return transmute(f64)ix
 }
-copy_sign_f64le :: proc(x, y: f64le) -> f64le { return #force_inline f64le(copy_sign_f64(f64(x), f64(y))); }
-copy_sign_f64be :: proc(x, y: f64be) -> f64be { return #force_inline f64be(copy_sign_f64(f64(x), f64(y))); }
+copy_sign_f64le :: proc(x, y: f64le) -> f64le { return #force_inline f64le(copy_sign_f64(f64(x), f64(y))) }
+copy_sign_f64be :: proc(x, y: f64be) -> f64be { return #force_inline f64be(copy_sign_f64(f64(x), f64(y))) }
 copy_sign       :: proc{
 	copy_sign_f16, copy_sign_f16le, copy_sign_f16be,
 	copy_sign_f32, copy_sign_f32le, copy_sign_f32be,
 	copy_sign_f64, copy_sign_f64le, copy_sign_f64be,
 }
 
-to_radians_f16   :: proc(degrees: f16)   -> f16   { return degrees * RAD_PER_DEG; }
-to_radians_f16le :: proc(degrees: f16le) -> f16le { return degrees * RAD_PER_DEG; }
-to_radians_f16be :: proc(degrees: f16be) -> f16be { return degrees * RAD_PER_DEG; }
-to_radians_f32   :: proc(degrees: f32)   -> f32   { return degrees * RAD_PER_DEG; }
-to_radians_f32le :: proc(degrees: f32le) -> f32le { return degrees * RAD_PER_DEG; }
-to_radians_f32be :: proc(degrees: f32be) -> f32be { return degrees * RAD_PER_DEG; }
-to_radians_f64   :: proc(degrees: f64)   -> f64   { return degrees * RAD_PER_DEG; }
-to_radians_f64le :: proc(degrees: f64le) -> f64le { return degrees * RAD_PER_DEG; }
-to_radians_f64be :: proc(degrees: f64be) -> f64be { return degrees * RAD_PER_DEG; }
-to_degrees_f16   :: proc(radians: f16)   -> f16   { return radians * DEG_PER_RAD; }
-to_degrees_f16le :: proc(radians: f16le) -> f16le { return radians * DEG_PER_RAD; }
-to_degrees_f16be :: proc(radians: f16be) -> f16be { return radians * DEG_PER_RAD; }
-to_degrees_f32   :: proc(radians: f32)   -> f32   { return radians * DEG_PER_RAD; }
-to_degrees_f32le :: proc(radians: f32le) -> f32le { return radians * DEG_PER_RAD; }
-to_degrees_f32be :: proc(radians: f32be) -> f32be { return radians * DEG_PER_RAD; }
-to_degrees_f64   :: proc(radians: f64)   -> f64   { return radians * DEG_PER_RAD; }
-to_degrees_f64le :: proc(radians: f64le) -> f64le { return radians * DEG_PER_RAD; }
-to_degrees_f64be :: proc(radians: f64be) -> f64be { return radians * DEG_PER_RAD; }
+to_radians_f16   :: proc(degrees: f16)   -> f16   { return degrees * RAD_PER_DEG }
+to_radians_f16le :: proc(degrees: f16le) -> f16le { return degrees * RAD_PER_DEG }
+to_radians_f16be :: proc(degrees: f16be) -> f16be { return degrees * RAD_PER_DEG }
+to_radians_f32   :: proc(degrees: f32)   -> f32   { return degrees * RAD_PER_DEG }
+to_radians_f32le :: proc(degrees: f32le) -> f32le { return degrees * RAD_PER_DEG }
+to_radians_f32be :: proc(degrees: f32be) -> f32be { return degrees * RAD_PER_DEG }
+to_radians_f64   :: proc(degrees: f64)   -> f64   { return degrees * RAD_PER_DEG }
+to_radians_f64le :: proc(degrees: f64le) -> f64le { return degrees * RAD_PER_DEG }
+to_radians_f64be :: proc(degrees: f64be) -> f64be { return degrees * RAD_PER_DEG }
+to_degrees_f16   :: proc(radians: f16)   -> f16   { return radians * DEG_PER_RAD }
+to_degrees_f16le :: proc(radians: f16le) -> f16le { return radians * DEG_PER_RAD }
+to_degrees_f16be :: proc(radians: f16be) -> f16be { return radians * DEG_PER_RAD }
+to_degrees_f32   :: proc(radians: f32)   -> f32   { return radians * DEG_PER_RAD }
+to_degrees_f32le :: proc(radians: f32le) -> f32le { return radians * DEG_PER_RAD }
+to_degrees_f32be :: proc(radians: f32be) -> f32be { return radians * DEG_PER_RAD }
+to_degrees_f64   :: proc(radians: f64)   -> f64   { return radians * DEG_PER_RAD }
+to_degrees_f64le :: proc(radians: f64le) -> f64le { return radians * DEG_PER_RAD }
+to_degrees_f64be :: proc(radians: f64be) -> f64be { return radians * DEG_PER_RAD }
 to_radians       :: proc{
 	to_radians_f16, to_radians_f16le, to_radians_f16be,
 	to_radians_f32, to_radians_f32le, to_radians_f32be,
@@ -438,8 +438,8 @@ trunc_f16   :: proc(x: f16) -> f16 {
 	}
 	return trunc_internal(x)
 }
-trunc_f16le :: proc(x: f16le) -> f16le { return #force_inline f16le(trunc_f16(f16(x))); }
-trunc_f16be :: proc(x: f16be) -> f16be { return #force_inline f16be(trunc_f16(f16(x))); }
+trunc_f16le :: proc(x: f16le) -> f16le { return #force_inline f16le(trunc_f16(f16(x))) }
+trunc_f16be :: proc(x: f16be) -> f16be { return #force_inline f16be(trunc_f16(f16(x))) }
 
 trunc_f32   :: proc(x: f32) -> f32 {
 	trunc_internal :: proc(f: f32) -> f32 {
@@ -470,8 +470,8 @@ trunc_f32   :: proc(x: f32) -> f32 {
 	}
 	return trunc_internal(x)
 }
-trunc_f32le :: proc(x: f32le) -> f32le { return #force_inline f32le(trunc_f32(f32(x))); }
-trunc_f32be :: proc(x: f32be) -> f32be { return #force_inline f32be(trunc_f32(f32(x))); }
+trunc_f32le :: proc(x: f32le) -> f32le { return #force_inline f32le(trunc_f32(f32(x))) }
+trunc_f32be :: proc(x: f32be) -> f32be { return #force_inline f32be(trunc_f32(f32(x))) }
 
 trunc_f64   :: proc(x: f64) -> f64 {
 	trunc_internal :: proc(f: f64) -> f64 {
@@ -502,8 +502,8 @@ trunc_f64   :: proc(x: f64) -> f64 {
 	}
 	return trunc_internal(x)
 }
-trunc_f64le :: proc(x: f64le) -> f64le { return #force_inline f64le(trunc_f64(f64(x))); }
-trunc_f64be :: proc(x: f64be) -> f64be { return #force_inline f64be(trunc_f64(f64(x))); }
+trunc_f64le :: proc(x: f64le) -> f64le { return #force_inline f64le(trunc_f64(f64(x))) }
+trunc_f64be :: proc(x: f64be) -> f64be { return #force_inline f64be(trunc_f64(f64(x))) }
 trunc       :: proc{
 	trunc_f16, trunc_f16le, trunc_f16be,
 	trunc_f32, trunc_f32le, trunc_f32be, 
@@ -545,17 +545,17 @@ round       :: proc{
 }
 
 
-ceil_f16   :: proc(x: f16)   -> f16   { return -floor(-x); }
-ceil_f16le :: proc(x: f16le) -> f16le { return -floor(-x); }
-ceil_f16be :: proc(x: f16be) -> f16be { return -floor(-x); }
+ceil_f16   :: proc(x: f16)   -> f16   { return -floor(-x) }
+ceil_f16le :: proc(x: f16le) -> f16le { return -floor(-x) }
+ceil_f16be :: proc(x: f16be) -> f16be { return -floor(-x) }
 
-ceil_f32   :: proc(x: f32)   -> f32   { return -floor(-x); }
-ceil_f32le :: proc(x: f32le) -> f32le { return -floor(-x); }
-ceil_f32be :: proc(x: f32be) -> f32be { return -floor(-x); }
+ceil_f32   :: proc(x: f32)   -> f32   { return -floor(-x) }
+ceil_f32le :: proc(x: f32le) -> f32le { return -floor(-x) }
+ceil_f32be :: proc(x: f32be) -> f32be { return -floor(-x) }
 
-ceil_f64   :: proc(x: f64)   -> f64   { return -floor(-x); }
-ceil_f64le :: proc(x: f64le) -> f64le { return -floor(-x); }
-ceil_f64be :: proc(x: f64be) -> f64be { return -floor(-x); }
+ceil_f64   :: proc(x: f64)   -> f64   { return -floor(-x) }
+ceil_f64le :: proc(x: f64le) -> f64le { return -floor(-x) }
+ceil_f64be :: proc(x: f64be) -> f64be { return -floor(-x) }
 
 ceil       :: proc{
 	ceil_f16, ceil_f16le, ceil_f16be,
@@ -577,8 +577,8 @@ floor_f16   :: proc(x: f16)   -> f16 {
 	d, _ := modf(x)
 	return d
 }
-floor_f16le :: proc(x: f16le) -> f16le { return #force_inline f16le(floor_f16(f16(x))); }
-floor_f16be :: proc(x: f16be) -> f16be { return #force_inline f16be(floor_f16(f16(x))); }
+floor_f16le :: proc(x: f16le) -> f16le { return #force_inline f16le(floor_f16(f16(x))) }
+floor_f16be :: proc(x: f16be) -> f16be { return #force_inline f16be(floor_f16(f16(x))) }
 floor_f32   :: proc(x: f32)   -> f32 {
 	if x == 0 || is_nan(x) || is_inf(x) {
 		return x
@@ -593,8 +593,8 @@ floor_f32   :: proc(x: f32)   -> f32 {
 	d, _ := modf(x)
 	return d
 }
-floor_f32le :: proc(x: f32le) -> f32le { return #force_inline f32le(floor_f32(f32(x))); }
-floor_f32be :: proc(x: f32be) -> f32be { return #force_inline f32be(floor_f32(f32(x))); }
+floor_f32le :: proc(x: f32le) -> f32le { return #force_inline f32le(floor_f32(f32(x))) }
+floor_f32be :: proc(x: f32be) -> f32be { return #force_inline f32be(floor_f32(f32(x))) }
 floor_f64   :: proc(x: f64)   -> f64 {
 	if x == 0 || is_nan(x) || is_inf(x) {
 		return x
@@ -609,8 +609,8 @@ floor_f64   :: proc(x: f64)   -> f64 {
 	d, _ := modf(x)
 	return d
 }
-floor_f64le :: proc(x: f64le) -> f64le { return #force_inline f64le(floor_f64(f64(x))); }
-floor_f64be :: proc(x: f64be) -> f64be { return #force_inline f64be(floor_f64(f64(x))); }
+floor_f64le :: proc(x: f64le) -> f64le { return #force_inline f64le(floor_f64(f64(x))) }
+floor_f64be :: proc(x: f64be) -> f64be { return #force_inline f64be(floor_f64(f64(x))) }
 floor       :: proc{
 	floor_f16, floor_f16le, floor_f16be,
 	floor_f32, floor_f32le, floor_f32be,
@@ -754,8 +754,8 @@ mod_f16   :: proc(x, y: f16) -> (n: f16) {
 	}
 	return copy_sign(n, x)
 }
-mod_f16le :: proc(x, y: f16le) -> (n: f16le) { return #force_inline f16le(mod_f16(f16(x), f16(y))); }
-mod_f16be :: proc(x, y: f16be) -> (n: f16be) { return #force_inline f16be(mod_f16(f16(x), f16(y))); }
+mod_f16le :: proc(x, y: f16le) -> (n: f16le) { return #force_inline f16le(mod_f16(f16(x), f16(y))) }
+mod_f16be :: proc(x, y: f16be) -> (n: f16be) { return #force_inline f16be(mod_f16(f16(x), f16(y))) }
 mod_f32   :: proc(x, y: f32)   -> (n: f32) {
 	z := abs(y)
 	n = remainder(abs(x), z)
@@ -764,8 +764,8 @@ mod_f32   :: proc(x, y: f32)   -> (n: f32) {
 	}
 	return copy_sign(n, x)
 }
-mod_f32le :: proc(x, y: f32le) -> (n: f32le) { return #force_inline f32le(mod_f32(f32(x), f32(y))); }
-mod_f32be :: proc(x, y: f32be) -> (n: f32be) { return #force_inline f32be(mod_f32(f32(x), f32(y))); }
+mod_f32le :: proc(x, y: f32le) -> (n: f32le) { return #force_inline f32le(mod_f32(f32(x), f32(y))) }
+mod_f32be :: proc(x, y: f32be) -> (n: f32be) { return #force_inline f32be(mod_f32(f32(x), f32(y))) }
 mod_f64   :: proc(x, y: f64)   -> (n: f64) {
 	z := abs(y)
 	n = remainder(abs(x), z)
@@ -774,23 +774,23 @@ mod_f64   :: proc(x, y: f64)   -> (n: f64) {
 	}
 	return copy_sign(n, x)
 }
-mod_f64le :: proc(x, y: f64le) -> (n: f64le) { return #force_inline f64le(mod_f64(f64(x), f64(y))); }
-mod_f64be :: proc(x, y: f64be) -> (n: f64be) { return #force_inline f64be(mod_f64(f64(x), f64(y))); }
+mod_f64le :: proc(x, y: f64le) -> (n: f64le) { return #force_inline f64le(mod_f64(f64(x), f64(y))) }
+mod_f64be :: proc(x, y: f64be) -> (n: f64be) { return #force_inline f64be(mod_f64(f64(x), f64(y))) }
 mod       :: proc{
 	mod_f16, mod_f16le, mod_f16be,
 	mod_f32, mod_f32le, mod_f32be,
 	mod_f64, mod_f64le, mod_f64be,
 }
 
-remainder_f16   :: proc(x, y: f16  ) -> f16   { return x - round(x/y) * y; }
-remainder_f16le :: proc(x, y: f16le) -> f16le { return x - round(x/y) * y; }
-remainder_f16be :: proc(x, y: f16be) -> f16be { return x - round(x/y) * y; }
-remainder_f32   :: proc(x, y: f32  ) -> f32   { return x - round(x/y) * y; }
-remainder_f32le :: proc(x, y: f32le) -> f32le { return x - round(x/y) * y; }
-remainder_f32be :: proc(x, y: f32be) -> f32be { return x - round(x/y) * y; }
-remainder_f64   :: proc(x, y: f64  ) -> f64   { return x - round(x/y) * y; }
-remainder_f64le :: proc(x, y: f64le) -> f64le { return x - round(x/y) * y; }
-remainder_f64be :: proc(x, y: f64be) -> f64be { return x - round(x/y) * y; }
+remainder_f16   :: proc(x, y: f16  ) -> f16   { return x - round(x/y) * y }
+remainder_f16le :: proc(x, y: f16le) -> f16le { return x - round(x/y) * y }
+remainder_f16be :: proc(x, y: f16be) -> f16be { return x - round(x/y) * y }
+remainder_f32   :: proc(x, y: f32  ) -> f32   { return x - round(x/y) * y }
+remainder_f32le :: proc(x, y: f32le) -> f32le { return x - round(x/y) * y }
+remainder_f32be :: proc(x, y: f32be) -> f32be { return x - round(x/y) * y }
+remainder_f64   :: proc(x, y: f64  ) -> f64   { return x - round(x/y) * y }
+remainder_f64le :: proc(x, y: f64le) -> f64le { return x - round(x/y) * y }
+remainder_f64be :: proc(x, y: f64be) -> f64be { return x - round(x/y) * y }
 remainder       :: proc{
 	remainder_f16, remainder_f16le, remainder_f16be,
 	remainder_f32, remainder_f32le, remainder_f32be,
@@ -958,8 +958,8 @@ classify_f16   :: proc(x: f16)   -> Float_Class {
 	}
 	return .Normal
 }
-classify_f16le :: proc(x: f16le) -> Float_Class { return #force_inline classify_f16(f16(x)); }
-classify_f16be :: proc(x: f16be) -> Float_Class { return #force_inline classify_f16(f16(x)); }
+classify_f16le :: proc(x: f16le) -> Float_Class { return #force_inline classify_f16(f16(x)) }
+classify_f16be :: proc(x: f16be) -> Float_Class { return #force_inline classify_f16(f16(x)) }
 classify_f32   :: proc(x: f32)   -> Float_Class {
 	switch {
 	case x == 0:
@@ -984,8 +984,8 @@ classify_f32   :: proc(x: f32)   -> Float_Class {
 	}
 	return .Normal
 }
-classify_f32le :: proc(x: f32le) -> Float_Class { return #force_inline classify_f32(f32(x)); }
-classify_f32be :: proc(x: f32be) -> Float_Class { return #force_inline classify_f32(f32(x)); }
+classify_f32le :: proc(x: f32le) -> Float_Class { return #force_inline classify_f32(f32(x)) }
+classify_f32be :: proc(x: f32be) -> Float_Class { return #force_inline classify_f32(f32(x)) }
 classify_f64   :: proc(x: f64)   -> Float_Class {
 	switch {
 	case x == 0:
@@ -1009,23 +1009,23 @@ classify_f64   :: proc(x: f64)   -> Float_Class {
 	}
 	return .Normal
 }
-classify_f64le :: proc(x: f64le) -> Float_Class { return #force_inline classify_f64(f64(x)); }
-classify_f64be :: proc(x: f64be) -> Float_Class { return #force_inline classify_f64(f64(x)); }
+classify_f64le :: proc(x: f64le) -> Float_Class { return #force_inline classify_f64(f64(x)) }
+classify_f64be :: proc(x: f64be) -> Float_Class { return #force_inline classify_f64(f64(x)) }
 classify       :: proc{
 	classify_f16, classify_f16le, classify_f16be,
 	classify_f32, classify_f32le, classify_f32be,
 	classify_f64, classify_f64le, classify_f64be,
 }
 
-is_nan_f16   :: proc(x: f16)   -> bool { return classify(x) == .NaN; }
-is_nan_f16le :: proc(x: f16le) -> bool { return classify(x) == .NaN; }
-is_nan_f16be :: proc(x: f16be) -> bool { return classify(x) == .NaN; }
-is_nan_f32   :: proc(x: f32)   -> bool { return classify(x) == .NaN; }
-is_nan_f32le :: proc(x: f32le) -> bool { return classify(x) == .NaN; }
-is_nan_f32be :: proc(x: f32be) -> bool { return classify(x) == .NaN; }
-is_nan_f64   :: proc(x: f64)   -> bool { return classify(x) == .NaN; }
-is_nan_f64le :: proc(x: f64le) -> bool { return classify(x) == .NaN; }
-is_nan_f64be :: proc(x: f64be) -> bool { return classify(x) == .NaN; }
+is_nan_f16   :: proc(x: f16)   -> bool { return classify(x) == .NaN }
+is_nan_f16le :: proc(x: f16le) -> bool { return classify(x) == .NaN }
+is_nan_f16be :: proc(x: f16be) -> bool { return classify(x) == .NaN }
+is_nan_f32   :: proc(x: f32)   -> bool { return classify(x) == .NaN }
+is_nan_f32le :: proc(x: f32le) -> bool { return classify(x) == .NaN }
+is_nan_f32be :: proc(x: f32be) -> bool { return classify(x) == .NaN }
+is_nan_f64   :: proc(x: f64)   -> bool { return classify(x) == .NaN }
+is_nan_f64le :: proc(x: f64le) -> bool { return classify(x) == .NaN }
+is_nan_f64be :: proc(x: f64be) -> bool { return classify(x) == .NaN }
 is_nan       :: proc{
 	is_nan_f16, is_nan_f16le, is_nan_f16be,
 	is_nan_f32, is_nan_f32le, is_nan_f32be,

core/math/rand/rand.odin

@@ -43,7 +43,7 @@ _random :: proc(r: ^Rand) -> u32 {
 	return (xor_shifted >> rot) | (xor_shifted << ((-rot) & 31))
 }
 
-uint32 :: proc(r: ^Rand = nil) -> u32 { return _random(r); }
+uint32 :: proc(r: ^Rand = nil) -> u32 { return _random(r) }
 
 uint64 :: proc(r: ^Rand = nil) -> u64 {
 	a := u64(_random(r))
@@ -59,9 +59,9 @@ uint128 :: proc(r: ^Rand = nil) -> u128 {
 	return (a<<96) | (b<<64) | (c<<32) | d
 }
 
-int31  :: proc(r: ^Rand = nil) -> i32  { return i32(uint32(r) << 1 >> 1); }
-int63  :: proc(r: ^Rand = nil) -> i64  { return i64(uint64(r) << 1 >> 1); }
-int127 :: proc(r: ^Rand = nil) -> i128 { return i128(uint128(r) << 1 >> 1); }
+int31  :: proc(r: ^Rand = nil) -> i32  { return i32(uint32(r) << 1 >> 1) }
+int63  :: proc(r: ^Rand = nil) -> i64  { return i64(uint64(r) << 1 >> 1) }
+int127 :: proc(r: ^Rand = nil) -> i128 { return i128(uint128(r) << 1 >> 1) }
 
 int31_max :: proc(n: i32, r: ^Rand = nil) -> i32 {
 	if n <= 0 {
@@ -119,11 +119,11 @@ int_max :: proc(n: int, r: ^Rand = nil) -> int {
 	}
 }
 
-float64 :: proc(r: ^Rand = nil) -> f64 { return f64(int63_max(1<<53, r)) / (1 << 53); }
-float32 :: proc(r: ^Rand = nil) -> f32 { return f32(float64(r)); }
+float64 :: proc(r: ^Rand = nil) -> f64 { return f64(int63_max(1<<53, r)) / (1 << 53) }
+float32 :: proc(r: ^Rand = nil) -> f32 { return f32(float64(r)) }
 
-float64_range :: proc(lo, hi: f64, r: ^Rand = nil) -> f64 { return (hi-lo)*float64(r) + lo; }
-float32_range :: proc(lo, hi: f32, r: ^Rand = nil) -> f32 { return (hi-lo)*float32(r) + lo; }
+float64_range :: proc(lo, hi: f64, r: ^Rand = nil) -> f64 { return (hi-lo)*float64(r) + lo }
+float32_range :: proc(lo, hi: f32, r: ^Rand = nil) -> f32 { return (hi-lo)*float32(r) + lo }
 
 
 read :: proc(p: []byte, r: ^Rand = nil) -> (n: int) {

core/mem/mem.odin

@@ -184,10 +184,10 @@ any_to_bytes :: proc(val: any) -> []byte {
 }
 
 
-kilobytes :: proc(x: int) -> int { return          (x) * 1024; }
-megabytes :: proc(x: int) -> int { return kilobytes(x) * 1024; }
-gigabytes :: proc(x: int) -> int { return megabytes(x) * 1024; }
-terabytes :: proc(x: int) -> int { return gigabytes(x) * 1024; }
+kilobytes :: proc(x: int) -> int { return          (x) * 1024 }
+megabytes :: proc(x: int) -> int { return kilobytes(x) * 1024 }
+gigabytes :: proc(x: int) -> int { return megabytes(x) * 1024 }
+terabytes :: proc(x: int) -> int { return gigabytes(x) * 1024 }
 
 is_power_of_two :: proc(x: uintptr) -> bool {
 	if x <= 0 {

core/odin/parser/parser.odin

@@ -1051,13 +1051,13 @@ parse_attribute :: proc(p: ^Parser, tok: tokenizer.Token, open_kind, close_kind:
 	decl := parse_stmt(p)
 	switch d in &decl.derived {
 	case ast.Value_Decl:
-		if d.docs == nil { d.docs = docs; }
+		if d.docs == nil { d.docs = docs }
 		append(&d.attributes, attribute)
 	case ast.Foreign_Block_Decl:
-		if d.docs == nil { d.docs = docs; }
+		if d.docs == nil { d.docs = docs }
 		append(&d.attributes, attribute)
 	case ast.Foreign_Import_Decl:
-		if d.docs == nil { d.docs = docs; }
+		if d.docs == nil { d.docs = docs }
 		append(&d.attributes, attribute)
 	case:
 		error(p, decl.pos, "expected a value or foreign declaration after an attribute")
@@ -1693,20 +1693,20 @@ parse_field_prefixes :: proc(p: ^Parser) -> ast.Field_Flags {
 		switch kind {
 		case .Invalid, .Unknown: // Ignore
 		case .Using:
-			if count > 1 { error(p, p.curr_tok.pos, "multiple 'using' in this field list"); }
-			if count > 0 { flags += {.Using}; }
+			if count > 1 { error(p, p.curr_tok.pos, "multiple 'using' in this field list") }
+			if count > 0 { flags += {.Using} }
 		case .No_Alias:
-			if count > 1 { error(p, p.curr_tok.pos, "multiple '#no_alias' in this field list"); }
-			if count > 0 { flags += {.No_Alias}; }
+			if count > 1 { error(p, p.curr_tok.pos, "multiple '#no_alias' in this field list") }
+			if count > 0 { flags += {.No_Alias} }
 		case .C_Vararg:
-			if count > 1 { error(p, p.curr_tok.pos, "multiple '#c_vararg' in this field list"); }
-			if count > 0 { flags += {.C_Vararg}; }
+			if count > 1 { error(p, p.curr_tok.pos, "multiple '#c_vararg' in this field list") }
+			if count > 0 { flags += {.C_Vararg} }
 		case .Auto_Cast:
-			if count > 1 { error(p, p.curr_tok.pos, "multiple 'auto_cast' in this field list"); }
-			if count > 0 { flags += {.Auto_Cast}; }
+			if count > 1 { error(p, p.curr_tok.pos, "multiple 'auto_cast' in this field list") }
+			if count > 0 { flags += {.Auto_Cast} }
 		case .Any_Int:
-			if count > 1 { error(p, p.curr_tok.pos, "multiple '#any_int' in this field list"); }
-			if count > 0 { flags += {.Any_Int}; }
+			if count > 1 { error(p, p.curr_tok.pos, "multiple '#any_int' in this field list") }
+			if count > 0 { flags += {.Any_Int} }
 		}
 	}
 

core/os/stat_windows.odin

@@ -108,7 +108,7 @@ cleanpath_strip_prefix :: proc(buf: []u16) -> []u16 {
 	buf := buf
 	N := 0
 	for c, i in buf {
-		if c == 0 { break; }
+		if c == 0 { break }
 		N = i+1
 	}
 	buf = buf[:N]

core/reflect/reflect.odin

@@ -117,7 +117,7 @@ backing_type_kind :: proc(T: typeid) -> Type_Kind {
 
 
 type_info_base :: proc(info: ^Type_Info) -> ^Type_Info {
-	if info == nil { return nil; }
+	if info == nil { return nil }
 
 	base := info
 	loop: for {
@@ -131,7 +131,7 @@ type_info_base :: proc(info: ^Type_Info) -> ^Type_Info {
 
 
 type_info_core :: proc(info: ^Type_Info) -> ^Type_Info {
-	if info == nil { return nil; }
+	if info == nil { return nil }
 
 	base := info
 	loop: for {
@@ -159,7 +159,7 @@ typeid_base_without_enum :: typeid_core
 
 typeid_elem :: proc(id: typeid) -> typeid {
 	ti := type_info_of(id)
-	if ti == nil { return nil; }
+	if ti == nil { return nil }
 
 	bits := 8*ti.size
 
@@ -228,7 +228,7 @@ is_nil :: proc(v: any) -> bool {
 }
 
 length :: proc(val: any) -> int {
-	if val == nil { return 0; }
+	if val == nil { return 0 }
 
 	#partial switch a in type_info_of(val.id).variant {
 	case Type_Info_Named:
@@ -263,7 +263,7 @@ length :: proc(val: any) -> int {
 }
 
 capacity :: proc(val: any) -> int {
-	if val == nil { return 0; }
+	if val == nil { return 0 }
 
 	#partial switch a in type_info_of(val.id).variant {
 	case Type_Info_Named:
@@ -289,7 +289,7 @@ capacity :: proc(val: any) -> int {
 
 
 index :: proc(val: any, i: int, loc := #caller_location) -> any {
-	if val == nil { return nil; }
+	if val == nil { return nil }
 
 	#partial switch a in type_info_of(val.id).variant {
 	case Type_Info_Named:
@@ -336,7 +336,7 @@ index :: proc(val: any, i: int, loc := #caller_location) -> any {
 		return any{data, a.elem.id}
 
 	case Type_Info_String:
-		if a.is_cstring { return nil; }
+		if a.is_cstring { return nil }
 
 		raw := (^mem.Raw_String)(val.data)
 		runtime.bounds_check_error_loc(loc, i, raw.len)
@@ -395,7 +395,7 @@ struct_field_by_name :: proc(T: typeid, name: string) -> (field: Struct_Field) {
 }
 
 struct_field_value_by_name :: proc(a: any, field: string, allow_using := false) -> any {
-	if a == nil { return nil; }
+	if a == nil { return nil }
 
 	ti := runtime.type_info_base(type_info_of(a.id))
 
@@ -538,7 +538,7 @@ struct_tag_lookup :: proc(tag: Struct_Tag, key: string) -> (value: Struct_Tag, o
 
 
 enum_string :: proc(a: any) -> string {
-	if a == nil { return ""; }
+	if a == nil { return "" }
 	ti := runtime.type_info_base(type_info_of(a.id))
 	if e, ok := ti.variant.(runtime.Type_Info_Enum); ok {
 		v, _ := as_i64(a)
@@ -627,7 +627,7 @@ type_info_union_is_pure_maybe :: proc(info: runtime.Type_Info_Union) -> bool {
 }
 
 union_variant_typeid :: proc(a: any) -> typeid {
-	if a == nil { return nil; }
+	if a == nil { return nil }
 
 	ti := runtime.type_info_base(type_info_of(a.id))
 	if info, ok := ti.variant.(runtime.Type_Info_Union); ok {
@@ -666,7 +666,7 @@ union_variant_typeid :: proc(a: any) -> typeid {
 }
 
 get_union_variant_raw_tag :: proc(a: any) -> i64 {
-	if a == nil { return -1; }
+	if a == nil { return -1 }
 
 	ti := runtime.type_info_base(type_info_of(a.id))
 	if info, ok := ti.variant.(runtime.Type_Info_Union); ok {
@@ -697,7 +697,7 @@ get_union_variant_raw_tag :: proc(a: any) -> i64 {
 
 
 set_union_variant_raw_tag :: proc(a: any, tag: i64) {
-	if a == nil { return; }
+	if a == nil { return }
 
 	ti := runtime.type_info_base(type_info_of(a.id))
 	if info, ok := ti.variant.(runtime.Type_Info_Union); ok {
@@ -727,7 +727,7 @@ set_union_variant_raw_tag :: proc(a: any, tag: i64) {
 }
 
 set_union_variant_typeid :: proc(a: any, id: typeid) {
-	if a == nil { return; }
+	if a == nil { return }
 
 	ti := runtime.type_info_base(type_info_of(a.id))
 	if info, ok := ti.variant.(runtime.Type_Info_Union); ok {
@@ -757,7 +757,7 @@ set_union_variant_typeid :: proc(a: any, id: typeid) {
 }
 
 set_union_variant_type_info :: proc(a: any, tag_ti: ^Type_Info) {
-	if a == nil { return; }
+	if a == nil { return }
 
 	ti := runtime.type_info_base(type_info_of(a.id))
 	if info, ok := ti.variant.(runtime.Type_Info_Union); ok {
@@ -788,7 +788,7 @@ set_union_variant_type_info :: proc(a: any, tag_ti: ^Type_Info) {
 
 
 as_bool :: proc(a: any) -> (value: bool, valid: bool) {
-	if a == nil { return; }
+	if a == nil { return }
 	a := a
 	ti := runtime.type_info_core(type_info_of(a.id))
 	a.id = ti.id
@@ -824,7 +824,7 @@ as_uint :: proc(a: any) -> (value: uint, valid: bool) {
 }
 
 as_i64 :: proc(a: any) -> (value: i64, valid: bool) {
-	if a == nil { return; }
+	if a == nil { return }
 	a := a
 	ti := runtime.type_info_core(type_info_of(a.id))
 	a.id = ti.id
@@ -931,7 +931,7 @@ as_i64 :: proc(a: any) -> (value: i64, valid: bool) {
 }
 
 as_u64 :: proc(a: any) -> (value: u64, valid: bool) {
-	if a == nil { return; }
+	if a == nil { return }
 	a := a
 	ti := runtime.type_info_core(type_info_of(a.id))
 	a.id = ti.id
@@ -1039,7 +1039,7 @@ as_u64 :: proc(a: any) -> (value: u64, valid: bool) {
 
 
 as_f64 :: proc(a: any) -> (value: f64, valid: bool) {
-	if a == nil { return; }
+	if a == nil { return }
 	a := a
 	ti := runtime.type_info_core(type_info_of(a.id))
 	a.id = ti.id
@@ -1144,7 +1144,7 @@ as_f64 :: proc(a: any) -> (value: f64, valid: bool) {
 
 
 as_string :: proc(a: any) -> (value: string, valid: bool) {
-	if a == nil { return; }
+	if a == nil { return }
 	a := a
 	ti := runtime.type_info_core(type_info_of(a.id))
 	a.id = ti.id
@@ -1163,7 +1163,7 @@ as_string :: proc(a: any) -> (value: string, valid: bool) {
 }
 
 relative_pointer_to_absolute :: proc(a: any) -> rawptr {
-	if a == nil { return nil; }
+	if a == nil { return nil }
 	a := a
 	ti := runtime.type_info_core(type_info_of(a.id))
 	a.id = ti.id
@@ -1219,7 +1219,7 @@ relative_pointer_to_absolute_raw :: proc(data: rawptr, base_integer_id: typeid)
 
 
 as_pointer :: proc(a: any) -> (value: rawptr, valid: bool) {
-	if a == nil { return; }
+	if a == nil { return }
 	a := a
 	ti := runtime.type_info_core(type_info_of(a.id))
 	a.id = ti.id
@@ -1246,7 +1246,7 @@ as_pointer :: proc(a: any) -> (value: rawptr, valid: bool) {
 
 
 as_raw_data :: proc(a: any) -> (value: rawptr, valid: bool) {
-	if a == nil { return; }
+	if a == nil { return }
 	a := a
 	ti := runtime.type_info_core(type_info_of(a.id))
 	a.id = ti.id

core/reflect/types.odin

@@ -80,12 +80,12 @@ are_types_identical :: proc(a, b: ^Type_Info) -> bool {
 
 	case Type_Info_Array:
 		y := b.variant.(Type_Info_Array) or_return
-		if x.count != y.count { return false; }
+		if x.count != y.count { return false }
 		return are_types_identical(x.elem, y.elem)
 
 	case Type_Info_Enumerated_Array:
 		y := b.variant.(Type_Info_Enumerated_Array) or_return
-		if x.count != y.count { return false; }
+		if x.count != y.count { return false }
 		return are_types_identical(x.index, y.index) &&
 		       are_types_identical(x.elem, y.elem)
 
@@ -99,7 +99,7 @@ are_types_identical :: proc(a, b: ^Type_Info) -> bool {
 
 	case Type_Info_Tuple:
 		y := b.variant.(Type_Info_Tuple) or_return
-		if len(x.types) != len(y.types) { return false; }
+		if len(x.types) != len(y.types) { return false }
 		for _, i in x.types {
 			xt, yt := x.types[i], y.types[i]
 			if !are_types_identical(xt, yt) {
@@ -125,19 +125,19 @@ are_types_identical :: proc(a, b: ^Type_Info) -> bool {
 			xt, yt := x.types[i], y.types[i]
 			xl, yl := x.tags[i],  y.tags[i]
 
-			if xn != yn { return false; }
-			if !are_types_identical(xt, yt) { return false; }
-			if xl != yl { return false; }
+			if xn != yn { return false }
+			if !are_types_identical(xt, yt) { return false }
+			if xl != yl { return false }
 		}
 		return true
 
 	case Type_Info_Union:
 		y := b.variant.(Type_Info_Union) or_return
-		if len(x.variants) != len(y.variants) { return false; }
+		if len(x.variants) != len(y.variants) { return false }
 
 		for _, i in x.variants {
 			xv, yv := x.variants[i], y.variants[i]
-			if !are_types_identical(xv, yv) { return false; }
+			if !are_types_identical(xv, yv) { return false }
 		}
 		return true
 
@@ -170,7 +170,7 @@ are_types_identical :: proc(a, b: ^Type_Info) -> bool {
 }
 
 is_signed :: proc(info: ^Type_Info) -> bool {
-	if info == nil { return false; }
+	if info == nil { return false }
 	#partial switch i in type_info_base(info).variant {
 	case Type_Info_Integer: return i.signed
 	case Type_Info_Float:   return true
@@ -178,7 +178,7 @@ is_signed :: proc(info: ^Type_Info) -> bool {
 	return false
 }
 is_unsigned :: proc(info: ^Type_Info) -> bool {
-	if info == nil { return false; }
+	if info == nil { return false }
 	#partial switch i in type_info_base(info).variant {
 	case Type_Info_Integer: return !i.signed
 	case Type_Info_Float:   return false
@@ -187,7 +187,7 @@ is_unsigned :: proc(info: ^Type_Info) -> bool {
 }
 
 is_byte :: proc(info: ^Type_Info) -> bool {
-	if info == nil { return false; }
+	if info == nil { return false }
 	#partial switch i in type_info_base(info).variant {
 	case Type_Info_Integer: return info.size == 1
 	}
@@ -196,127 +196,127 @@ is_byte :: proc(info: ^Type_Info) -> bool {
 
 
 is_integer :: proc(info: ^Type_Info) -> bool {
-	if info == nil { return false; }
+	if info == nil { return false }
 	_, ok := type_info_base(info).variant.(Type_Info_Integer)
 	return ok
 }
 is_rune :: proc(info: ^Type_Info) -> bool {
-	if info == nil { return false; }
+	if info == nil { return false }
 	_, ok := type_info_base(info).variant.(Type_Info_Rune)
 	return ok
 }
 is_float :: proc(info: ^Type_Info) -> bool {
-	if info == nil { return false; }
+	if info == nil { return false }
 	_, ok := type_info_base(info).variant.(Type_Info_Float)
 	return ok
 }
 is_complex :: proc(info: ^Type_Info) -> bool {
-	if info == nil { return false; }
+	if info == nil { return false }
 	_, ok := type_info_base(info).variant.(Type_Info_Complex)
 	return ok
 }
 is_quaternion :: proc(info: ^Type_Info) -> bool {
-	if info == nil { return false; }
+	if info == nil { return false }
 	_, ok := type_info_base(info).variant.(Type_Info_Quaternion)
 	return ok
 }
 is_any :: proc(info: ^Type_Info) -> bool {
-	if info == nil { return false; }
+	if info == nil { return false }
 	_, ok := type_info_base(info).variant.(Type_Info_Any)
 	return ok
 }
 is_string :: proc(info: ^Type_Info) -> bool {
-	if info == nil { return false; }
+	if info == nil { return false }
 	_, ok := type_info_base(info).variant.(Type_Info_String)
 	return ok
 }
 is_cstring :: proc(info: ^Type_Info) -> bool {
-	if info == nil { return false; }
+	if info == nil { return false }
 	v, ok := type_info_base(info).variant.(Type_Info_String)
 	return ok && v.is_cstring
 }
 is_boolean :: proc(info: ^Type_Info) -> bool {
-	if info == nil { return false; }
+	if info == nil { return false }
 	_, ok := type_info_base(info).variant.(Type_Info_Boolean)
 	return ok
 }
 is_pointer :: proc(info: ^Type_Info) -> bool {
-	if info == nil { return false; }
+	if info == nil { return false }
 	_, ok := type_info_base(info).variant.(Type_Info_Pointer)
 	return ok
 }
 is_multi_pointer :: proc(info: ^Type_Info) -> bool {
-	if info == nil { return false; }
+	if info == nil { return false }
 	_, ok := type_info_base(info).variant.(Type_Info_Multi_Pointer)
 	return ok
 }
 is_procedure :: proc(info: ^Type_Info) -> bool {
-	if info == nil { return false; }
+	if info == nil { return false }
 	_, ok := type_info_base(info).variant.(Type_Info_Procedure)
 	return ok
 }
 is_array :: proc(info: ^Type_Info) -> bool {
-	if info == nil { return false; }
+	if info == nil { return false }
 	_, ok := type_info_base(info).variant.(Type_Info_Array)
 	return ok
 }
 is_enumerated_array :: proc(info: ^Type_Info) -> bool {
-	if info == nil { return false; }
+	if info == nil { return false }
 	_, ok := type_info_base(info).variant.(Type_Info_Enumerated_Array)
 	return ok
 }
 is_dynamic_array :: proc(info: ^Type_Info) -> bool {
-	if info == nil { return false; }
+	if info == nil { return false }
 	_, ok := type_info_base(info).variant.(Type_Info_Dynamic_Array)
 	return ok
 }
 is_dynamic_map :: proc(info: ^Type_Info) -> bool {
-	if info == nil { return false; }
+	if info == nil { return false }
 	_, ok := type_info_base(info).variant.(Type_Info_Map)
 	return ok
 }
 is_slice :: proc(info: ^Type_Info) -> bool {
-	if info == nil { return false; }
+	if info == nil { return false }
 	_, ok := type_info_base(info).variant.(Type_Info_Slice)
 	return ok
 }
 is_tuple :: proc(info: ^Type_Info) -> bool {
-	if info == nil { return false; }
+	if info == nil { return false }
 	_, ok := type_info_base(info).variant.(Type_Info_Tuple)
 	return ok
 }
 is_struct :: proc(info: ^Type_Info) -> bool {
-	if info == nil { return false; }
+	if info == nil { return false }
 	s, ok := type_info_base(info).variant.(Type_Info_Struct)
 	return ok && !s.is_raw_union
 }
 is_raw_union :: proc(info: ^Type_Info) -> bool {
-	if info == nil { return false; }
+	if info == nil { return false }
 	s, ok := type_info_base(info).variant.(Type_Info_Struct)
 	return ok && s.is_raw_union
 }
 is_union :: proc(info: ^Type_Info) -> bool {
-	if info == nil { return false; }
+	if info == nil { return false }
 	_, ok := type_info_base(info).variant.(Type_Info_Union)
 	return ok
 }
 is_enum :: proc(info: ^Type_Info) -> bool {
-	if info == nil { return false; }
+	if info == nil { return false }
 	_, ok := type_info_base(info).variant.(Type_Info_Enum)
 	return ok
 }
 is_simd_vector :: proc(info: ^Type_Info) -> bool {
-	if info == nil { return false; }
+	if info == nil { return false }
 	_, ok := type_info_base(info).variant.(Type_Info_Simd_Vector)
 	return ok
 }
 is_relative_pointer :: proc(info: ^Type_Info) -> bool {
-	if info == nil { return false; }
+	if info == nil { return false }
 	_, ok := type_info_base(info).variant.(Type_Info_Relative_Pointer)
 	return ok
 }
 is_relative_slice :: proc(info: ^Type_Info) -> bool {
-	if info == nil { return false; }
+	if info == nil { return false }
 	_, ok := type_info_base(info).variant.(Type_Info_Relative_Slice)
 	return ok
 }
@@ -354,8 +354,8 @@ write_type_writer :: proc(w: io.Writer, ti: ^Type_Info) -> (n: int) {
 		return write_string(w, "nil")
 	}
 
-	_n1 :: proc(err: io.Error) -> int { return 1 if err == nil else 0; }
-	_n2 :: proc(n: int, _: io.Error) -> int { return n; }
+	_n1 :: proc(err: io.Error) -> int { return 1 if err == nil else 0 }
+	_n2 :: proc(n: int, _: io.Error) -> int { return n }
 	_n :: proc{_n1, _n2}
 
 	switch info in ti.variant {
@@ -441,9 +441,9 @@ write_type_writer :: proc(w: io.Writer, ti: ^Type_Info) -> (n: int) {
 		}
 	case Type_Info_Tuple:
 		count := len(info.names)
-		if count != 1 { n += write_string(w, "("); }
+		if count != 1 { n += write_string(w, "(") }
 		for name, i in info.names {
-			if i > 0 { n += write_string(w, ", "); }
+			if i > 0 { n += write_string(w, ", ") }
 
 			t := info.types[i]
 
@@ -453,7 +453,7 @@ write_type_writer :: proc(w: io.Writer, ti: ^Type_Info) -> (n: int) {
 			}
 			n += write_type(w, t)
 		}
-		if count != 1 { n += write_string(w, ")"); }
+		if count != 1 { n += write_string(w, ")") }
 
 	case Type_Info_Array:
 		n += _n(io.write_string(w, "["))
@@ -500,8 +500,8 @@ write_type_writer :: proc(w: io.Writer, ti: ^Type_Info) -> (n: int) {
 		}
 
 		n += write_string(w, "struct ")
-		if info.is_packed    { n += write_string(w, "#packed "); }
-		if info.is_raw_union { n += write_string(w, "#raw_union "); }
+		if info.is_packed    { n += write_string(w, "#packed ") }
+		if info.is_raw_union { n += write_string(w, "#raw_union ") }
 		if info.custom_align {
 			n += _n(io.write_string(w, "#align "))
 			n += _n(io.write_i64(w, i64(ti.align), 10))
@@ -509,7 +509,7 @@ write_type_writer :: proc(w: io.Writer, ti: ^Type_Info) -> (n: int) {
 		}
 		n += _n(io.write_byte(w, '{'))
 		for name, i in info.names {
-			if i > 0 { n += write_string(w, ", "); }
+			if i > 0 { n += write_string(w, ", ") }
 			n += _n(io.write_string(w, name))
 			n += _n(io.write_string(w, ": "))
 			n += write_type(w, info.types[i])
@@ -525,7 +525,7 @@ write_type_writer :: proc(w: io.Writer, ti: ^Type_Info) -> (n: int) {
 		}
 		n += _n(io.write_byte(w, '{'))
 		for variant, i in info.variants {
-			if i > 0 { n += write_string(w, ", "); }
+			if i > 0 { n += write_string(w, ", ") }
 			n += write_type(w, variant)
 		}
 		n += _n(io.write_byte(w, '}'))
@@ -535,7 +535,7 @@ write_type_writer :: proc(w: io.Writer, ti: ^Type_Info) -> (n: int) {
 		n += write_type(w, info.base)
 		n += write_string(w, " {")
 		for name, i in info.names {
-			if i > 0 { n += write_string(w, ", "); }
+			if i > 0 { n += write_string(w, ", ") }
 			n += write_string(w, name)
 		}
 		n += _n(io.write_byte(w, '}'))

core/runtime/dynamic_map_internal.odin

@@ -101,22 +101,22 @@ default_hasher_n :: #force_inline proc "contextless" (data: rawptr, seed: uintpt
 
 // NOTE(bill): There are loads of predefined ones to improve optimizations for small types
 
-default_hasher1  :: proc "contextless" (data: rawptr, seed: uintptr) -> uintptr { return #force_inline _default_hasher_const(data, seed,  1); }
-default_hasher2  :: proc "contextless" (data: rawptr, seed: uintptr) -> uintptr { return #force_inline _default_hasher_const(data, seed,  2); }
-default_hasher3  :: proc "contextless" (data: rawptr, seed: uintptr) -> uintptr { return #force_inline _default_hasher_const(data, seed,  3); }
-default_hasher4  :: proc "contextless" (data: rawptr, seed: uintptr) -> uintptr { return #force_inline _default_hasher_const(data, seed,  4); }
-default_hasher5  :: proc "contextless" (data: rawptr, seed: uintptr) -> uintptr { return #force_inline _default_hasher_const(data, seed,  5); }
-default_hasher6  :: proc "contextless" (data: rawptr, seed: uintptr) -> uintptr { return #force_inline _default_hasher_const(data, seed,  6); }
-default_hasher7  :: proc "contextless" (data: rawptr, seed: uintptr) -> uintptr { return #force_inline _default_hasher_const(data, seed,  7); }
-default_hasher8  :: proc "contextless" (data: rawptr, seed: uintptr) -> uintptr { return #force_inline _default_hasher_const(data, seed,  8); }
-default_hasher9  :: proc "contextless" (data: rawptr, seed: uintptr) -> uintptr { return #force_inline _default_hasher_const(data, seed,  9); }
-default_hasher10 :: proc "contextless" (data: rawptr, seed: uintptr) -> uintptr { return #force_inline _default_hasher_const(data, seed, 10); }
-default_hasher11 :: proc "contextless" (data: rawptr, seed: uintptr) -> uintptr { return #force_inline _default_hasher_const(data, seed, 11); }
-default_hasher12 :: proc "contextless" (data: rawptr, seed: uintptr) -> uintptr { return #force_inline _default_hasher_const(data, seed, 12); }
-default_hasher13 :: proc "contextless" (data: rawptr, seed: uintptr) -> uintptr { return #force_inline _default_hasher_const(data, seed, 13); }
-default_hasher14 :: proc "contextless" (data: rawptr, seed: uintptr) -> uintptr { return #force_inline _default_hasher_const(data, seed, 14); }
-default_hasher15 :: proc "contextless" (data: rawptr, seed: uintptr) -> uintptr { return #force_inline _default_hasher_const(data, seed, 15); }
-default_hasher16 :: proc "contextless" (data: rawptr, seed: uintptr) -> uintptr { return #force_inline _default_hasher_const(data, seed, 16); }
+default_hasher1  :: proc "contextless" (data: rawptr, seed: uintptr) -> uintptr { return #force_inline _default_hasher_const(data, seed,  1) }
+default_hasher2  :: proc "contextless" (data: rawptr, seed: uintptr) -> uintptr { return #force_inline _default_hasher_const(data, seed,  2) }
+default_hasher3  :: proc "contextless" (data: rawptr, seed: uintptr) -> uintptr { return #force_inline _default_hasher_const(data, seed,  3) }
+default_hasher4  :: proc "contextless" (data: rawptr, seed: uintptr) -> uintptr { return #force_inline _default_hasher_const(data, seed,  4) }
+default_hasher5  :: proc "contextless" (data: rawptr, seed: uintptr) -> uintptr { return #force_inline _default_hasher_const(data, seed,  5) }
+default_hasher6  :: proc "contextless" (data: rawptr, seed: uintptr) -> uintptr { return #force_inline _default_hasher_const(data, seed,  6) }
+default_hasher7  :: proc "contextless" (data: rawptr, seed: uintptr) -> uintptr { return #force_inline _default_hasher_const(data, seed,  7) }
+default_hasher8  :: proc "contextless" (data: rawptr, seed: uintptr) -> uintptr { return #force_inline _default_hasher_const(data, seed,  8) }
+default_hasher9  :: proc "contextless" (data: rawptr, seed: uintptr) -> uintptr { return #force_inline _default_hasher_const(data, seed,  9) }
+default_hasher10 :: proc "contextless" (data: rawptr, seed: uintptr) -> uintptr { return #force_inline _default_hasher_const(data, seed, 10) }
+default_hasher11 :: proc "contextless" (data: rawptr, seed: uintptr) -> uintptr { return #force_inline _default_hasher_const(data, seed, 11) }
+default_hasher12 :: proc "contextless" (data: rawptr, seed: uintptr) -> uintptr { return #force_inline _default_hasher_const(data, seed, 12) }
+default_hasher13 :: proc "contextless" (data: rawptr, seed: uintptr) -> uintptr { return #force_inline _default_hasher_const(data, seed, 13) }
+default_hasher14 :: proc "contextless" (data: rawptr, seed: uintptr) -> uintptr { return #force_inline _default_hasher_const(data, seed, 14) }
+default_hasher15 :: proc "contextless" (data: rawptr, seed: uintptr) -> uintptr { return #force_inline _default_hasher_const(data, seed, 15) }
+default_hasher16 :: proc "contextless" (data: rawptr, seed: uintptr) -> uintptr { return #force_inline _default_hasher_const(data, seed, 16) }
 
 default_hasher_string :: proc "contextless" (data: rawptr, seed: uintptr) -> uintptr {
 	h := u64(seed) + 0xcbf29ce484222325

core/runtime/internal.odin

@@ -275,11 +275,11 @@ string_cmp :: proc "contextless" (a, b: string) -> int {
 	return memory_compare(x.data, y.data, min(x.len, y.len))
 }
 
-string_ne :: #force_inline proc "contextless" (a, b: string) -> bool { return !string_eq(a, b); }
-string_lt :: #force_inline proc "contextless" (a, b: string) -> bool { return string_cmp(a, b) < 0; }
-string_gt :: #force_inline proc "contextless" (a, b: string) -> bool { return string_cmp(a, b) > 0; }
-string_le :: #force_inline proc "contextless" (a, b: string) -> bool { return string_cmp(a, b) <= 0; }
-string_ge :: #force_inline proc "contextless" (a, b: string) -> bool { return string_cmp(a, b) >= 0; }
+string_ne :: #force_inline proc "contextless" (a, b: string) -> bool { return !string_eq(a, b) }
+string_lt :: #force_inline proc "contextless" (a, b: string) -> bool { return string_cmp(a, b) < 0 }
+string_gt :: #force_inline proc "contextless" (a, b: string) -> bool { return string_cmp(a, b) > 0 }
+string_le :: #force_inline proc "contextless" (a, b: string) -> bool { return string_cmp(a, b) <= 0 }
+string_ge :: #force_inline proc "contextless" (a, b: string) -> bool { return string_cmp(a, b) >= 0 }
 
 cstring_len :: proc "contextless" (s: cstring) -> int {
 	p0 := uintptr((^byte)(s))
@@ -300,24 +300,24 @@ cstring_to_string :: proc "contextless" (s: cstring) -> string {
 }
 
 
-complex32_eq :: #force_inline proc "contextless"  (a, b: complex32)  -> bool { return real(a) == real(b) && imag(a) == imag(b); }
-complex32_ne :: #force_inline proc "contextless"  (a, b: complex32)  -> bool { return real(a) != real(b) || imag(a) != imag(b); }
+complex32_eq :: #force_inline proc "contextless"  (a, b: complex32)  -> bool { return real(a) == real(b) && imag(a) == imag(b) }
+complex32_ne :: #force_inline proc "contextless"  (a, b: complex32)  -> bool { return real(a) != real(b) || imag(a) != imag(b) }
 
-complex64_eq :: #force_inline proc "contextless"  (a, b: complex64)  -> bool { return real(a) == real(b) && imag(a) == imag(b); }
-complex64_ne :: #force_inline proc "contextless"  (a, b: complex64)  -> bool { return real(a) != real(b) || imag(a) != imag(b); }
+complex64_eq :: #force_inline proc "contextless"  (a, b: complex64)  -> bool { return real(a) == real(b) && imag(a) == imag(b) }
+complex64_ne :: #force_inline proc "contextless"  (a, b: complex64)  -> bool { return real(a) != real(b) || imag(a) != imag(b) }
 
-complex128_eq :: #force_inline proc "contextless" (a, b: complex128) -> bool { return real(a) == real(b) && imag(a) == imag(b); }
-complex128_ne :: #force_inline proc "contextless" (a, b: complex128) -> bool { return real(a) != real(b) || imag(a) != imag(b); }
+complex128_eq :: #force_inline proc "contextless" (a, b: complex128) -> bool { return real(a) == real(b) && imag(a) == imag(b) }
+complex128_ne :: #force_inline proc "contextless" (a, b: complex128) -> bool { return real(a) != real(b) || imag(a) != imag(b) }
 
 
-quaternion64_eq :: #force_inline proc "contextless"  (a, b: quaternion64)  -> bool { return real(a) == real(b) && imag(a) == imag(b) && jmag(a) == jmag(b) && kmag(a) == kmag(b); }
-quaternion64_ne :: #force_inline proc "contextless"  (a, b: quaternion64)  -> bool { return real(a) != real(b) || imag(a) != imag(b) || jmag(a) != jmag(b) || kmag(a) != kmag(b); }
+quaternion64_eq :: #force_inline proc "contextless"  (a, b: quaternion64)  -> bool { return real(a) == real(b) && imag(a) == imag(b) && jmag(a) == jmag(b) && kmag(a) == kmag(b) }
+quaternion64_ne :: #force_inline proc "contextless"  (a, b: quaternion64)  -> bool { return real(a) != real(b) || imag(a) != imag(b) || jmag(a) != jmag(b) || kmag(a) != kmag(b) }
 
-quaternion128_eq :: #force_inline proc "contextless"  (a, b: quaternion128)  -> bool { return real(a) == real(b) && imag(a) == imag(b) && jmag(a) == jmag(b) && kmag(a) == kmag(b); }
-quaternion128_ne :: #force_inline proc "contextless"  (a, b: quaternion128)  -> bool { return real(a) != real(b) || imag(a) != imag(b) || jmag(a) != jmag(b) || kmag(a) != kmag(b); }
+quaternion128_eq :: #force_inline proc "contextless"  (a, b: quaternion128)  -> bool { return real(a) == real(b) && imag(a) == imag(b) && jmag(a) == jmag(b) && kmag(a) == kmag(b) }
+quaternion128_ne :: #force_inline proc "contextless"  (a, b: quaternion128)  -> bool { return real(a) != real(b) || imag(a) != imag(b) || jmag(a) != jmag(b) || kmag(a) != kmag(b) }
 
-quaternion256_eq :: #force_inline proc "contextless" (a, b: quaternion256) -> bool { return real(a) == real(b) && imag(a) == imag(b) && jmag(a) == jmag(b) && kmag(a) == kmag(b); }
-quaternion256_ne :: #force_inline proc "contextless" (a, b: quaternion256) -> bool { return real(a) != real(b) || imag(a) != imag(b) || jmag(a) != jmag(b) || kmag(a) != kmag(b); }
+quaternion256_eq :: #force_inline proc "contextless" (a, b: quaternion256) -> bool { return real(a) == real(b) && imag(a) == imag(b) && jmag(a) == jmag(b) && kmag(a) == kmag(b) }
+quaternion256_ne :: #force_inline proc "contextless" (a, b: quaternion256) -> bool { return real(a) != real(b) || imag(a) != imag(b) || jmag(a) != jmag(b) || kmag(a) != kmag(b) }
 
 
 string_decode_rune :: #force_inline proc "contextless" (s: string) -> (rune, int) {

core/runtime/print.odin

@@ -214,7 +214,7 @@ print_type :: proc "contextless" (ti: ^Type_Info) {
 			t := info.params.variant.(Type_Info_Tuple)
 			print_byte('(')
 			for t, i in t.types {
-				if i > 0 { print_string(", "); }
+				if i > 0 { print_string(", ") }
 				print_type(t)
 			}
 			print_string(")")
@@ -225,9 +225,9 @@ print_type :: proc "contextless" (ti: ^Type_Info) {
 		}
 	case Type_Info_Tuple:
 		count := len(info.names)
-		if count != 1 { print_byte('('); }
+		if count != 1 { print_byte('(') }
 		for name, i in info.names {
-			if i > 0 { print_string(", "); }
+			if i > 0 { print_string(", ") }
 
 			t := info.types[i]
 
@@ -237,7 +237,7 @@ print_type :: proc "contextless" (ti: ^Type_Info) {
 			}
 			print_type(t)
 		}
-		if count != 1 { print_string(")"); }
+		if count != 1 { print_string(")") }
 
 	case Type_Info_Array:
 		print_byte('[')
@@ -285,8 +285,8 @@ print_type :: proc "contextless" (ti: ^Type_Info) {
 		}
 
 		print_string("struct ")
-		if info.is_packed    { print_string("#packed "); }
-		if info.is_raw_union { print_string("#raw_union "); }
+		if info.is_packed    { print_string("#packed ") }
+		if info.is_raw_union { print_string("#raw_union ") }
 		if info.custom_align {
 			print_string("#align ")
 			print_u64(u64(ti.align))
@@ -294,7 +294,7 @@ print_type :: proc "contextless" (ti: ^Type_Info) {
 		}
 		print_byte('{')
 		for name, i in info.names {
-			if i > 0 { print_string(", "); }
+			if i > 0 { print_string(", ") }
 			print_string(name)
 			print_string(": ")
 			print_type(info.types[i])
@@ -312,7 +312,7 @@ print_type :: proc "contextless" (ti: ^Type_Info) {
 		}
 		print_byte('{')
 		for variant, i in info.variants {
-			if i > 0 { print_string(", "); }
+			if i > 0 { print_string(", ") }
 			print_type(variant)
 		}
 		print_string("}")
@@ -322,7 +322,7 @@ print_type :: proc "contextless" (ti: ^Type_Info) {
 		print_type(info.base)
 		print_string(" {")
 		for name, i in info.names {
-			if i > 0 { print_string(", "); }
+			if i > 0 { print_string(", ") }
 			print_string(name)
 		}
 		print_string("}")

core/sort/sort.odin

@@ -367,8 +367,8 @@ quick_sort_proc :: proc(array: $A/[]$T, f: proc(T, T) -> int) {
 	i, j := 0, n-1
 
 	loop: for {
-		for f(a[i], p) < 0 { i += 1; }
-		for f(p, a[j]) < 0 { j -= 1; }
+		for f(a[i], p) < 0 { i += 1 }
+		for f(p, a[j]) < 0 { j -= 1 }
 
 		if i >= j {
 			break loop
@@ -395,8 +395,8 @@ quick_sort :: proc(array: $A/[]$T) where intrinsics.type_is_ordered(T) {
 	i, j := 0, n-1
 
 	loop: for {
-		for a[i] < p { i += 1; }
-		for p < a[j] { j -= 1; }
+		for a[i] < p { i += 1 }
+		for p < a[j] { j -= 1 }
 
 		if i >= j {
 			break loop

core/strconv/decimal/decimal.odin

@@ -202,7 +202,7 @@ shift :: proc(a: ^Decimal, i: int) {
 }
 
 can_round_up :: proc(a: ^Decimal, nd: int) -> bool {
-	if nd < 0 || nd >= a.count { return false ; }
+	if nd < 0 || nd >= a.count { return false  }
 	if a.digits[nd] == '5' && nd+1 == a.count {
 		if a.trunc {
 			return true
@@ -214,7 +214,7 @@ can_round_up :: proc(a: ^Decimal, nd: int) -> bool {
 }
 
 round :: proc(a: ^Decimal, nd: int) {
-	if nd < 0 || nd >= a.count { return; }
+	if nd < 0 || nd >= a.count { return }
 	if can_round_up(a, nd) {
 		round_up(a, nd)
 	} else {
@@ -223,7 +223,7 @@ round :: proc(a: ^Decimal, nd: int) {
 }
 
 round_up :: proc(a: ^Decimal, nd: int) {
-	if nd < 0 || nd >= a.count { return; }
+	if nd < 0 || nd >= a.count { return }
 
 	for i := nd-1; i >= 0; i -= 1 {
 		if c := a.digits[i]; c < '9' {
@@ -240,7 +240,7 @@ round_up :: proc(a: ^Decimal, nd: int) {
 }
 
 round_down :: proc(a: ^Decimal, nd: int) {
-	if nd < 0 || nd >= a.count { return; }
+	if nd < 0 || nd >= a.count { return }
 	a.count = nd
 	trim(a)
 }

core/strconv/strconv.odin

@@ -402,11 +402,11 @@ parse_f64 :: proc(str: string) -> (value: f64, ok: bool) {
 				}
 				exp = exp * 10 + d
 			}
-			if exp > 308 { exp = 308; }
+			if exp > 308 { exp = 308 }
 
-			for exp >= 50 { scale *= 1e50; exp -= 50; }
-			for exp >=  8 { scale *=  1e8; exp -=  8; }
-			for exp >   0 { scale *=   10; exp -=  1; }
+			for exp >= 50 { scale *= 1e50; exp -= 50 }
+			for exp >=  8 { scale *=  1e8; exp -=  8 }
+			for exp >   0 { scale *=   10; exp -=  1 }
 		}
 	}
 	s = s[i:]

core/strings/strings.odin

@@ -207,11 +207,11 @@ cut :: proc(s: string, rune_offset := int(0), rune_length := int(0), allocator :
 	s := s; rune_length := rune_length
 	l := utf8.rune_count_in_string(s)
 
-	if rune_offset >= l { return ""; }
+	if rune_offset >= l { return "" }
 	if rune_offset == 0 && rune_length <= 0 {
 		return clone(s, allocator)
 	}
-	if rune_length == 0 { rune_length = l; }
+	if rune_length == 0 { rune_length = l }
 
 	bytes_needed := min(rune_length * 4, len(s))
 	buf := make([]u8, bytes_needed, allocator)
@@ -226,7 +226,7 @@ cut :: proc(s: string, rune_offset := int(0), rune_length := int(0), allocator :
 			byte_offset += w
 		}
 		if rune_length > 0 {
-			if i == rune_offset + rune_length - 1 { break; }
+			if i == rune_offset + rune_length - 1 { break }
 		}
 		s = s[w:]
 	}

core/sync/atomic.odin

@@ -23,62 +23,62 @@ strongest_failure_ordering :: #force_inline proc(order: Ordering) -> Ordering {
 }
 
 fence :: #force_inline proc($order: Ordering) {
-	     when order == .Relaxed                 { #panic("there is no such thing as a relaxed fence"); }
-	else when order == .Release                 { intrinsics.atomic_fence_rel();                       }
-	else when order == .Acquire                 { intrinsics.atomic_fence_acq();                       }
-	else when order == .Acquire_Release         { intrinsics.atomic_fence_acqrel();                    }
-	else when order == .Sequentially_Consistent { intrinsics.atomic_fence();                           }
-	else { #panic("unknown order"); }
+	     when order == .Relaxed                 { #panic("there is no such thing as a relaxed fence") }
+	else when order == .Release                 { intrinsics.atomic_fence_rel()                       }
+	else when order == .Acquire                 { intrinsics.atomic_fence_acq()                       }
+	else when order == .Acquire_Release         { intrinsics.atomic_fence_acqrel()                    }
+	else when order == .Sequentially_Consistent { intrinsics.atomic_fence()                           }
+	else { #panic("unknown order") }
 }
 
 
 atomic_store :: #force_inline proc(dst: ^$T, val: T, $order: Ordering) {
-	     when order == .Relaxed                 { intrinsics.atomic_store_relaxed(dst, val); }
-	else when order == .Release                 { intrinsics.atomic_store_rel(dst, val); }
-	else when order == .Sequentially_Consistent { intrinsics.atomic_store(dst, val); }
-	else when order == .Acquire                 { #panic("there is not such thing as an acquire store"); }
-	else when order == .Acquire_Release         { #panic("there is not such thing as an acquire/release store"); }
-	else { #panic("unknown order"); }
+	     when order == .Relaxed                 { intrinsics.atomic_store_relaxed(dst, val) }
+	else when order == .Release                 { intrinsics.atomic_store_rel(dst, val) }
+	else when order == .Sequentially_Consistent { intrinsics.atomic_store(dst, val) }
+	else when order == .Acquire                 { #panic("there is not such thing as an acquire store") }
+	else when order == .Acquire_Release         { #panic("there is not such thing as an acquire/release store") }
+	else { #panic("unknown order") }
 }
 
 atomic_load :: #force_inline proc(dst: ^$T, $order: Ordering) -> T {
-	     when order == .Relaxed                 { return intrinsics.atomic_load_relaxed(dst); }
-	else when order == .Acquire                 { return intrinsics.atomic_load_acq(dst); }
-	else when order == .Sequentially_Consistent { return intrinsics.atomic_load(dst); }
-	else when order == .Release                 { #panic("there is no such thing as a release load"); }
-	else when order == .Acquire_Release         { #panic("there is no such thing as an acquire/release load"); }
-	else { #panic("unknown order"); }
+	     when order == .Relaxed                 { return intrinsics.atomic_load_relaxed(dst) }
+	else when order == .Acquire                 { return intrinsics.atomic_load_acq(dst) }
+	else when order == .Sequentially_Consistent { return intrinsics.atomic_load(dst) }
+	else when order == .Release                 { #panic("there is no such thing as a release load") }
+	else when order == .Acquire_Release         { #panic("there is no such thing as an acquire/release load") }
+	else { #panic("unknown order") }
 }
 
 atomic_swap :: #force_inline proc(dst: ^$T, val: T, $order: Ordering) -> T {
-	     when order == .Relaxed                 { return intrinsics.atomic_xchg_relaxed(dst, val); }
-	else when order == .Release                 { return intrinsics.atomic_xchg_rel(dst, val);     }
-	else when order == .Acquire                 { return intrinsics.atomic_xchg_acq(dst, val);     }
-	else when order == .Acquire_Release         { return intrinsics.atomic_xchg_acqrel(dst, val);  }
-	else when order == .Sequentially_Consistent { return intrinsics.atomic_xchg(dst, val);         }
-	else { #panic("unknown order"); }
+	     when order == .Relaxed                 { return intrinsics.atomic_xchg_relaxed(dst, val) }
+	else when order == .Release                 { return intrinsics.atomic_xchg_rel(dst, val)     }
+	else when order == .Acquire                 { return intrinsics.atomic_xchg_acq(dst, val)     }
+	else when order == .Acquire_Release         { return intrinsics.atomic_xchg_acqrel(dst, val)  }
+	else when order == .Sequentially_Consistent { return intrinsics.atomic_xchg(dst, val)         }
+	else { #panic("unknown order") }
 }
 
 atomic_compare_exchange :: #force_inline proc(dst: ^$T, old, new: T, $success, $failure: Ordering) -> (val: T, ok: bool) {
 	when failure == .Relaxed {
-		     when success == .Relaxed                 { return intrinsics.atomic_cxchg_relaxed(dst, old, new); }
-		else when success == .Acquire                 { return intrinsics.atomic_cxchg_acq_failrelaxed(dst, old, new); }
-		else when success == .Acquire_Release         { return intrinsics.atomic_cxchg_acqrel_failrelaxed(dst, old, new); }
-		else when success == .Sequentially_Consistent { return intrinsics.atomic_cxchg_failrelaxed(dst, old, new); }
-		else when success == .Release                 { return intrinsics.atomic_cxchg_rel(dst, old, new); }
-		else { #panic("an unknown ordering combination"); }
+		     when success == .Relaxed                 { return intrinsics.atomic_cxchg_relaxed(dst, old, new) }
+		else when success == .Acquire                 { return intrinsics.atomic_cxchg_acq_failrelaxed(dst, old, new) }
+		else when success == .Acquire_Release         { return intrinsics.atomic_cxchg_acqrel_failrelaxed(dst, old, new) }
+		else when success == .Sequentially_Consistent { return intrinsics.atomic_cxchg_failrelaxed(dst, old, new) }
+		else when success == .Release                 { return intrinsics.atomic_cxchg_rel(dst, old, new) }
+		else { #panic("an unknown ordering combination") }
 	} else when failure == .Acquire {
-		     when success == .Release { return intrinsics.atomic_cxchg_acqrel(dst, old, new); }
-		else when success == .Acquire { return intrinsics.atomic_cxchg_acq(dst, old, new); }
-		else { #panic("an unknown ordering combination"); }
+		     when success == .Release { return intrinsics.atomic_cxchg_acqrel(dst, old, new) }
+		else when success == .Acquire { return intrinsics.atomic_cxchg_acq(dst, old, new) }
+		else { #panic("an unknown ordering combination") }
 	} else when failure == .Sequentially_Consistent {
-		when success == .Sequentially_Consistent { return intrinsics.atomic_cxchg(dst, old, new); }
-		else { #panic("an unknown ordering combination"); }
+		when success == .Sequentially_Consistent { return intrinsics.atomic_cxchg(dst, old, new) }
+		else { #panic("an unknown ordering combination") }
 	} else when failure == .Acquire_Release {
 		#panic("there is not such thing as an acquire/release failure ordering")
 	} else when failure == .Release {
-		when success == .Acquire { return instrinsics.atomic_cxchg_failacq(dst, old, new); }
-		else { #panic("an unknown ordering combination"); }
+		when success == .Acquire { return instrinsics.atomic_cxchg_failacq(dst, old, new) }
+		else { #panic("an unknown ordering combination") }
 	} else {
 		return T{}, false
 	}
@@ -87,24 +87,24 @@ atomic_compare_exchange :: #force_inline proc(dst: ^$T, old, new: T, $success, $
 
 atomic_compare_exchange_weak :: #force_inline proc(dst: ^$T, old, new: T, $success, $failure: Ordering) -> (val: T, ok: bool) {
 	when failure == .Relaxed {
-		     when success == .Relaxed                 { return intrinsics.atomic_cxchgweak_relaxed(dst, old, new); }
-		else when success == .Acquire                 { return intrinsics.atomic_cxchgweak_acq_failrelaxed(dst, old, new); }
-		else when success == .Acquire_Release         { return intrinsics.atomic_cxchgweak_acqrel_failrelaxed(dst, old, new); }
-		else when success == .Sequentially_Consistent { return intrinsics.atomic_cxchgweak_failrelaxed(dst, old, new); }
-		else when success == .Release                 { return intrinsics.atomic_cxchgweak_rel(dst, old, new); }
-		else { #panic("an unknown ordering combination"); }
+		     when success == .Relaxed                 { return intrinsics.atomic_cxchgweak_relaxed(dst, old, new) }
+		else when success == .Acquire                 { return intrinsics.atomic_cxchgweak_acq_failrelaxed(dst, old, new) }
+		else when success == .Acquire_Release         { return intrinsics.atomic_cxchgweak_acqrel_failrelaxed(dst, old, new) }
+		else when success == .Sequentially_Consistent { return intrinsics.atomic_cxchgweak_failrelaxed(dst, old, new) }
+		else when success == .Release                 { return intrinsics.atomic_cxchgweak_rel(dst, old, new) }
+		else { #panic("an unknown ordering combination") }
 	} else when failure == .Acquire {
-		     when success == .Release { return intrinsics.atomic_cxchgweak_acqrel(dst, old, new); }
-		else when success == .Acquire { return intrinsics.atomic_cxchgweak_acq(dst, old, new); }
-		else { #panic("an unknown ordering combination"); }
+		     when success == .Release { return intrinsics.atomic_cxchgweak_acqrel(dst, old, new) }
+		else when success == .Acquire { return intrinsics.atomic_cxchgweak_acq(dst, old, new) }
+		else { #panic("an unknown ordering combination") }
 	} else when failure == .Sequentially_Consistent {
-		when success == .Sequentially_Consistent { return intrinsics.atomic_cxchgweak(dst, old, new); }
-		else { #panic("an unknown ordering combination"); }
+		when success == .Sequentially_Consistent { return intrinsics.atomic_cxchgweak(dst, old, new) }
+		else { #panic("an unknown ordering combination") }
 	} else when failure == .Acquire_Release {
 		#panic("there is not such thing as an acquire/release failure ordering")
 	} else when failure == .Release {
-		when success == .Acquire { return intrinsics.atomic_cxchgweak_failacq(dst, old, new); }
-		else { #panic("an unknown ordering combination"); }
+		when success == .Acquire { return intrinsics.atomic_cxchgweak_failacq(dst, old, new) }
+		else { #panic("an unknown ordering combination") }
 	} else {
 		return T{}, false
 	}
@@ -113,56 +113,56 @@ atomic_compare_exchange_weak :: #force_inline proc(dst: ^$T, old, new: T, $succe
 
 
 atomic_add :: #force_inline proc(dst: ^$T, val: T, $order: Ordering) -> T {
-	     when order == .Relaxed                 { return intrinsics.atomic_add_relaxed(dst, val); }
-	else when order == .Release                 { return intrinsics.atomic_add_rel(dst, val); }
-	else when order == .Acquire                 { return intrinsics.atomic_add_acq(dst, val); }
-	else when order == .Acquire_Release         { return intrinsics.atomic_add_acqrel(dst, val); }
-	else when order == .Sequentially_Consistent { return intrinsics.atomic_add(dst, val); }
-	else { #panic("unknown order"); }
+	     when order == .Relaxed                 { return intrinsics.atomic_add_relaxed(dst, val) }
+	else when order == .Release                 { return intrinsics.atomic_add_rel(dst, val) }
+	else when order == .Acquire                 { return intrinsics.atomic_add_acq(dst, val) }
+	else when order == .Acquire_Release         { return intrinsics.atomic_add_acqrel(dst, val) }
+	else when order == .Sequentially_Consistent { return intrinsics.atomic_add(dst, val) }
+	else { #panic("unknown order") }
 }
 
 atomic_sub :: #force_inline proc(dst: ^$T, val: T, $order: Ordering) -> T {
-	     when order == .Relaxed                 { return intrinsics.atomic_sub_relaxed(dst, val); }
-	else when order == .Release                 { return intrinsics.atomic_sub_rel(dst, val); }
-	else when order == .Acquire                 { return intrinsics.atomic_sub_acq(dst, val); }
-	else when order == .Acquire_Release         { return intrinsics.atomic_sub_acqrel(dst, val); }
-	else when order == .Sequentially_Consistent { return intrinsics.atomic_sub(dst, val); }
-	else { #panic("unknown order"); }
+	     when order == .Relaxed                 { return intrinsics.atomic_sub_relaxed(dst, val) }
+	else when order == .Release                 { return intrinsics.atomic_sub_rel(dst, val) }
+	else when order == .Acquire                 { return intrinsics.atomic_sub_acq(dst, val) }
+	else when order == .Acquire_Release         { return intrinsics.atomic_sub_acqrel(dst, val) }
+	else when order == .Sequentially_Consistent { return intrinsics.atomic_sub(dst, val) }
+	else { #panic("unknown order") }
 }
 
 atomic_and :: #force_inline proc(dst: ^$T, val: T, $order: Ordering) -> T {
-	     when order == .Relaxed                 { return intrinsics.atomic_and_relaxed(dst, val); }
-	else when order == .Release                 { return intrinsics.atomic_and_rel(dst, val); }
-	else when order == .Acquire                 { return intrinsics.atomic_and_acq(dst, val); }
-	else when order == .Acquire_Release         { return intrinsics.atomic_and_acqrel(dst, val); }
-	else when order == .Sequentially_Consistent { return intrinsics.atomic_and(dst, val); }
-	else { #panic("unknown order"); }
+	     when order == .Relaxed                 { return intrinsics.atomic_and_relaxed(dst, val) }
+	else when order == .Release                 { return intrinsics.atomic_and_rel(dst, val) }
+	else when order == .Acquire                 { return intrinsics.atomic_and_acq(dst, val) }
+	else when order == .Acquire_Release         { return intrinsics.atomic_and_acqrel(dst, val) }
+	else when order == .Sequentially_Consistent { return intrinsics.atomic_and(dst, val) }
+	else { #panic("unknown order") }
 }
 
 atomic_nand :: #force_inline proc(dst: ^$T, val: T, $order: Ordering) -> T {
-	     when order == .Relaxed                 { return intrinsics.atomic_nand_relaxed(dst, val); }
-	else when order == .Release                 { return intrinsics.atomic_nand_rel(dst, val); }
-	else when order == .Acquire                 { return intrinsics.atomic_nand_acq(dst, val); }
-	else when order == .Acquire_Release         { return intrinsics.atomic_nand_acqrel(dst, val); }
-	else when order == .Sequentially_Consistent { return intrinsics.atomic_nand(dst, val); }
-	else { #panic("unknown order"); }
+	     when order == .Relaxed                 { return intrinsics.atomic_nand_relaxed(dst, val) }
+	else when order == .Release                 { return intrinsics.atomic_nand_rel(dst, val) }
+	else when order == .Acquire                 { return intrinsics.atomic_nand_acq(dst, val) }
+	else when order == .Acquire_Release         { return intrinsics.atomic_nand_acqrel(dst, val) }
+	else when order == .Sequentially_Consistent { return intrinsics.atomic_nand(dst, val) }
+	else { #panic("unknown order") }
 }
 
 atomic_or :: #force_inline proc(dst: ^$T, val: T, $order: Ordering) -> T {
-	     when order == .Relaxed                 { return intrinsics.atomic_or_relaxed(dst, val); }
-	else when order == .Release                 { return intrinsics.atomic_or_rel(dst, val); }
-	else when order == .Acquire                 { return intrinsics.atomic_or_acq(dst, val); }
-	else when order == .Acquire_Release         { return intrinsics.atomic_or_acqrel(dst, val); }
-	else when order == .Sequentially_Consistent { return intrinsics.atomic_or(dst, val); }
-	else { #panic("unknown order"); }
+	     when order == .Relaxed                 { return intrinsics.atomic_or_relaxed(dst, val) }
+	else when order == .Release                 { return intrinsics.atomic_or_rel(dst, val) }
+	else when order == .Acquire                 { return intrinsics.atomic_or_acq(dst, val) }
+	else when order == .Acquire_Release         { return intrinsics.atomic_or_acqrel(dst, val) }
+	else when order == .Sequentially_Consistent { return intrinsics.atomic_or(dst, val) }
+	else { #panic("unknown order") }
 }
 
 atomic_xor :: #force_inline proc(dst: ^$T, val: T, $order: Ordering) -> T {
-	     when order == .Relaxed                 { return intrinsics.atomic_xor_relaxed(dst, val); }
-	else when order == .Release                 { return intrinsics.atomic_xor_rel(dst, val); }
-	else when order == .Acquire                 { return intrinsics.atomic_xor_acq(dst, val); }
-	else when order == .Acquire_Release         { return intrinsics.atomic_xor_acqrel(dst, val); }
-	else when order == .Sequentially_Consistent { return intrinsics.atomic_xor(dst, val); }
-	else { #panic("unknown order"); }
+	     when order == .Relaxed                 { return intrinsics.atomic_xor_relaxed(dst, val) }
+	else when order == .Release                 { return intrinsics.atomic_xor_rel(dst, val) }
+	else when order == .Acquire                 { return intrinsics.atomic_xor_acq(dst, val) }
+	else when order == .Acquire_Release         { return intrinsics.atomic_xor_acqrel(dst, val) }
+	else when order == .Sequentially_Consistent { return intrinsics.atomic_xor(dst, val) }
+	else { #panic("unknown order") }
 }
 

core/sys/win32/general.odin

@@ -847,12 +847,12 @@ get_query_performance_frequency :: proc() -> i64 {
 	return r
 }
 
-HIWORD_W :: proc(wParam: Wparam) -> u16 { return u16((u32(wParam) >> 16) & 0xffff); }
-HIWORD_L :: proc(lParam: Lparam) -> u16 { return u16((u32(lParam) >> 16) & 0xffff); }
-LOWORD_W :: proc(wParam: Wparam) -> u16 { return u16(wParam); }
-LOWORD_L :: proc(lParam: Lparam) -> u16 { return u16(lParam); }
+HIWORD_W :: proc(wParam: Wparam) -> u16 { return u16((u32(wParam) >> 16) & 0xffff) }
+HIWORD_L :: proc(lParam: Lparam) -> u16 { return u16((u32(lParam) >> 16) & 0xffff) }
+LOWORD_W :: proc(wParam: Wparam) -> u16 { return u16(wParam) }
+LOWORD_L :: proc(lParam: Lparam) -> u16 { return u16(lParam) }
 
-is_key_down :: #force_inline proc(key: Key_Code) -> bool { return get_async_key_state(i32(key)) < 0; }
+is_key_down :: #force_inline proc(key: Key_Code) -> bool { return get_async_key_state(i32(key)) < 0 }
 
 
 

core/text/scanner/scanner.odin

@@ -266,9 +266,9 @@ scan_identifier :: proc(s: ^Scanner) -> rune {
 	return ch
 }
 
-@(private) lower      :: proc(ch: rune) -> rune { return ('a' - 'A') | ch; }
-@(private) is_decimal :: proc(ch: rune) -> bool { return '0' <= ch && ch <= '9'; }
-@(private) is_hex     :: proc(ch: rune) -> bool { return '0' <= ch && ch <= '9' || 'a' <= lower(ch) && lower(ch) <= 'f'; }
+@(private) lower      :: proc(ch: rune) -> rune { return ('a' - 'A') | ch }
+@(private) is_decimal :: proc(ch: rune) -> bool { return '0' <= ch && ch <= '9' }
+@(private) is_hex     :: proc(ch: rune) -> bool { return '0' <= ch && ch <= '9' || 'a' <= lower(ch) && lower(ch) <= 'f' }
 
 
 

core/unicode/utf16/utf16.odin

@@ -35,19 +35,19 @@ encode :: proc(d: []u16, s: []rune) -> int {
 	loop: for r in s {
 		switch r {
 		case 0..<_surr1, _surr3 ..< _surr_self:
-			if m+1 < n { break loop; }
+			if m+1 < n { break loop }
 			d[n] = u16(r)
 			n += 1
 
 		case _surr_self ..= MAX_RUNE:
-			if m+2 < n { break loop; }
+			if m+2 < n { break loop }
 			r1, r2 := encode_surrogate_pair(r)
 			d[n]    = u16(r1)
 			d[n+1]  = u16(r2)
 			n += 2
 
 		case:
-			if m+1 < n { break loop; }
+			if m+1 < n { break loop }
 			d[n] = u16(REPLACEMENT_CHAR)
 			n += 1
 		}
@@ -61,19 +61,19 @@ encode_string :: proc(d: []u16, s: string) -> int {
 	loop: for r in s {
 		switch r {
 		case 0..<_surr1, _surr3 ..< _surr_self:
-			if m+1 < n { break loop; }
+			if m+1 < n { break loop }
 			d[n] = u16(r)
 			n += 1
 
 		case _surr_self ..= MAX_RUNE:
-			if m+2 < n { break loop; }
+			if m+2 < n { break loop }
 			r1, r2 := encode_surrogate_pair(r)
 			d[n]    = u16(r1)
 			d[n+1]  = u16(r2)
 			n += 2
 
 		case:
-			if m+1 < n { break loop; }
+			if m+1 < n { break loop }
 			d[n] = u16(REPLACEMENT_CHAR)
 			n += 1
 		}