Commit f26dda2117

@@ -24,28 +24,28 @@ pub inline fn addf3(comptime T: type, a: T, b: T) T {
     const significandMask = (@as(Z, 1) << significandBits) - 1;
 
     const absMask = signBit - 1;
-    const qnanRep = @bitCast(Z, math.nan(T)) | quietBit;
+    const qnanRep = @as(Z, @bitCast(math.nan(T))) | quietBit;
 
-    var aRep = @bitCast(Z, a);
-    var bRep = @bitCast(Z, b);
+    var aRep = @as(Z, @bitCast(a));
+    var bRep = @as(Z, @bitCast(b));
     const aAbs = aRep & absMask;
     const bAbs = bRep & absMask;
 
-    const infRep = @bitCast(Z, math.inf(T));
+    const infRep = @as(Z, @bitCast(math.inf(T)));
 
     // Detect if a or b is zero, infinity, or NaN.
     if (aAbs -% @as(Z, 1) >= infRep - @as(Z, 1) or
         bAbs -% @as(Z, 1) >= infRep - @as(Z, 1))
     {
         // NaN + anything = qNaN
-        if (aAbs > infRep) return @bitCast(T, @bitCast(Z, a) | quietBit);
+        if (aAbs > infRep) return @as(T, @bitCast(@as(Z, @bitCast(a)) | quietBit));
         // anything + NaN = qNaN
-        if (bAbs > infRep) return @bitCast(T, @bitCast(Z, b) | quietBit);
+        if (bAbs > infRep) return @as(T, @bitCast(@as(Z, @bitCast(b)) | quietBit));
 
         if (aAbs == infRep) {
             // +/-infinity + -/+infinity = qNaN
-            if ((@bitCast(Z, a) ^ @bitCast(Z, b)) == signBit) {
-                return @bitCast(T, qnanRep);
+            if ((@as(Z, @bitCast(a)) ^ @as(Z, @bitCast(b))) == signBit) {
+                return @as(T, @bitCast(qnanRep));
             }
             // +/-infinity + anything remaining = +/- infinity
             else {
@@ -60,7 +60,7 @@ pub inline fn addf3(comptime T: type, a: T, b: T) T {
         if (aAbs == 0) {
             // but we need to get the sign right for zero + zero
             if (bAbs == 0) {
-                return @bitCast(T, @bitCast(Z, a) & @bitCast(Z, b));
+                return @as(T, @bitCast(@as(Z, @bitCast(a)) & @as(Z, @bitCast(b))));
             } else {
                 return b;
             }
@@ -78,8 +78,8 @@ pub inline fn addf3(comptime T: type, a: T, b: T) T {
     }
 
     // Extract the exponent and significand from the (possibly swapped) a and b.
-    var aExponent = @intCast(i32, (aRep >> significandBits) & maxExponent);
-    var bExponent = @intCast(i32, (bRep >> significandBits) & maxExponent);
+    var aExponent = @as(i32, @intCast((aRep >> significandBits) & maxExponent));
+    var bExponent = @as(i32, @intCast((bRep >> significandBits) & maxExponent));
     var aSignificand = aRep & significandMask;
     var bSignificand = bRep & significandMask;
 
@@ -101,11 +101,11 @@ pub inline fn addf3(comptime T: type, a: T, b: T) T {
 
     // Shift the significand of b by the difference in exponents, with a sticky
     // bottom bit to get rounding correct.
-    const @"align" = @intCast(u32, aExponent - bExponent);
+    const @"align" = @as(u32, @intCast(aExponent - bExponent));
     if (@"align" != 0) {
         if (@"align" < typeWidth) {
-            const sticky = if (bSignificand << @intCast(S, typeWidth - @"align") != 0) @as(Z, 1) else 0;
-            bSignificand = (bSignificand >> @truncate(S, @"align")) | sticky;
+            const sticky = if (bSignificand << @as(S, @intCast(typeWidth - @"align")) != 0) @as(Z, 1) else 0;
+            bSignificand = (bSignificand >> @as(S, @truncate(@"align"))) | sticky;
         } else {
             bSignificand = 1; // sticky; b is known to be non-zero.
         }
@@ -113,13 +113,13 @@ pub inline fn addf3(comptime T: type, a: T, b: T) T {
     if (subtraction) {
         aSignificand -= bSignificand;
         // If a == -b, return +zero.
-        if (aSignificand == 0) return @bitCast(T, @as(Z, 0));
+        if (aSignificand == 0) return @as(T, @bitCast(@as(Z, 0)));
 
         // If partial cancellation occured, we need to left-shift the result
         // and adjust the exponent:
         if (aSignificand < integerBit << 3) {
-            const shift = @intCast(i32, @clz(aSignificand)) - @intCast(i32, @clz(integerBit << 3));
-            aSignificand <<= @intCast(S, shift);
+            const shift = @as(i32, @intCast(@clz(aSignificand))) - @as(i32, @intCast(@clz(integerBit << 3)));
+            aSignificand <<= @as(S, @intCast(shift));
             aExponent -= shift;
         }
     } else { // addition
@@ -135,13 +135,13 @@ pub inline fn addf3(comptime T: type, a: T, b: T) T {
     }
 
     // If we have overflowed the type, return +/- infinity:
-    if (aExponent >= maxExponent) return @bitCast(T, infRep | resultSign);
+    if (aExponent >= maxExponent) return @as(T, @bitCast(infRep | resultSign));
 
     if (aExponent <= 0) {
         // Result is denormal; the exponent and round/sticky bits are zero.
         // All we need to do is shift the significand and apply the correct sign.
-        aSignificand >>= @intCast(S, 4 - aExponent);
-        return @bitCast(T, resultSign | aSignificand);
+        aSignificand >>= @as(S, @intCast(4 - aExponent));
+        return @as(T, @bitCast(resultSign | aSignificand));
     }
 
     // Low three bits are round, guard, and sticky.
@@ -151,7 +151,7 @@ pub inline fn addf3(comptime T: type, a: T, b: T) T {
     var result = (aSignificand >> 3) & significandMask;
 
     // Insert the exponent and sign.
-    result |= @intCast(Z, aExponent) << significandBits;
+    result |= @as(Z, @intCast(aExponent)) << significandBits;
     result |= resultSign;
 
     // Final rounding.  The result may overflow to infinity, but that is the
@@ -164,7 +164,7 @@ pub inline fn addf3(comptime T: type, a: T, b: T) T {
         if ((result >> significandBits) != 0) result |= integerBit;
     }
 
-    return @bitCast(T, result);
+    return @as(T, @bitCast(result));
 }
 
 test {

@@ -5,7 +5,7 @@
 
 const std = @import("std");
 const math = std.math;
-const qnan128 = @bitCast(f128, @as(u128, 0x7fff800000000000) << 64);
+const qnan128 = @as(f128, @bitCast(@as(u128, 0x7fff800000000000) << 64));
 
 const __addtf3 = @import("addtf3.zig").__addtf3;
 const __addxf3 = @import("addxf3.zig").__addxf3;
@@ -14,9 +14,9 @@ const __subtf3 = @import("subtf3.zig").__subtf3;
 fn test__addtf3(a: f128, b: f128, expected_hi: u64, expected_lo: u64) !void {
     const x = __addtf3(a, b);
 
-    const rep = @bitCast(u128, x);
-    const hi = @intCast(u64, rep >> 64);
-    const lo = @truncate(u64, rep);
+    const rep = @as(u128, @bitCast(x));
+    const hi = @as(u64, @intCast(rep >> 64));
+    const lo = @as(u64, @truncate(rep));
 
     if (hi == expected_hi and lo == expected_lo) {
         return;
@@ -37,7 +37,7 @@ test "addtf3" {
     try test__addtf3(qnan128, 0x1.23456789abcdefp+5, 0x7fff800000000000, 0x0);
 
     // NaN + any = NaN
-    try test__addtf3(@bitCast(f128, (@as(u128, 0x7fff000000000000) << 64) | @as(u128, 0x800030000000)), 0x1.23456789abcdefp+5, 0x7fff800000000000, 0x0);
+    try test__addtf3(@as(f128, @bitCast((@as(u128, 0x7fff000000000000) << 64) | @as(u128, 0x800030000000))), 0x1.23456789abcdefp+5, 0x7fff800000000000, 0x0);
 
     // inf + inf = inf
     try test__addtf3(math.inf(f128), math.inf(f128), 0x7fff000000000000, 0x0);
@@ -53,9 +53,9 @@ test "addtf3" {
 fn test__subtf3(a: f128, b: f128, expected_hi: u64, expected_lo: u64) !void {
     const x = __subtf3(a, b);
 
-    const rep = @bitCast(u128, x);
-    const hi = @intCast(u64, rep >> 64);
-    const lo = @truncate(u64, rep);
+    const rep = @as(u128, @bitCast(x));
+    const hi = @as(u64, @intCast(rep >> 64));
+    const lo = @as(u64, @truncate(rep));
 
     if (hi == expected_hi and lo == expected_lo) {
         return;
@@ -77,7 +77,7 @@ test "subtf3" {
     try test__subtf3(qnan128, 0x1.23456789abcdefp+5, 0x7fff800000000000, 0x0);
 
     // NaN + any = NaN
-    try test__subtf3(@bitCast(f128, (@as(u128, 0x7fff000000000000) << 64) | @as(u128, 0x800030000000)), 0x1.23456789abcdefp+5, 0x7fff800000000000, 0x0);
+    try test__subtf3(@as(f128, @bitCast((@as(u128, 0x7fff000000000000) << 64) | @as(u128, 0x800030000000))), 0x1.23456789abcdefp+5, 0x7fff800000000000, 0x0);
 
     // inf - any = inf
     try test__subtf3(math.inf(f128), 0x1.23456789abcdefp+5, 0x7fff000000000000, 0x0);
@@ -87,16 +87,16 @@ test "subtf3" {
     try test__subtf3(0x1.ee9d7c52354a6936ab8d7654321fp-1, 0x1.234567829a3bcdef5678ade36734p+5, 0xc0041b8af1915166, 0xa44a7bca780a166c);
 }
 
-const qnan80 = @bitCast(f80, @bitCast(u80, math.nan(f80)) | (1 << (math.floatFractionalBits(f80) - 1)));
+const qnan80 = @as(f80, @bitCast(@as(u80, @bitCast(math.nan(f80))) | (1 << (math.floatFractionalBits(f80) - 1))));
 
 fn test__addxf3(a: f80, b: f80, expected: u80) !void {
     const x = __addxf3(a, b);
-    const rep = @bitCast(u80, x);
+    const rep = @as(u80, @bitCast(x));
 
     if (rep == expected)
         return;
 
-    if (math.isNan(@bitCast(f80, expected)) and math.isNan(x))
+    if (math.isNan(@as(f80, @bitCast(expected))) and math.isNan(x))
         return; // We don't currently test NaN payload propagation
 
     return error.TestFailed;
@@ -104,33 +104,33 @@ fn test__addxf3(a: f80, b: f80, expected: u80) !void {
 
 test "addxf3" {
     // NaN + any = NaN
-    try test__addxf3(qnan80, 0x1.23456789abcdefp+5, @bitCast(u80, qnan80));
-    try test__addxf3(@bitCast(f80, @as(u80, 0x7fff_8000_8000_3000_0000)), 0x1.23456789abcdefp+5, @bitCast(u80, qnan80));
+    try test__addxf3(qnan80, 0x1.23456789abcdefp+5, @as(u80, @bitCast(qnan80)));
+    try test__addxf3(@as(f80, @bitCast(@as(u80, 0x7fff_8000_8000_3000_0000))), 0x1.23456789abcdefp+5, @as(u80, @bitCast(qnan80)));
 
     // any + NaN = NaN
-    try test__addxf3(0x1.23456789abcdefp+5, qnan80, @bitCast(u80, qnan80));
-    try test__addxf3(0x1.23456789abcdefp+5, @bitCast(f80, @as(u80, 0x7fff_8000_8000_3000_0000)), @bitCast(u80, qnan80));
+    try test__addxf3(0x1.23456789abcdefp+5, qnan80, @as(u80, @bitCast(qnan80)));
+    try test__addxf3(0x1.23456789abcdefp+5, @as(f80, @bitCast(@as(u80, 0x7fff_8000_8000_3000_0000))), @as(u80, @bitCast(qnan80)));
 
     // NaN + inf = NaN
-    try test__addxf3(qnan80, math.inf(f80), @bitCast(u80, qnan80));
+    try test__addxf3(qnan80, math.inf(f80), @as(u80, @bitCast(qnan80)));
 
     // inf + NaN = NaN
-    try test__addxf3(math.inf(f80), qnan80, @bitCast(u80, qnan80));
+    try test__addxf3(math.inf(f80), qnan80, @as(u80, @bitCast(qnan80)));
 
     // inf + inf = inf
-    try test__addxf3(math.inf(f80), math.inf(f80), @bitCast(u80, math.inf(f80)));
+    try test__addxf3(math.inf(f80), math.inf(f80), @as(u80, @bitCast(math.inf(f80))));
 
     // inf + -inf = NaN
-    try test__addxf3(math.inf(f80), -math.inf(f80), @bitCast(u80, qnan80));
+    try test__addxf3(math.inf(f80), -math.inf(f80), @as(u80, @bitCast(qnan80)));
 
     // -inf + inf = NaN
-    try test__addxf3(-math.inf(f80), math.inf(f80), @bitCast(u80, qnan80));
+    try test__addxf3(-math.inf(f80), math.inf(f80), @as(u80, @bitCast(qnan80)));
 
     // inf + any = inf
-    try test__addxf3(math.inf(f80), 0x1.2335653452436234723489432abcdefp+5, @bitCast(u80, math.inf(f80)));
+    try test__addxf3(math.inf(f80), 0x1.2335653452436234723489432abcdefp+5, @as(u80, @bitCast(math.inf(f80))));
 
     // any + inf = inf
-    try test__addxf3(0x1.2335653452436234723489432abcdefp+5, math.inf(f80), @bitCast(u80, math.inf(f80)));
+    try test__addxf3(0x1.2335653452436234723489432abcdefp+5, math.inf(f80), @as(u80, @bitCast(math.inf(f80))));
 
     // any + any
     try test__addxf3(0x1.23456789abcdp+5, 0x1.dcba987654321p+5, 0x4005_BFFFFFFFFFFFC400);

@@ -192,6 +192,6 @@ pub fn __aeabi_ldivmod() callconv(.Naked) void {
 }
 
 pub fn __aeabi_drsub(a: f64, b: f64) callconv(.AAPCS) f64 {
-    const neg_a = @bitCast(f64, @bitCast(u64, a) ^ (@as(u64, 1) << 63));
+    const neg_a = @as(f64, @bitCast(@as(u64, @bitCast(a)) ^ (@as(u64, 1) << 63)));
     return b + neg_a;
 }

@@ -232,16 +232,16 @@ fn wideUpdate(comptime T: type, ptr: *T, val: T, update: anytype) T {
 
     const addr = @intFromPtr(ptr);
     const wide_addr = addr & ~(@as(T, smallest_atomic_fetch_exch_size) - 1);
-    const wide_ptr = @alignCast(smallest_atomic_fetch_exch_size, @ptrFromInt(*WideAtomic, wide_addr));
+    const wide_ptr: *align(smallest_atomic_fetch_exch_size) WideAtomic = @alignCast(@as(*WideAtomic, @ptrFromInt(wide_addr)));
 
     const inner_offset = addr & (@as(T, smallest_atomic_fetch_exch_size) - 1);
-    const inner_shift = @intCast(std.math.Log2Int(T), inner_offset * 8);
+    const inner_shift = @as(std.math.Log2Int(T), @intCast(inner_offset * 8));
 
     const mask = @as(WideAtomic, std.math.maxInt(T)) << inner_shift;
 
     var wide_old = @atomicLoad(WideAtomic, wide_ptr, .SeqCst);
     while (true) {
-        const old = @truncate(T, (wide_old & mask) >> inner_shift);
+        const old = @as(T, @truncate((wide_old & mask) >> inner_shift));
         const new = update(val, old);
         const wide_new = wide_old & ~mask | (@as(WideAtomic, new) << inner_shift);
         if (@cmpxchgWeak(WideAtomic, wide_ptr, wide_old, wide_new, .SeqCst, .SeqCst)) |new_wide_old| {

@@ -21,9 +21,9 @@ pub fn _alldiv(a: i64, b: i64) callconv(.Stdcall) i64 {
     const an = (a ^ s_a) -% s_a;
     const bn = (b ^ s_b) -% s_b;
 
-    const r = @bitCast(u64, an) / @bitCast(u64, bn);
+    const r = @as(u64, @bitCast(an)) / @as(u64, @bitCast(bn));
     const s = s_a ^ s_b;
-    return (@bitCast(i64, r) ^ s) -% s;
+    return (@as(i64, @bitCast(r)) ^ s) -% s;
 }
 
 pub fn _aulldiv() callconv(.Naked) void {

@@ -21,9 +21,9 @@ pub fn _allrem(a: i64, b: i64) callconv(.Stdcall) i64 {
     const an = (a ^ s_a) -% s_a;
     const bn = (b ^ s_b) -% s_b;
 
-    const r = @bitCast(u64, an) % @bitCast(u64, bn);
+    const r = @as(u64, @bitCast(an)) % @as(u64, @bitCast(bn));
     const s = s_a ^ s_b;
-    return (@bitCast(i64, r) ^ s) -% s;
+    return (@as(i64, @bitCast(r)) ^ s) -% s;
 }
 
 pub fn _aullrem() callconv(.Naked) void {

@@ -27,12 +27,12 @@ comptime {
 
 pub fn __ceilh(x: f16) callconv(.C) f16 {
     // TODO: more efficient implementation
-    return @floatCast(f16, ceilf(x));
+    return @as(f16, @floatCast(ceilf(x)));
 }
 
 pub fn ceilf(x: f32) callconv(.C) f32 {
-    var u = @bitCast(u32, x);
-    var e = @intCast(i32, (u >> 23) & 0xFF) - 0x7F;
+    var u = @as(u32, @bitCast(x));
+    var e = @as(i32, @intCast((u >> 23) & 0xFF)) - 0x7F;
     var m: u32 = undefined;
 
     // TODO: Shouldn't need this explicit check.
@@ -43,7 +43,7 @@ pub fn ceilf(x: f32) callconv(.C) f32 {
     if (e >= 23) {
         return x;
     } else if (e >= 0) {
-        m = @as(u32, 0x007FFFFF) >> @intCast(u5, e);
+        m = @as(u32, 0x007FFFFF) >> @as(u5, @intCast(e));
         if (u & m == 0) {
             return x;
         }
@@ -52,7 +52,7 @@ pub fn ceilf(x: f32) callconv(.C) f32 {
             u += m;
         }
         u &= ~m;
-        return @bitCast(f32, u);
+        return @as(f32, @bitCast(u));
     } else {
         math.doNotOptimizeAway(x + 0x1.0p120);
         if (u >> 31 != 0) {
@@ -66,7 +66,7 @@ pub fn ceilf(x: f32) callconv(.C) f32 {
 pub fn ceil(x: f64) callconv(.C) f64 {
     const f64_toint = 1.0 / math.floatEps(f64);
 
-    const u = @bitCast(u64, x);
+    const u = @as(u64, @bitCast(x));
     const e = (u >> 52) & 0x7FF;
     var y: f64 = undefined;
 
@@ -96,13 +96,13 @@ pub fn ceil(x: f64) callconv(.C) f64 {
 
 pub fn __ceilx(x: f80) callconv(.C) f80 {
     // TODO: more efficient implementation
-    return @floatCast(f80, ceilq(x));
+    return @as(f80, @floatCast(ceilq(x)));
 }
 
 pub fn ceilq(x: f128) callconv(.C) f128 {
     const f128_toint = 1.0 / math.floatEps(f128);
 
-    const u = @bitCast(u128, x);
+    const u = @as(u128, @bitCast(x));
     const e = (u >> 112) & 0x7FFF;
     var y: f128 = undefined;
 

@@ -102,7 +102,7 @@ fn clear_cache(start: usize, end: usize) callconv(.C) void {
         // If CTR_EL0.IDC is set, data cache cleaning to the point of unification
         // is not required for instruction to data coherence.
         if (((ctr_el0 >> 28) & 0x1) == 0x0) {
-            const dcache_line_size: usize = @as(usize, 4) << @intCast(u6, (ctr_el0 >> 16) & 15);
+            const dcache_line_size: usize = @as(usize, 4) << @as(u6, @intCast((ctr_el0 >> 16) & 15));
             addr = start & ~(dcache_line_size - 1);
             while (addr < end) : (addr += dcache_line_size) {
                 asm volatile ("dc cvau, %[addr]"
@@ -115,7 +115,7 @@ fn clear_cache(start: usize, end: usize) callconv(.C) void {
         // If CTR_EL0.DIC is set, instruction cache invalidation to the point of
         // unification is not required for instruction to data coherence.
         if (((ctr_el0 >> 29) & 0x1) == 0x0) {
-            const icache_line_size: usize = @as(usize, 4) << @intCast(u6, (ctr_el0 >> 0) & 15);
+            const icache_line_size: usize = @as(usize, 4) << @as(u6, @intCast((ctr_el0 >> 0) & 15));
             addr = start & ~(icache_line_size - 1);
             while (addr < end) : (addr += icache_line_size) {
                 asm volatile ("ic ivau, %[addr]"

@@ -2,7 +2,7 @@ const clz = @import("count0bits.zig");
 const testing = @import("std").testing;
 
 fn test__clzdi2(a: u64, expected: i64) !void {
-    var x = @bitCast(i64, a);
+    var x = @as(i64, @bitCast(a));
     var result = clz.__clzdi2(x);
     try testing.expectEqual(expected, result);
 }

@@ -4,8 +4,8 @@ const testing = @import("std").testing;
 
 fn test__clzsi2(a: u32, expected: i32) !void {
     const nakedClzsi2 = clz.__clzsi2;
-    const actualClzsi2 = @ptrCast(*const fn (a: i32) callconv(.C) i32, &nakedClzsi2);
-    const x = @bitCast(i32, a);
+    const actualClzsi2 = @as(*const fn (a: i32) callconv(.C) i32, @ptrCast(&nakedClzsi2));
+    const x = @as(i32, @bitCast(a));
     const result = actualClzsi2(x);
     try testing.expectEqual(expected, result);
 }

@@ -2,7 +2,7 @@ const clz = @import("count0bits.zig");
 const testing = @import("std").testing;
 
 fn test__clzti2(a: u128, expected: i64) !void {
-    var x = @bitCast(i128, a);
+    var x = @as(i128, @bitCast(a));
     var result = clz.__clzti2(x);
     try testing.expectEqual(expected, result);
 }

@@ -75,30 +75,30 @@ fn _Qp_cmp(a: *const f128, b: *const f128) callconv(.C) i32 {
 }
 
 fn _Qp_feq(a: *const f128, b: *const f128) callconv(.C) bool {
-    return @enumFromInt(SparcFCMP, _Qp_cmp(a, b)) == .Equal;
+    return @as(SparcFCMP, @enumFromInt(_Qp_cmp(a, b))) == .Equal;
 }
 
 fn _Qp_fne(a: *const f128, b: *const f128) callconv(.C) bool {
-    return @enumFromInt(SparcFCMP, _Qp_cmp(a, b)) != .Equal;
+    return @as(SparcFCMP, @enumFromInt(_Qp_cmp(a, b))) != .Equal;
 }
 
 fn _Qp_flt(a: *const f128, b: *const f128) callconv(.C) bool {
-    return @enumFromInt(SparcFCMP, _Qp_cmp(a, b)) == .Less;
+    return @as(SparcFCMP, @enumFromInt(_Qp_cmp(a, b))) == .Less;
 }
 
 fn _Qp_fgt(a: *const f128, b: *const f128) callconv(.C) bool {
-    return @enumFromInt(SparcFCMP, _Qp_cmp(a, b)) == .Greater;
+    return @as(SparcFCMP, @enumFromInt(_Qp_cmp(a, b))) == .Greater;
 }
 
 fn _Qp_fge(a: *const f128, b: *const f128) callconv(.C) bool {
-    return switch (@enumFromInt(SparcFCMP, _Qp_cmp(a, b))) {
+    return switch (@as(SparcFCMP, @enumFromInt(_Qp_cmp(a, b)))) {
         .Equal, .Greater => true,
         .Less, .Unordered => false,
     };
 }
 
 fn _Qp_fle(a: *const f128, b: *const f128) callconv(.C) bool {
-    return switch (@enumFromInt(SparcFCMP, _Qp_cmp(a, b))) {
+    return switch (@as(SparcFCMP, @enumFromInt(_Qp_cmp(a, b)))) {
         .Equal, .Less => true,
         .Greater, .Unordered => false,
     };

@@ -102,22 +102,22 @@ pub fn wideMultiply(comptime Z: type, a: Z, b: Z, hi: *Z, lo: *Z) void {
         u16 => {
             // 16x16 --> 32 bit multiply
             const product = @as(u32, a) * @as(u32, b);
-            hi.* = @intCast(u16, product >> 16);
-            lo.* = @truncate(u16, product);
+            hi.* = @as(u16, @intCast(product >> 16));
+            lo.* = @as(u16, @truncate(product));
         },
         u32 => {
             // 32x32 --> 64 bit multiply
             const product = @as(u64, a) * @as(u64, b);
-            hi.* = @truncate(u32, product >> 32);
-            lo.* = @truncate(u32, product);
+            hi.* = @as(u32, @truncate(product >> 32));
+            lo.* = @as(u32, @truncate(product));
         },
         u64 => {
             const S = struct {
                 fn loWord(x: u64) u64 {
-                    return @truncate(u32, x);
+                    return @as(u32, @truncate(x));
                 }
                 fn hiWord(x: u64) u64 {
-                    return @truncate(u32, x >> 32);
+                    return @as(u32, @truncate(x >> 32));
                 }
             };
             // 64x64 -> 128 wide multiply for platforms that don't have such an operation;
@@ -141,16 +141,16 @@ pub fn wideMultiply(comptime Z: type, a: Z, b: Z, hi: *Z, lo: *Z) void {
             const Word_FullMask = @as(u64, 0xffffffffffffffff);
             const S = struct {
                 fn Word_1(x: u128) u64 {
-                    return @truncate(u32, x >> 96);
+                    return @as(u32, @truncate(x >> 96));
                 }
                 fn Word_2(x: u128) u64 {
-                    return @truncate(u32, x >> 64);
+                    return @as(u32, @truncate(x >> 64));
                 }
                 fn Word_3(x: u128) u64 {
-                    return @truncate(u32, x >> 32);
+                    return @as(u32, @truncate(x >> 32));
                 }
                 fn Word_4(x: u128) u64 {
-                    return @truncate(u32, x);
+                    return @as(u32, @truncate(x));
                 }
             };
             // 128x128 -> 256 wide multiply for platforms that don't have such an operation;
@@ -216,7 +216,7 @@ pub fn normalize(comptime T: type, significand: *std.meta.Int(.unsigned, @typeIn
     const integerBit = @as(Z, 1) << std.math.floatFractionalBits(T);
 
     const shift = @clz(significand.*) - @clz(integerBit);
-    significand.* <<= @intCast(std.math.Log2Int(Z), shift);
+    significand.* <<= @as(std.math.Log2Int(Z), @intCast(shift));
     return @as(i32, 1) - shift;
 }
 
@@ -228,8 +228,8 @@ pub inline fn fneg(a: anytype) @TypeOf(a) {
         .bits = bits,
     } });
     const sign_bit_mask = @as(U, 1) << (bits - 1);
-    const negated = @bitCast(U, a) ^ sign_bit_mask;
-    return @bitCast(F, negated);
+    const negated = @as(U, @bitCast(a)) ^ sign_bit_mask;
+    return @as(F, @bitCast(negated));
 }
 
 /// Allows to access underlying bits as two equally sized lower and higher

@@ -26,12 +26,12 @@ pub inline fn cmpf2(comptime T: type, comptime RT: type, a: T, b: T) RT {
     const signBit = (@as(rep_t, 1) << (significandBits + exponentBits));
     const absMask = signBit - 1;
     const infT = comptime std.math.inf(T);
-    const infRep = @bitCast(rep_t, infT);
+    const infRep = @as(rep_t, @bitCast(infT));
 
-    const aInt = @bitCast(srep_t, a);
-    const bInt = @bitCast(srep_t, b);
-    const aAbs = @bitCast(rep_t, aInt) & absMask;
-    const bAbs = @bitCast(rep_t, bInt) & absMask;
+    const aInt = @as(srep_t, @bitCast(a));
+    const bInt = @as(srep_t, @bitCast(b));
+    const aAbs = @as(rep_t, @bitCast(aInt)) & absMask;
+    const bAbs = @as(rep_t, @bitCast(bInt)) & absMask;
 
     // If either a or b is NaN, they are unordered.
     if (aAbs > infRep or bAbs > infRep) return RT.Unordered;
@@ -81,7 +81,7 @@ pub inline fn cmp_f80(comptime RT: type, a: f80, b: f80) RT {
         return .Equal;
     } else if (a_rep.exp & sign_bit != b_rep.exp & sign_bit) {
         // signs are different
-        if (@bitCast(i16, a_rep.exp) < @bitCast(i16, b_rep.exp)) {
+        if (@as(i16, @bitCast(a_rep.exp)) < @as(i16, @bitCast(b_rep.exp))) {
             return .Less;
         } else {
             return .Greater;
@@ -104,10 +104,10 @@ pub inline fn unordcmp(comptime T: type, a: T, b: T) i32 {
     const exponentBits = std.math.floatExponentBits(T);
     const signBit = (@as(rep_t, 1) << (significandBits + exponentBits));
     const absMask = signBit - 1;
-    const infRep = @bitCast(rep_t, std.math.inf(T));
+    const infRep = @as(rep_t, @bitCast(std.math.inf(T)));
 
-    const aAbs: rep_t = @bitCast(rep_t, a) & absMask;
-    const bAbs: rep_t = @bitCast(rep_t, b) & absMask;
+    const aAbs: rep_t = @as(rep_t, @bitCast(a)) & absMask;
+    const bAbs: rep_t = @as(rep_t, @bitCast(b)) & absMask;
 
     return @intFromBool(aAbs > infRep or bAbs > infRep);
 }

@@ -25,7 +25,7 @@ comptime {
 
 pub fn __cosh(a: f16) callconv(.C) f16 {
     // TODO: more efficient implementation
-    return @floatCast(f16, cosf(a));
+    return @as(f16, @floatCast(cosf(a)));
 }
 
 pub fn cosf(x: f32) callconv(.C) f32 {
@@ -35,7 +35,7 @@ pub fn cosf(x: f32) callconv(.C) f32 {
     const c3pio2: f64 = 3.0 * math.pi / 2.0; // 0x4012D97C, 0x7F3321D2
     const c4pio2: f64 = 4.0 * math.pi / 2.0; // 0x401921FB, 0x54442D18
 
-    var ix = @bitCast(u32, x);
+    var ix = @as(u32, @bitCast(x));
     const sign = ix >> 31 != 0;
     ix &= 0x7fffffff;
 
@@ -86,7 +86,7 @@ pub fn cosf(x: f32) callconv(.C) f32 {
 }
 
 pub fn cos(x: f64) callconv(.C) f64 {
-    var ix = @bitCast(u64, x) >> 32;
+    var ix = @as(u64, @bitCast(x)) >> 32;
     ix &= 0x7fffffff;
 
     // |x| ~< pi/4
@@ -116,12 +116,12 @@ pub fn cos(x: f64) callconv(.C) f64 {
 
 pub fn __cosx(a: f80) callconv(.C) f80 {
     // TODO: more efficient implementation
-    return @floatCast(f80, cosq(a));
+    return @as(f80, @floatCast(cosq(a)));
 }
 
 pub fn cosq(a: f128) callconv(.C) f128 {
     // TODO: more correct implementation
-    return cos(@floatCast(f64, a));
+    return cos(@as(f64, @floatCast(a)));
 }
 
 pub fn cosl(x: c_longdouble) callconv(.C) c_longdouble {

@@ -32,9 +32,9 @@ comptime {
 
 inline fn clzXi2(comptime T: type, a: T) i32 {
     var x = switch (@bitSizeOf(T)) {
-        32 => @bitCast(u32, a),
-        64 => @bitCast(u64, a),
-        128 => @bitCast(u128, a),
+        32 => @as(u32, @bitCast(a)),
+        64 => @as(u64, @bitCast(a)),
+        128 => @as(u128, @bitCast(a)),
         else => unreachable,
     };
     var n: T = @bitSizeOf(T);
@@ -49,7 +49,7 @@ inline fn clzXi2(comptime T: type, a: T) i32 {
             x = y;
         }
     }
-    return @intCast(i32, n - @bitCast(T, x));
+    return @as(i32, @intCast(n - @as(T, @bitCast(x))));
 }
 
 fn __clzsi2_thumb1() callconv(.Naked) void {
@@ -169,9 +169,9 @@ pub fn __clzti2(a: i128) callconv(.C) i32 {
 
 inline fn ctzXi2(comptime T: type, a: T) i32 {
     var x = switch (@bitSizeOf(T)) {
-        32 => @bitCast(u32, a),
-        64 => @bitCast(u64, a),
-        128 => @bitCast(u128, a),
+        32 => @as(u32, @bitCast(a)),
+        64 => @as(u64, @bitCast(a)),
+        128 => @as(u128, @bitCast(a)),
         else => unreachable,
     };
     var n: T = 1;
@@ -187,7 +187,7 @@ inline fn ctzXi2(comptime T: type, a: T) i32 {
             x = x >> shift;
         }
     }
-    return @intCast(i32, n - @bitCast(T, (x & 1)));
+    return @as(i32, @intCast(n - @as(T, @bitCast((x & 1)))));
 }
 
 pub fn __ctzsi2(a: i32) callconv(.C) i32 {
@@ -204,9 +204,9 @@ pub fn __ctzti2(a: i128) callconv(.C) i32 {
 
 inline fn ffsXi2(comptime T: type, a: T) i32 {
     var x = switch (@bitSizeOf(T)) {
-        32 => @bitCast(u32, a),
-        64 => @bitCast(u64, a),
-        128 => @bitCast(u128, a),
+        32 => @as(u32, @bitCast(a)),
+        64 => @as(u64, @bitCast(a)),
+        128 => @as(u128, @bitCast(a)),
         else => unreachable,
     };
     var n: T = 1;
@@ -224,7 +224,7 @@ inline fn ffsXi2(comptime T: type, a: T) i32 {
         }
     }
     // return ctz + 1
-    return @intCast(i32, n - @bitCast(T, (x & 1))) + @as(i32, 1);
+    return @as(i32, @intCast(n - @as(T, @bitCast((x & 1))))) + @as(i32, 1);
 }
 
 pub fn __ffssi2(a: i32) callconv(.C) i32 {

@@ -2,7 +2,7 @@ const ctz = @import("count0bits.zig");
 const testing = @import("std").testing;
 
 fn test__ctzdi2(a: u64, expected: i32) !void {
-    var x = @bitCast(i64, a);
+    var x = @as(i64, @bitCast(a));
     var result = ctz.__ctzdi2(x);
     try testing.expectEqual(expected, result);
 }

@@ -2,7 +2,7 @@ const ctz = @import("count0bits.zig");
 const testing = @import("std").testing;
 
 fn test__ctzsi2(a: u32, expected: i32) !void {
-    var x = @bitCast(i32, a);
+    var x = @as(i32, @bitCast(a));
     var result = ctz.__ctzsi2(x);
     try testing.expectEqual(expected, result);
 }

@@ -2,7 +2,7 @@ const ctz = @import("count0bits.zig");
 const testing = @import("std").testing;
 
 fn test__ctzti2(a: u128, expected: i32) !void {
-    var x = @bitCast(i128, a);
+    var x = @as(i128, @bitCast(a));
     var result = ctz.__ctzti2(x);
     try testing.expectEqual(expected, result);
 }

@@ -47,52 +47,52 @@ inline fn div(a: f64, b: f64) f64 {
     const absMask = signBit - 1;
     const exponentMask = absMask ^ significandMask;
     const qnanRep = exponentMask | quietBit;
-    const infRep = @bitCast(Z, std.math.inf(f64));
+    const infRep = @as(Z, @bitCast(std.math.inf(f64)));
 
-    const aExponent = @truncate(u32, (@bitCast(Z, a) >> significandBits) & maxExponent);
-    const bExponent = @truncate(u32, (@bitCast(Z, b) >> significandBits) & maxExponent);
-    const quotientSign: Z = (@bitCast(Z, a) ^ @bitCast(Z, b)) & signBit;
+    const aExponent = @as(u32, @truncate((@as(Z, @bitCast(a)) >> significandBits) & maxExponent));
+    const bExponent = @as(u32, @truncate((@as(Z, @bitCast(b)) >> significandBits) & maxExponent));
+    const quotientSign: Z = (@as(Z, @bitCast(a)) ^ @as(Z, @bitCast(b))) & signBit;
 
-    var aSignificand: Z = @bitCast(Z, a) & significandMask;
-    var bSignificand: Z = @bitCast(Z, b) & significandMask;
+    var aSignificand: Z = @as(Z, @bitCast(a)) & significandMask;
+    var bSignificand: Z = @as(Z, @bitCast(b)) & significandMask;
     var scale: i32 = 0;
 
     // Detect if a or b is zero, denormal, infinity, or NaN.
     if (aExponent -% 1 >= maxExponent - 1 or bExponent -% 1 >= maxExponent - 1) {
-        const aAbs: Z = @bitCast(Z, a) & absMask;
-        const bAbs: Z = @bitCast(Z, b) & absMask;
+        const aAbs: Z = @as(Z, @bitCast(a)) & absMask;
+        const bAbs: Z = @as(Z, @bitCast(b)) & absMask;
 
         // NaN / anything = qNaN
-        if (aAbs > infRep) return @bitCast(f64, @bitCast(Z, a) | quietBit);
+        if (aAbs > infRep) return @as(f64, @bitCast(@as(Z, @bitCast(a)) | quietBit));
         // anything / NaN = qNaN
-        if (bAbs > infRep) return @bitCast(f64, @bitCast(Z, b) | quietBit);
+        if (bAbs > infRep) return @as(f64, @bitCast(@as(Z, @bitCast(b)) | quietBit));
 
         if (aAbs == infRep) {
             // infinity / infinity = NaN
             if (bAbs == infRep) {
-                return @bitCast(f64, qnanRep);
+                return @as(f64, @bitCast(qnanRep));
             }
             // infinity / anything else = +/- infinity
             else {
-                return @bitCast(f64, aAbs | quotientSign);
+                return @as(f64, @bitCast(aAbs | quotientSign));
             }
         }
 
         // anything else / infinity = +/- 0
-        if (bAbs == infRep) return @bitCast(f64, quotientSign);
+        if (bAbs == infRep) return @as(f64, @bitCast(quotientSign));
 
         if (aAbs == 0) {
             // zero / zero = NaN
             if (bAbs == 0) {
-                return @bitCast(f64, qnanRep);
+                return @as(f64, @bitCast(qnanRep));
             }
             // zero / anything else = +/- zero
             else {
-                return @bitCast(f64, quotientSign);
+                return @as(f64, @bitCast(quotientSign));
             }
         }
         // anything else / zero = +/- infinity
-        if (bAbs == 0) return @bitCast(f64, infRep | quotientSign);
+        if (bAbs == 0) return @as(f64, @bitCast(infRep | quotientSign));
 
         // one or both of a or b is denormal, the other (if applicable) is a
         // normal number.  Renormalize one or both of a and b, and set scale to
@@ -106,13 +106,13 @@ inline fn div(a: f64, b: f64) f64 {
     // won't hurt anything.)
     aSignificand |= implicitBit;
     bSignificand |= implicitBit;
-    var quotientExponent: i32 = @bitCast(i32, aExponent -% bExponent) +% scale;
+    var quotientExponent: i32 = @as(i32, @bitCast(aExponent -% bExponent)) +% scale;
 
     // Align the significand of b as a Q31 fixed-point number in the range
     // [1, 2.0) and get a Q32 approximate reciprocal using a small minimax
     // polynomial approximation: reciprocal = 3/4 + 1/sqrt(2) - b/2.  This
     // is accurate to about 3.5 binary digits.
-    const q31b: u32 = @truncate(u32, bSignificand >> 21);
+    const q31b: u32 = @as(u32, @truncate(bSignificand >> 21));
     var recip32 = @as(u32, 0x7504f333) -% q31b;
 
     // Now refine the reciprocal estimate using a Newton-Raphson iteration:
@@ -123,12 +123,12 @@ inline fn div(a: f64, b: f64) f64 {
     // with each iteration, so after three iterations, we have about 28 binary
     // digits of accuracy.
     var correction32: u32 = undefined;
-    correction32 = @truncate(u32, ~(@as(u64, recip32) *% q31b >> 32) +% 1);
-    recip32 = @truncate(u32, @as(u64, recip32) *% correction32 >> 31);
-    correction32 = @truncate(u32, ~(@as(u64, recip32) *% q31b >> 32) +% 1);
-    recip32 = @truncate(u32, @as(u64, recip32) *% correction32 >> 31);
-    correction32 = @truncate(u32, ~(@as(u64, recip32) *% q31b >> 32) +% 1);
-    recip32 = @truncate(u32, @as(u64, recip32) *% correction32 >> 31);
+    correction32 = @as(u32, @truncate(~(@as(u64, recip32) *% q31b >> 32) +% 1));
+    recip32 = @as(u32, @truncate(@as(u64, recip32) *% correction32 >> 31));
+    correction32 = @as(u32, @truncate(~(@as(u64, recip32) *% q31b >> 32) +% 1));
+    recip32 = @as(u32, @truncate(@as(u64, recip32) *% correction32 >> 31));
+    correction32 = @as(u32, @truncate(~(@as(u64, recip32) *% q31b >> 32) +% 1));
+    recip32 = @as(u32, @truncate(@as(u64, recip32) *% correction32 >> 31));
 
     // recip32 might have overflowed to exactly zero in the preceding
     // computation if the high word of b is exactly 1.0.  This would sabotage
@@ -138,12 +138,12 @@ inline fn div(a: f64, b: f64) f64 {
 
     // We need to perform one more iteration to get us to 56 binary digits;
     // The last iteration needs to happen with extra precision.
-    const q63blo: u32 = @truncate(u32, bSignificand << 11);
+    const q63blo: u32 = @as(u32, @truncate(bSignificand << 11));
     var correction: u64 = undefined;
     var reciprocal: u64 = undefined;
     correction = ~(@as(u64, recip32) *% q31b +% (@as(u64, recip32) *% q63blo >> 32)) +% 1;
-    const cHi = @truncate(u32, correction >> 32);
-    const cLo = @truncate(u32, correction);
+    const cHi = @as(u32, @truncate(correction >> 32));
+    const cLo = @as(u32, @truncate(correction));
     reciprocal = @as(u64, recip32) *% cHi +% (@as(u64, recip32) *% cLo >> 32);
 
     // We already adjusted the 32-bit estimate, now we need to adjust the final
@@ -195,7 +195,7 @@ inline fn div(a: f64, b: f64) f64 {
 
     if (writtenExponent >= maxExponent) {
         // If we have overflowed the exponent, return infinity.
-        return @bitCast(f64, infRep | quotientSign);
+        return @as(f64, @bitCast(infRep | quotientSign));
     } else if (writtenExponent < 1) {
         if (writtenExponent == 0) {
             // Check whether the rounded result is normal.
@@ -206,22 +206,22 @@ inline fn div(a: f64, b: f64) f64 {
             absResult += round;
             if ((absResult & ~significandMask) != 0) {
                 // The rounded result is normal; return it.
-                return @bitCast(f64, absResult | quotientSign);
+                return @as(f64, @bitCast(absResult | quotientSign));
             }
         }
         // Flush denormals to zero.  In the future, it would be nice to add
         // code to round them correctly.
-        return @bitCast(f64, quotientSign);
+        return @as(f64, @bitCast(quotientSign));
     } else {
         const round = @intFromBool((residual << 1) > bSignificand);
         // Clear the implicit bit
         var absResult = quotient & significandMask;
         // Insert the exponent
-        absResult |= @bitCast(Z, @as(SignedZ, writtenExponent)) << significandBits;
+        absResult |= @as(Z, @bitCast(@as(SignedZ, writtenExponent))) << significandBits;
         // Round
         absResult +%= round;
         // Insert the sign and return
-        return @bitCast(f64, absResult | quotientSign);
+        return @as(f64, @bitCast(absResult | quotientSign));
     }
 }
 

@@ -6,7 +6,7 @@ const __divdf3 = @import("divdf3.zig").__divdf3;
 const testing = @import("std").testing;
 
 fn compareResultD(result: f64, expected: u64) bool {
-    const rep = @bitCast(u64, result);
+    const rep = @as(u64, @bitCast(result));
 
     if (rep == expected) {
         return true;

@@ -7,5 +7,5 @@ comptime {
 
 pub fn __divhf3(a: f16, b: f16) callconv(.C) f16 {
     // TODO: more efficient implementation
-    return @floatCast(f16, divsf3.__divsf3(a, b));
+    return @as(f16, @floatCast(divsf3.__divsf3(a, b)));
 }

@@ -44,52 +44,52 @@ inline fn div(a: f32, b: f32) f32 {
     const absMask = signBit - 1;
     const exponentMask = absMask ^ significandMask;
     const qnanRep = exponentMask | quietBit;
-    const infRep = @bitCast(Z, std.math.inf(f32));
+    const infRep = @as(Z, @bitCast(std.math.inf(f32)));
 
-    const aExponent = @truncate(u32, (@bitCast(Z, a) >> significandBits) & maxExponent);
-    const bExponent = @truncate(u32, (@bitCast(Z, b) >> significandBits) & maxExponent);
-    const quotientSign: Z = (@bitCast(Z, a) ^ @bitCast(Z, b)) & signBit;
+    const aExponent = @as(u32, @truncate((@as(Z, @bitCast(a)) >> significandBits) & maxExponent));
+    const bExponent = @as(u32, @truncate((@as(Z, @bitCast(b)) >> significandBits) & maxExponent));
+    const quotientSign: Z = (@as(Z, @bitCast(a)) ^ @as(Z, @bitCast(b))) & signBit;
 
-    var aSignificand: Z = @bitCast(Z, a) & significandMask;
-    var bSignificand: Z = @bitCast(Z, b) & significandMask;
+    var aSignificand: Z = @as(Z, @bitCast(a)) & significandMask;
+    var bSignificand: Z = @as(Z, @bitCast(b)) & significandMask;
     var scale: i32 = 0;
 
     // Detect if a or b is zero, denormal, infinity, or NaN.
     if (aExponent -% 1 >= maxExponent - 1 or bExponent -% 1 >= maxExponent - 1) {
-        const aAbs: Z = @bitCast(Z, a) & absMask;
-        const bAbs: Z = @bitCast(Z, b) & absMask;
+        const aAbs: Z = @as(Z, @bitCast(a)) & absMask;
+        const bAbs: Z = @as(Z, @bitCast(b)) & absMask;
 
         // NaN / anything = qNaN
-        if (aAbs > infRep) return @bitCast(f32, @bitCast(Z, a) | quietBit);
+        if (aAbs > infRep) return @as(f32, @bitCast(@as(Z, @bitCast(a)) | quietBit));
         // anything / NaN = qNaN
-        if (bAbs > infRep) return @bitCast(f32, @bitCast(Z, b) | quietBit);
+        if (bAbs > infRep) return @as(f32, @bitCast(@as(Z, @bitCast(b)) | quietBit));
 
         if (aAbs == infRep) {
             // infinity / infinity = NaN
             if (bAbs == infRep) {
-                return @bitCast(f32, qnanRep);
+                return @as(f32, @bitCast(qnanRep));
             }
             // infinity / anything else = +/- infinity
             else {
-                return @bitCast(f32, aAbs | quotientSign);
+                return @as(f32, @bitCast(aAbs | quotientSign));
             }
         }
 
         // anything else / infinity = +/- 0
-        if (bAbs == infRep) return @bitCast(f32, quotientSign);
+        if (bAbs == infRep) return @as(f32, @bitCast(quotientSign));
 
         if (aAbs == 0) {
             // zero / zero = NaN
             if (bAbs == 0) {
-                return @bitCast(f32, qnanRep);
+                return @as(f32, @bitCast(qnanRep));
             }
             // zero / anything else = +/- zero
             else {
-                return @bitCast(f32, quotientSign);
+                return @as(f32, @bitCast(quotientSign));
             }
         }
         // anything else / zero = +/- infinity
-        if (bAbs == 0) return @bitCast(f32, infRep | quotientSign);
+        if (bAbs == 0) return @as(f32, @bitCast(infRep | quotientSign));
 
         // one or both of a or b is denormal, the other (if applicable) is a
         // normal number.  Renormalize one or both of a and b, and set scale to
@@ -103,7 +103,7 @@ inline fn div(a: f32, b: f32) f32 {
     // won't hurt anything.)
     aSignificand |= implicitBit;
     bSignificand |= implicitBit;
-    var quotientExponent: i32 = @bitCast(i32, aExponent -% bExponent) +% scale;
+    var quotientExponent: i32 = @as(i32, @bitCast(aExponent -% bExponent)) +% scale;
 
     // Align the significand of b as a Q31 fixed-point number in the range
     // [1, 2.0) and get a Q32 approximate reciprocal using a small minimax
@@ -120,12 +120,12 @@ inline fn div(a: f32, b: f32) f32 {
     // with each iteration, so after three iterations, we have about 28 binary
     // digits of accuracy.
     var correction: u32 = undefined;
-    correction = @truncate(u32, ~(@as(u64, reciprocal) *% q31b >> 32) +% 1);
-    reciprocal = @truncate(u32, @as(u64, reciprocal) *% correction >> 31);
-    correction = @truncate(u32, ~(@as(u64, reciprocal) *% q31b >> 32) +% 1);
-    reciprocal = @truncate(u32, @as(u64, reciprocal) *% correction >> 31);
-    correction = @truncate(u32, ~(@as(u64, reciprocal) *% q31b >> 32) +% 1);
-    reciprocal = @truncate(u32, @as(u64, reciprocal) *% correction >> 31);
+    correction = @as(u32, @truncate(~(@as(u64, reciprocal) *% q31b >> 32) +% 1));
+    reciprocal = @as(u32, @truncate(@as(u64, reciprocal) *% correction >> 31));
+    correction = @as(u32, @truncate(~(@as(u64, reciprocal) *% q31b >> 32) +% 1));
+    reciprocal = @as(u32, @truncate(@as(u64, reciprocal) *% correction >> 31));
+    correction = @as(u32, @truncate(~(@as(u64, reciprocal) *% q31b >> 32) +% 1));
+    reciprocal = @as(u32, @truncate(@as(u64, reciprocal) *% correction >> 31));
 
     // Exhaustive testing shows that the error in reciprocal after three steps
     // is in the interval [-0x1.f58108p-31, 0x1.d0e48cp-29], in line with our
@@ -147,7 +147,7 @@ inline fn div(a: f32, b: f32) f32 {
     //       is the error in the reciprocal of b scaled by the maximum
     //       possible value of a.  As a consequence of this error bound,
     //       either q or nextafter(q) is the correctly rounded
-    var quotient: Z = @truncate(u32, @as(u64, reciprocal) *% (aSignificand << 1) >> 32);
+    var quotient: Z = @as(u32, @truncate(@as(u64, reciprocal) *% (aSignificand << 1) >> 32));
 
     // Two cases: quotient is in [0.5, 1.0) or quotient is in [1.0, 2.0).
     // In either case, we are going to compute a residual of the form
@@ -175,7 +175,7 @@ inline fn div(a: f32, b: f32) f32 {
 
     if (writtenExponent >= maxExponent) {
         // If we have overflowed the exponent, return infinity.
-        return @bitCast(f32, infRep | quotientSign);
+        return @as(f32, @bitCast(infRep | quotientSign));
     } else if (writtenExponent < 1) {
         if (writtenExponent == 0) {
             // Check whether the rounded result is normal.
@@ -186,22 +186,22 @@ inline fn div(a: f32, b: f32) f32 {
             absResult += round;
             if ((absResult & ~significandMask) > 0) {
                 // The rounded result is normal; return it.
-                return @bitCast(f32, absResult | quotientSign);
+                return @as(f32, @bitCast(absResult | quotientSign));
             }
         }
         // Flush denormals to zero.  In the future, it would be nice to add
         // code to round them correctly.
-        return @bitCast(f32, quotientSign);
+        return @as(f32, @bitCast(quotientSign));
     } else {
         const round = @intFromBool((residual << 1) > bSignificand);
         // Clear the implicit bit
         var absResult = quotient & significandMask;
         // Insert the exponent
-        absResult |= @bitCast(Z, writtenExponent) << significandBits;
+        absResult |= @as(Z, @bitCast(writtenExponent)) << significandBits;
         // Round
         absResult +%= round;
         // Insert the sign and return
-        return @bitCast(f32, absResult | quotientSign);
+        return @as(f32, @bitCast(absResult | quotientSign));
     }
 }
 

@@ -6,7 +6,7 @@ const __divsf3 = @import("divsf3.zig").__divsf3;
 const testing = @import("std").testing;
 
 fn compareResultF(result: f32, expected: u32) bool {
-    const rep = @bitCast(u32, result);
+    const rep = @as(u32, @bitCast(result));
 
     if (rep == expected) {
         return true;

@@ -41,52 +41,52 @@ inline fn div(a: f128, b: f128) f128 {
     const absMask = signBit - 1;
     const exponentMask = absMask ^ significandMask;
     const qnanRep = exponentMask | quietBit;
-    const infRep = @bitCast(Z, std.math.inf(f128));
+    const infRep = @as(Z, @bitCast(std.math.inf(f128)));
 
-    const aExponent = @truncate(u32, (@bitCast(Z, a) >> significandBits) & maxExponent);
-    const bExponent = @truncate(u32, (@bitCast(Z, b) >> significandBits) & maxExponent);
-    const quotientSign: Z = (@bitCast(Z, a) ^ @bitCast(Z, b)) & signBit;
+    const aExponent = @as(u32, @truncate((@as(Z, @bitCast(a)) >> significandBits) & maxExponent));
+    const bExponent = @as(u32, @truncate((@as(Z, @bitCast(b)) >> significandBits) & maxExponent));
+    const quotientSign: Z = (@as(Z, @bitCast(a)) ^ @as(Z, @bitCast(b))) & signBit;
 
-    var aSignificand: Z = @bitCast(Z, a) & significandMask;
-    var bSignificand: Z = @bitCast(Z, b) & significandMask;
+    var aSignificand: Z = @as(Z, @bitCast(a)) & significandMask;
+    var bSignificand: Z = @as(Z, @bitCast(b)) & significandMask;
     var scale: i32 = 0;
 
     // Detect if a or b is zero, denormal, infinity, or NaN.
     if (aExponent -% 1 >= maxExponent - 1 or bExponent -% 1 >= maxExponent - 1) {
-        const aAbs: Z = @bitCast(Z, a) & absMask;
-        const bAbs: Z = @bitCast(Z, b) & absMask;
+        const aAbs: Z = @as(Z, @bitCast(a)) & absMask;
+        const bAbs: Z = @as(Z, @bitCast(b)) & absMask;
 
         // NaN / anything = qNaN
-        if (aAbs > infRep) return @bitCast(f128, @bitCast(Z, a) | quietBit);
+        if (aAbs > infRep) return @as(f128, @bitCast(@as(Z, @bitCast(a)) | quietBit));
         // anything / NaN = qNaN
-        if (bAbs > infRep) return @bitCast(f128, @bitCast(Z, b) | quietBit);
+        if (bAbs > infRep) return @as(f128, @bitCast(@as(Z, @bitCast(b)) | quietBit));
 
         if (aAbs == infRep) {
             // infinity / infinity = NaN
             if (bAbs == infRep) {
-                return @bitCast(f128, qnanRep);
+                return @as(f128, @bitCast(qnanRep));
             }
             // infinity / anything else = +/- infinity
             else {
-                return @bitCast(f128, aAbs | quotientSign);
+                return @as(f128, @bitCast(aAbs | quotientSign));
             }
         }
 
         // anything else / infinity = +/- 0
-        if (bAbs == infRep) return @bitCast(f128, quotientSign);
+        if (bAbs == infRep) return @as(f128, @bitCast(quotientSign));
 
         if (aAbs == 0) {
             // zero / zero = NaN
             if (bAbs == 0) {
-                return @bitCast(f128, qnanRep);
+                return @as(f128, @bitCast(qnanRep));
             }
             // zero / anything else = +/- zero
             else {
-                return @bitCast(f128, quotientSign);
+                return @as(f128, @bitCast(quotientSign));
             }
         }
         // anything else / zero = +/- infinity
-        if (bAbs == 0) return @bitCast(f128, infRep | quotientSign);
+        if (bAbs == 0) return @as(f128, @bitCast(infRep | quotientSign));
 
         // one or both of a or b is denormal, the other (if applicable) is a
         // normal number.  Renormalize one or both of a and b, and set scale to
@@ -100,13 +100,13 @@ inline fn div(a: f128, b: f128) f128 {
     // won't hurt anything.
     aSignificand |= implicitBit;
     bSignificand |= implicitBit;
-    var quotientExponent: i32 = @bitCast(i32, aExponent -% bExponent) +% scale;
+    var quotientExponent: i32 = @as(i32, @bitCast(aExponent -% bExponent)) +% scale;
 
     // Align the significand of b as a Q63 fixed-point number in the range
     // [1, 2.0) and get a Q64 approximate reciprocal using a small minimax
     // polynomial approximation: reciprocal = 3/4 + 1/sqrt(2) - b/2.  This
     // is accurate to about 3.5 binary digits.
-    const q63b = @truncate(u64, bSignificand >> 49);
+    const q63b = @as(u64, @truncate(bSignificand >> 49));
     var recip64 = @as(u64, 0x7504f333F9DE6484) -% q63b;
     // 0x7504f333F9DE6484 / 2^64 + 1 = 3/4 + 1/sqrt(2)
 
@@ -117,16 +117,16 @@ inline fn div(a: f128, b: f128) f128 {
     // This doubles the number of correct binary digits in the approximation
     // with each iteration.
     var correction64: u64 = undefined;
-    correction64 = @truncate(u64, ~(@as(u128, recip64) *% q63b >> 64) +% 1);
-    recip64 = @truncate(u64, @as(u128, recip64) *% correction64 >> 63);
-    correction64 = @truncate(u64, ~(@as(u128, recip64) *% q63b >> 64) +% 1);
-    recip64 = @truncate(u64, @as(u128, recip64) *% correction64 >> 63);
-    correction64 = @truncate(u64, ~(@as(u128, recip64) *% q63b >> 64) +% 1);
-    recip64 = @truncate(u64, @as(u128, recip64) *% correction64 >> 63);
-    correction64 = @truncate(u64, ~(@as(u128, recip64) *% q63b >> 64) +% 1);
-    recip64 = @truncate(u64, @as(u128, recip64) *% correction64 >> 63);
-    correction64 = @truncate(u64, ~(@as(u128, recip64) *% q63b >> 64) +% 1);
-    recip64 = @truncate(u64, @as(u128, recip64) *% correction64 >> 63);
+    correction64 = @as(u64, @truncate(~(@as(u128, recip64) *% q63b >> 64) +% 1));
+    recip64 = @as(u64, @truncate(@as(u128, recip64) *% correction64 >> 63));
+    correction64 = @as(u64, @truncate(~(@as(u128, recip64) *% q63b >> 64) +% 1));
+    recip64 = @as(u64, @truncate(@as(u128, recip64) *% correction64 >> 63));
+    correction64 = @as(u64, @truncate(~(@as(u128, recip64) *% q63b >> 64) +% 1));
+    recip64 = @as(u64, @truncate(@as(u128, recip64) *% correction64 >> 63));
+    correction64 = @as(u64, @truncate(~(@as(u128, recip64) *% q63b >> 64) +% 1));
+    recip64 = @as(u64, @truncate(@as(u128, recip64) *% correction64 >> 63));
+    correction64 = @as(u64, @truncate(~(@as(u128, recip64) *% q63b >> 64) +% 1));
+    recip64 = @as(u64, @truncate(@as(u128, recip64) *% correction64 >> 63));
 
     // The reciprocal may have overflowed to zero if the upper half of b is
     // exactly 1.0.  This would sabatoge the full-width final stage of the
@@ -135,7 +135,7 @@ inline fn div(a: f128, b: f128) f128 {
 
     // We need to perform one more iteration to get us to 112 binary digits;
     // The last iteration needs to happen with extra precision.
-    const q127blo: u64 = @truncate(u64, bSignificand << 15);
+    const q127blo: u64 = @as(u64, @truncate(bSignificand << 15));
     var correction: u128 = undefined;
     var reciprocal: u128 = undefined;
 
@@ -151,8 +151,8 @@ inline fn div(a: f128, b: f128) f128 {
 
     correction = -%(r64q63 + (r64q127 >> 64));
 
-    const cHi = @truncate(u64, correction >> 64);
-    const cLo = @truncate(u64, correction);
+    const cHi = @as(u64, @truncate(correction >> 64));
+    const cLo = @as(u64, @truncate(correction));
 
     wideMultiply(u128, recip64, cHi, &dummy, &r64cH);
     wideMultiply(u128, recip64, cLo, &dummy, &r64cL);
@@ -210,7 +210,7 @@ inline fn div(a: f128, b: f128) f128 {
 
     if (writtenExponent >= maxExponent) {
         // If we have overflowed the exponent, return infinity.
-        return @bitCast(f128, infRep | quotientSign);
+        return @as(f128, @bitCast(infRep | quotientSign));
     } else if (writtenExponent < 1) {
         if (writtenExponent == 0) {
             // Check whether the rounded result is normal.
@@ -221,22 +221,22 @@ inline fn div(a: f128, b: f128) f128 {
             absResult += round;
             if ((absResult & ~significandMask) > 0) {
                 // The rounded result is normal; return it.
-                return @bitCast(f128, absResult | quotientSign);
+                return @as(f128, @bitCast(absResult | quotientSign));
             }
         }
         // Flush denormals to zero.  In the future, it would be nice to add
         // code to round them correctly.
-        return @bitCast(f128, quotientSign);
+        return @as(f128, @bitCast(quotientSign));
     } else {
         const round = @intFromBool((residual << 1) >= bSignificand);
         // Clear the implicit bit
         var absResult = quotient & significandMask;
         // Insert the exponent
-        absResult |= @intCast(Z, writtenExponent) << significandBits;
+        absResult |= @as(Z, @intCast(writtenExponent)) << significandBits;
         // Round
         absResult +%= round;
         // Insert the sign and return
-        return @bitCast(f128, absResult | quotientSign);
+        return @as(f128, @bitCast(absResult | quotientSign));
     }
 }
 

@@ -5,9 +5,9 @@ const testing = std.testing;
 const __divtf3 = @import("divtf3.zig").__divtf3;
 
 fn compareResultLD(result: f128, expectedHi: u64, expectedLo: u64) bool {
-    const rep = @bitCast(u128, result);
-    const hi = @truncate(u64, rep >> 64);
-    const lo = @truncate(u64, rep);
+    const rep = @as(u128, @bitCast(result));
+    const hi = @as(u64, @truncate(rep >> 64));
+    const lo = @as(u64, @truncate(rep));
 
     if (hi == expectedHi and lo == expectedLo) {
         return true;

@@ -21,7 +21,7 @@ pub fn __divti3(a: i128, b: i128) callconv(.C) i128 {
 const v128 = @Vector(2, u64);
 
 fn __divti3_windows_x86_64(a: v128, b: v128) callconv(.C) v128 {
-    return @bitCast(v128, div(@bitCast(i128, a), @bitCast(i128, b)));
+    return @as(v128, @bitCast(div(@as(i128, @bitCast(a)), @as(i128, @bitCast(b)))));
 }
 
 inline fn div(a: i128, b: i128) i128 {
@@ -31,9 +31,9 @@ inline fn div(a: i128, b: i128) i128 {
     const an = (a ^ s_a) -% s_a;
     const bn = (b ^ s_b) -% s_b;
 
-    const r = udivmod(u128, @bitCast(u128, an), @bitCast(u128, bn), null);
+    const r = udivmod(u128, @as(u128, @bitCast(an)), @as(u128, @bitCast(bn)), null);
     const s = s_a ^ s_b;
-    return (@bitCast(i128, r) ^ s) -% s;
+    return (@as(i128, @bitCast(r)) ^ s) -% s;
 }
 
 test {

@@ -14,8 +14,8 @@ test "divti3" {
     try test__divti3(-2, 1, -2);
     try test__divti3(-2, -1, 2);
 
-    try test__divti3(@bitCast(i128, @as(u128, 0x8 << 124)), 1, @bitCast(i128, @as(u128, 0x8 << 124)));
-    try test__divti3(@bitCast(i128, @as(u128, 0x8 << 124)), -1, @bitCast(i128, @as(u128, 0x8 << 124)));
-    try test__divti3(@bitCast(i128, @as(u128, 0x8 << 124)), -2, @bitCast(i128, @as(u128, 0x4 << 124)));
-    try test__divti3(@bitCast(i128, @as(u128, 0x8 << 124)), 2, @bitCast(i128, @as(u128, 0xc << 124)));
+    try test__divti3(@as(i128, @bitCast(@as(u128, 0x8 << 124))), 1, @as(i128, @bitCast(@as(u128, 0x8 << 124))));
+    try test__divti3(@as(i128, @bitCast(@as(u128, 0x8 << 124))), -1, @as(i128, @bitCast(@as(u128, 0x8 << 124))));
+    try test__divti3(@as(i128, @bitCast(@as(u128, 0x8 << 124))), -2, @as(i128, @bitCast(@as(u128, 0x4 << 124))));
+    try test__divti3(@as(i128, @bitCast(@as(u128, 0x8 << 124))), 2, @as(i128, @bitCast(@as(u128, 0xc << 124))));
 }

@@ -29,53 +29,53 @@ pub fn __divxf3(a: f80, b: f80) callconv(.C) f80 {
     const significandMask = (@as(Z, 1) << significandBits) - 1;
 
     const absMask = signBit - 1;
-    const qnanRep = @bitCast(Z, std.math.nan(T)) | quietBit;
-    const infRep = @bitCast(Z, std.math.inf(T));
+    const qnanRep = @as(Z, @bitCast(std.math.nan(T))) | quietBit;
+    const infRep = @as(Z, @bitCast(std.math.inf(T)));
 
-    const aExponent = @truncate(u32, (@bitCast(Z, a) >> significandBits) & maxExponent);
-    const bExponent = @truncate(u32, (@bitCast(Z, b) >> significandBits) & maxExponent);
-    const quotientSign: Z = (@bitCast(Z, a) ^ @bitCast(Z, b)) & signBit;
+    const aExponent = @as(u32, @truncate((@as(Z, @bitCast(a)) >> significandBits) & maxExponent));
+    const bExponent = @as(u32, @truncate((@as(Z, @bitCast(b)) >> significandBits) & maxExponent));
+    const quotientSign: Z = (@as(Z, @bitCast(a)) ^ @as(Z, @bitCast(b))) & signBit;
 
-    var aSignificand: Z = @bitCast(Z, a) & significandMask;
-    var bSignificand: Z = @bitCast(Z, b) & significandMask;
+    var aSignificand: Z = @as(Z, @bitCast(a)) & significandMask;
+    var bSignificand: Z = @as(Z, @bitCast(b)) & significandMask;
     var scale: i32 = 0;
 
     // Detect if a or b is zero, denormal, infinity, or NaN.
     if (aExponent -% 1 >= maxExponent - 1 or bExponent -% 1 >= maxExponent - 1) {
-        const aAbs: Z = @bitCast(Z, a) & absMask;
-        const bAbs: Z = @bitCast(Z, b) & absMask;
+        const aAbs: Z = @as(Z, @bitCast(a)) & absMask;
+        const bAbs: Z = @as(Z, @bitCast(b)) & absMask;
 
         // NaN / anything = qNaN
-        if (aAbs > infRep) return @bitCast(T, @bitCast(Z, a) | quietBit);
+        if (aAbs > infRep) return @as(T, @bitCast(@as(Z, @bitCast(a)) | quietBit));
         // anything / NaN = qNaN
-        if (bAbs > infRep) return @bitCast(T, @bitCast(Z, b) | quietBit);
+        if (bAbs > infRep) return @as(T, @bitCast(@as(Z, @bitCast(b)) | quietBit));
 
         if (aAbs == infRep) {
             // infinity / infinity = NaN
             if (bAbs == infRep) {
-                return @bitCast(T, qnanRep);
+                return @as(T, @bitCast(qnanRep));
             }
             // infinity / anything else = +/- infinity
             else {
-                return @bitCast(T, aAbs | quotientSign);
+                return @as(T, @bitCast(aAbs | quotientSign));
             }
         }
 
         // anything else / infinity = +/- 0
-        if (bAbs == infRep) return @bitCast(T, quotientSign);
+        if (bAbs == infRep) return @as(T, @bitCast(quotientSign));
 
         if (aAbs == 0) {
             // zero / zero = NaN
             if (bAbs == 0) {
-                return @bitCast(T, qnanRep);
+                return @as(T, @bitCast(qnanRep));
             }
             // zero / anything else = +/- zero
             else {
-                return @bitCast(T, quotientSign);
+                return @as(T, @bitCast(quotientSign));
             }
         }
         // anything else / zero = +/- infinity
-        if (bAbs == 0) return @bitCast(T, infRep | quotientSign);
+        if (bAbs == 0) return @as(T, @bitCast(infRep | quotientSign));
 
         // one or both of a or b is denormal, the other (if applicable) is a
         // normal number.  Renormalize one or both of a and b, and set scale to
@@ -83,13 +83,13 @@ pub fn __divxf3(a: f80, b: f80) callconv(.C) f80 {
         if (aAbs < integerBit) scale +%= normalize(T, &aSignificand);
         if (bAbs < integerBit) scale -%= normalize(T, &bSignificand);
     }
-    var quotientExponent: i32 = @bitCast(i32, aExponent -% bExponent) +% scale;
+    var quotientExponent: i32 = @as(i32, @bitCast(aExponent -% bExponent)) +% scale;
 
     // Align the significand of b as a Q63 fixed-point number in the range
     // [1, 2.0) and get a Q64 approximate reciprocal using a small minimax
     // polynomial approximation: reciprocal = 3/4 + 1/sqrt(2) - b/2.  This
     // is accurate to about 3.5 binary digits.
-    const q63b = @intCast(u64, bSignificand);
+    const q63b = @as(u64, @intCast(bSignificand));
     var recip64 = @as(u64, 0x7504f333F9DE6484) -% q63b;
     // 0x7504f333F9DE6484 / 2^64 + 1 = 3/4 + 1/sqrt(2)
 
@@ -100,16 +100,16 @@ pub fn __divxf3(a: f80, b: f80) callconv(.C) f80 {
     // This doubles the number of correct binary digits in the approximation
     // with each iteration.
     var correction64: u64 = undefined;
-    correction64 = @truncate(u64, ~(@as(u128, recip64) *% q63b >> 64) +% 1);
-    recip64 = @truncate(u64, @as(u128, recip64) *% correction64 >> 63);
-    correction64 = @truncate(u64, ~(@as(u128, recip64) *% q63b >> 64) +% 1);
-    recip64 = @truncate(u64, @as(u128, recip64) *% correction64 >> 63);
-    correction64 = @truncate(u64, ~(@as(u128, recip64) *% q63b >> 64) +% 1);
-    recip64 = @truncate(u64, @as(u128, recip64) *% correction64 >> 63);
-    correction64 = @truncate(u64, ~(@as(u128, recip64) *% q63b >> 64) +% 1);
-    recip64 = @truncate(u64, @as(u128, recip64) *% correction64 >> 63);
-    correction64 = @truncate(u64, ~(@as(u128, recip64) *% q63b >> 64) +% 1);
-    recip64 = @truncate(u64, @as(u128, recip64) *% correction64 >> 63);
+    correction64 = @as(u64, @truncate(~(@as(u128, recip64) *% q63b >> 64) +% 1));
+    recip64 = @as(u64, @truncate(@as(u128, recip64) *% correction64 >> 63));
+    correction64 = @as(u64, @truncate(~(@as(u128, recip64) *% q63b >> 64) +% 1));
+    recip64 = @as(u64, @truncate(@as(u128, recip64) *% correction64 >> 63));
+    correction64 = @as(u64, @truncate(~(@as(u128, recip64) *% q63b >> 64) +% 1));
+    recip64 = @as(u64, @truncate(@as(u128, recip64) *% correction64 >> 63));
+    correction64 = @as(u64, @truncate(~(@as(u128, recip64) *% q63b >> 64) +% 1));
+    recip64 = @as(u64, @truncate(@as(u128, recip64) *% correction64 >> 63));
+    correction64 = @as(u64, @truncate(~(@as(u128, recip64) *% q63b >> 64) +% 1));
+    recip64 = @as(u64, @truncate(@as(u128, recip64) *% correction64 >> 63));
 
     // The reciprocal may have overflowed to zero if the upper half of b is
     // exactly 1.0.  This would sabatoge the full-width final stage of the
@@ -128,8 +128,8 @@ pub fn __divxf3(a: f80, b: f80) callconv(.C) f80 {
 
     correction = -%correction;
 
-    const cHi = @truncate(u64, correction >> 64);
-    const cLo = @truncate(u64, correction);
+    const cHi = @as(u64, @truncate(correction >> 64));
+    const cLo = @as(u64, @truncate(correction));
 
     var r64cH: u128 = undefined;
     var r64cL: u128 = undefined;
@@ -164,8 +164,8 @@ pub fn __divxf3(a: f80, b: f80) callconv(.C) f80 {
     // exponent accordingly.
     var quotient: u64 = if (quotient128 < (integerBit << 1)) b: {
         quotientExponent -= 1;
-        break :b @intCast(u64, quotient128);
-    } else @intCast(u64, quotient128 >> 1);
+        break :b @as(u64, @intCast(quotient128));
+    } else @as(u64, @intCast(quotient128 >> 1));
 
     // We are going to compute a residual of the form
     //
@@ -182,26 +182,26 @@ pub fn __divxf3(a: f80, b: f80) callconv(.C) f80 {
     const writtenExponent = quotientExponent + exponentBias;
     if (writtenExponent >= maxExponent) {
         // If we have overflowed the exponent, return infinity.
-        return @bitCast(T, infRep | quotientSign);
+        return @as(T, @bitCast(infRep | quotientSign));
     } else if (writtenExponent < 1) {
         if (writtenExponent == 0) {
             // Check whether the rounded result is normal.
             if (residual > (bSignificand >> 1)) { // round
                 if (quotient == (integerBit - 1)) // If the rounded result is normal, return it
-                    return @bitCast(T, @bitCast(Z, std.math.floatMin(T)) | quotientSign);
+                    return @as(T, @bitCast(@as(Z, @bitCast(std.math.floatMin(T))) | quotientSign));
             }
         }
         // Flush denormals to zero.  In the future, it would be nice to add
         // code to round them correctly.
-        return @bitCast(T, quotientSign);
+        return @as(T, @bitCast(quotientSign));
     } else {
         const round = @intFromBool(residual > (bSignificand >> 1));
         // Insert the exponent
-        var absResult = quotient | (@intCast(Z, writtenExponent) << significandBits);
+        var absResult = quotient | (@as(Z, @intCast(writtenExponent)) << significandBits);
         // Round
         absResult +%= round;
         // Insert the sign and return
-        return @bitCast(T, absResult | quotientSign | integerBit);
+        return @as(T, @bitCast(absResult | quotientSign | integerBit));
     }
 }