diff --git a/lib/compiler_rt/addf3.zig b/lib/compiler_rt/addf3.zig
index 94ec8eec76..8616e53e2b 100644
--- a/lib/compiler_rt/addf3.zig
+++ b/lib/compiler_rt/addf3.zig
@@ -9,7 +9,6 @@ const normalize = common.normalize;
 pub inline fn addf3(comptime T: type, a: T, b: T) T {
     const bits = @typeInfo(T).Float.bits;
     const Z = std.meta.Int(.unsigned, bits);
-    const S = std.meta.Int(.unsigned, bits - @clz(@as(Z, bits) - 1));
 
     const typeWidth = bits;
     const significandBits = math.floatMantissaBits(T);
@@ -26,12 +25,12 @@ pub inline fn addf3(comptime T: type, a: T, b: T) T {
     const absMask = signBit - 1;
     const qnanRep = @as(Z, @bitCast(math.nan(T))) | quietBit;
 
-    var aRep = @as(Z, @bitCast(a));
-    var bRep = @as(Z, @bitCast(b));
+    var aRep: Z = @bitCast(a);
+    var bRep: Z = @bitCast(b);
     const aAbs = aRep & absMask;
     const bAbs = bRep & absMask;
 
-    const infRep = @as(Z, @bitCast(math.inf(T)));
+    const infRep: 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
@@ -104,8 +103,8 @@ pub inline fn addf3(comptime T: type, a: T, b: T) T {
     const @"align": u32 = @intCast(aExponent - bExponent);
     if (@"align" != 0) {
         if (@"align" < typeWidth) {
-            const sticky = if (bSignificand << @as(S, @intCast(typeWidth - @"align")) != 0) @as(Z, 1) else 0;
-            bSignificand = (bSignificand >> @as(S, @truncate(@"align"))) | sticky;
+            const sticky = if (bSignificand << @intCast(typeWidth - @"align") != 0) @as(Z, 1) else 0;
+            bSignificand = (bSignificand >> @truncate(@"align")) | sticky;
         } else {
             bSignificand = 1; // sticky; b is known to be non-zero.
         }
@@ -119,7 +118,7 @@ pub inline fn addf3(comptime T: type, a: T, b: T) T {
         // and adjust the exponent:
         if (aSignificand < integerBit << 3) {
             const shift = @as(i32, @intCast(@clz(aSignificand))) - @as(i32, @intCast(@clz(integerBit << 3)));
-            aSignificand <<= @as(S, @intCast(shift));
+            aSignificand <<= @intCast(shift);
             aExponent -= shift;
         }
     } else { // addition
@@ -140,7 +139,7 @@ pub inline fn addf3(comptime T: type, a: T, b: T) T {
     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 >>= @as(S, @intCast(4 - aExponent));
+        aSignificand >>= @intCast(4 - aExponent);
         return @bitCast(resultSign | aSignificand);
     }
 
diff --git a/lib/compiler_rt/ceil.zig b/lib/compiler_rt/ceil.zig
index d275f16076..baa9edbee4 100644
--- a/lib/compiler_rt/ceil.zig
+++ b/lib/compiler_rt/ceil.zig
@@ -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) >> @as(u5, @intCast(e));
+        m = @as(u32, 0x007FFFFF) >> @intCast(e);
         if (u & m == 0) {
             return x;
         }
diff --git a/lib/compiler_rt/clear_cache.zig b/lib/compiler_rt/clear_cache.zig
index f2f4fc9bc2..3f9ecc0132 100644
--- a/lib/compiler_rt/clear_cache.zig
+++ b/lib/compiler_rt/clear_cache.zig
@@ -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) << @as(u6, @intCast((ctr_el0 >> 16) & 15));
+            const dcache_line_size = @as(usize, 4) << @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) << @as(u6, @intCast((ctr_el0 >> 0) & 15));
+            const icache_line_size = @as(usize, 4) << @intCast((ctr_el0 >> 0) & 15);
             addr = start & ~(icache_line_size - 1);
             while (addr < end) : (addr += icache_line_size) {
                 asm volatile ("ic ivau, %[addr]"
diff --git a/lib/compiler_rt/common.zig b/lib/compiler_rt/common.zig
index 752a4a46df..6ffafe464c 100644
--- a/lib/compiler_rt/common.zig
+++ b/lib/compiler_rt/common.zig
@@ -102,14 +102,14 @@ 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.* = @as(u16, @intCast(product >> 16));
-            lo.* = @as(u16, @truncate(product));
+            hi.* = @intCast(product >> 16);
+            lo.* = @truncate(product);
         },
         u32 => {
             // 32x32 --> 64 bit multiply
             const product = @as(u64, a) * @as(u64, b);
-            hi.* = @as(u32, @truncate(product >> 32));
-            lo.* = @as(u32, @truncate(product));
+            hi.* = @truncate(product >> 32);
+            lo.* = @truncate(product);
         },
         u64 => {
             const S = struct {
@@ -136,9 +136,9 @@ pub fn wideMultiply(comptime Z: type, a: Z, b: Z, hi: *Z, lo: *Z) void {
             hi.* = S.hiWord(plohi) +% S.hiWord(philo) +% S.hiWord(r1) +% phihi;
         },
         u128 => {
-            const Word_LoMask = @as(u64, 0x00000000ffffffff);
-            const Word_HiMask = @as(u64, 0xffffffff00000000);
-            const Word_FullMask = @as(u64, 0xffffffffffffffff);
+            const Word_LoMask: u64 = 0x00000000ffffffff;
+            const Word_HiMask: u64 = 0xffffffff00000000;
+            const Word_FullMask: u64 = 0xffffffffffffffff;
             const S = struct {
                 fn Word_1(x: u128) u64 {
                     return @as(u32, @truncate(x >> 96));
@@ -229,7 +229,7 @@ pub inline fn fneg(a: anytype) @TypeOf(a) {
     } });
     const sign_bit_mask = @as(U, 1) << (bits - 1);
     const negated = @as(U, @bitCast(a)) ^ sign_bit_mask;
-    return @as(F, @bitCast(negated));
+    return @bitCast(negated);
 }
 
 /// Allows to access underlying bits as two equally sized lower and higher
diff --git a/lib/compiler_rt/cos.zig b/lib/compiler_rt/cos.zig
index 5561097452..d299e682d7 100644
--- a/lib/compiler_rt/cos.zig
+++ b/lib/compiler_rt/cos.zig
@@ -25,7 +25,7 @@ comptime {
 
 pub fn __cosh(a: f16) callconv(.C) f16 {
     // TODO: more efficient implementation
-    return @as(f16, @floatCast(cosf(a)));
+    return @floatCast(cosf(a));
 }
 
 pub fn cosf(x: f32) callconv(.C) f32 {
diff --git a/lib/compiler_rt/count0bits.zig b/lib/compiler_rt/count0bits.zig
index 3ef78f26c2..478ad0eb57 100644
--- a/lib/compiler_rt/count0bits.zig
+++ b/lib/compiler_rt/count0bits.zig
@@ -203,12 +203,7 @@ pub fn __ctzti2(a: i128) callconv(.C) i32 {
 }
 
 inline fn ffsXi2(comptime T: type, a: T) i32 {
-    var x = switch (@bitSizeOf(T)) {
-        32 => @as(u32, @bitCast(a)),
-        64 => @as(u64, @bitCast(a)),
-        128 => @as(u128, @bitCast(a)),
-        else => unreachable,
-    };
+    var x: std.meta.Int(.unsigned, @typeInfo(T).Int.bits) = @bitCast(a);
     var n: T = 1;
     // adapted from Number of trailing zeroes (see ctzXi2)
     var mask: @TypeOf(x) = std.math.maxInt(@TypeOf(x));
diff --git a/lib/compiler_rt/divti3.zig b/lib/compiler_rt/divti3.zig
index 43bb951ab9..1efc09ce3c 100644
--- a/lib/compiler_rt/divti3.zig
+++ b/lib/compiler_rt/divti3.zig
@@ -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 @as(v128, @bitCast(div(@as(i128, @bitCast(a)), @as(i128, @bitCast(b)))));
+    return @bitCast(div(@bitCast(a), @bitCast(b)));
 }
 
 inline fn div(a: i128, b: i128) i128 {
@@ -31,7 +31,7 @@ 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, @as(u128, @bitCast(an)), @as(u128, @bitCast(bn)), null);
+    const r = udivmod(u128, @bitCast(an), @bitCast(bn), null);
     const s = s_a ^ s_b;
     return (@as(i128, @bitCast(r)) ^ s) -% s;
 }
diff --git a/lib/compiler_rt/divxf3.zig b/lib/compiler_rt/divxf3.zig
index d04575576b..baa39cd61c 100644
--- a/lib/compiler_rt/divxf3.zig
+++ b/lib/compiler_rt/divxf3.zig
@@ -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 @as(u64, @intCast(quotient128));
-    } else @as(u64, @intCast(quotient128 >> 1));
+        break :b @intCast(quotient128);
+    } else @intCast(quotient128 >> 1);
 
     // We are going to compute a residual of the form
     //
@@ -182,18 +182,18 @@ 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 @as(T, @bitCast(infRep | quotientSign));
+        return @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 @as(T, @bitCast(@as(Z, @bitCast(std.math.floatMin(T))) | quotientSign));
+                    return @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 @as(T, @bitCast(quotientSign));
+        return @bitCast(quotientSign);
     } else {
         const round = @intFromBool(residual > (bSignificand >> 1));
         // Insert the exponent
@@ -201,7 +201,7 @@ pub fn __divxf3(a: f80, b: f80) callconv(.C) f80 {
         // Round
         absResult +%= round;
         // Insert the sign and return
-        return @as(T, @bitCast(absResult | quotientSign | integerBit));
+        return @bitCast(absResult | quotientSign | integerBit);
     }
 }
 
diff --git a/lib/compiler_rt/emutls.zig b/lib/compiler_rt/emutls.zig
index 0283e852a2..66d944bc21 100644
--- a/lib/compiler_rt/emutls.zig
+++ b/lib/compiler_rt/emutls.zig
@@ -52,19 +52,19 @@ const simple_allocator = struct {
             abort();
         }
 
-        return @as([*]u8, @ptrCast(aligned_ptr));
+        return @ptrCast(aligned_ptr);
     }
 
     /// Resize a slice.
     pub fn reallocSlice(comptime T: type, slice: []T, len: usize) []T {
-        var c_ptr: *anyopaque = @as(*anyopaque, @ptrCast(slice.ptr));
+        var c_ptr: *anyopaque = @ptrCast(slice.ptr);
         var new_array: [*]T = @ptrCast(@alignCast(std.c.realloc(c_ptr, @sizeOf(T) * len) orelse abort()));
         return new_array[0..len];
     }
 
     /// Free a memory chunk allocated with simple_allocator.
     pub fn free(ptr: anytype) void {
-        std.c.free(@as(*anyopaque, @ptrCast(ptr)));
+        std.c.free(@ptrCast(ptr));
     }
 };
 
@@ -138,7 +138,7 @@ const ObjectArray = struct {
                 @memset(data[0..size], 0);
             }
 
-            self.slots[index] = @as(*anyopaque, @ptrCast(data));
+            self.slots[index] = @ptrCast(data);
         }
 
         return self.slots[index].?;
@@ -178,7 +178,7 @@ const current_thread_storage = struct {
 
     /// Set casted thread specific value.
     fn setspecific(new: ?*ObjectArray) void {
-        if (std.c.pthread_setspecific(current_thread_storage.key, @as(*anyopaque, @ptrCast(new))) != 0) {
+        if (std.c.pthread_setspecific(current_thread_storage.key, @ptrCast(new)) != 0) {
             abort();
         }
     }
@@ -278,7 +278,7 @@ const emutls_control = extern struct {
             .size = @sizeOf(T),
             .alignment = @alignOf(T),
             .object = .{ .index = 0 },
-            .default_value = @as(?*const anyopaque, @ptrCast(default_value)),
+            .default_value = @ptrCast(default_value),
         };
     }
 
diff --git a/lib/compiler_rt/exp.zig b/lib/compiler_rt/exp.zig
index ee331222a8..65a6adb440 100644
--- a/lib/compiler_rt/exp.zig
+++ b/lib/compiler_rt/exp.zig
@@ -27,7 +27,7 @@ comptime {
 
 pub fn __exph(a: f16) callconv(.C) f16 {
     // TODO: more efficient implementation
-    return @as(f16, @floatCast(expf(a)));
+    return @floatCast(expf(a));
 }
 
 pub fn expf(x_: f32) callconv(.C) f32 {
@@ -74,7 +74,7 @@ pub fn expf(x_: f32) callconv(.C) f32 {
     if (hx > 0x3EB17218) {
         // |x| > 1.5 * ln2
         if (hx > 0x3F851592) {
-            k = @intFromFloat(invln2 * x + half[@as(usize, @intCast(sign))]);
+            k = @intFromFloat(invln2 * x + half[@intCast(sign)]);
         } else {
             k = 1 - sign - sign;
         }
@@ -157,7 +157,7 @@ pub fn exp(x_: f64) callconv(.C) f64 {
     if (hx > 0x3FD62E42) {
         // |x| >= 1.5 * ln2
         if (hx > 0x3FF0A2B2) {
-            k = @intFromFloat(invln2 * x + half[@as(usize, @intCast(sign))]);
+            k = @intFromFloat(invln2 * x + half[@intCast(sign)]);
         } else {
             k = 1 - sign - sign;
         }
diff --git a/lib/compiler_rt/exp2.zig b/lib/compiler_rt/exp2.zig
index d1d62b2a98..84bbe19d73 100644
--- a/lib/compiler_rt/exp2.zig
+++ b/lib/compiler_rt/exp2.zig
@@ -27,7 +27,7 @@ comptime {
 
 pub fn __exp2h(x: f16) callconv(.C) f16 {
     // TODO: more efficient implementation
-    return @as(f16, @floatCast(exp2f(x)));
+    return @floatCast(exp2f(x));
 }
 
 pub fn exp2f(x: f32) callconv(.C) f32 {
@@ -81,7 +81,7 @@ pub fn exp2f(x: f32) callconv(.C) f32 {
     uf -= redux;
 
     const z: f64 = x - uf;
-    var r: f64 = exp2ft[@as(usize, @intCast(i_0))];
+    var r: f64 = exp2ft[@intCast(i_0)];
     const t: f64 = r * z;
     r = r + t * (P1 + z * P2) + t * (z * z) * (P3 + z * P4);
     return @floatCast(r * uk);
@@ -149,8 +149,8 @@ pub fn exp2(x: f64) callconv(.C) f64 {
 
     // r = exp2(y) = exp2t[i_0] * p(z - eps[i])
     var z: f64 = x - uf;
-    const t: f64 = exp2dt[@as(usize, @intCast(2 * i_0))];
-    z -= exp2dt[@as(usize, @intCast(2 * i_0 + 1))];
+    const t: f64 = exp2dt[@intCast(2 * i_0)];
+    z -= exp2dt[@intCast(2 * i_0 + 1)];
     const r: f64 = t + t * z * (P1 + z * (P2 + z * (P3 + z * (P4 + z * P5))));
 
     return math.scalbn(r, ik);
diff --git a/lib/compiler_rt/extendf.zig b/lib/compiler_rt/extendf.zig
index e56e261d89..b4e3f37f38 100644
--- a/lib/compiler_rt/extendf.zig
+++ b/lib/compiler_rt/extendf.zig
@@ -9,7 +9,6 @@ pub inline fn extendf(
     const dst_rep_t = std.meta.Int(.unsigned, @typeInfo(dst_t).Float.bits);
     const srcSigBits = std.math.floatMantissaBits(src_t);
     const dstSigBits = std.math.floatMantissaBits(dst_t);
-    const DstShift = std.math.Log2Int(dst_rep_t);
 
     // Various constants whose values follow from the type parameters.
     // Any reasonable optimizer will fold and propagate all of these.
@@ -56,9 +55,8 @@ pub inline fn extendf(
         // a is denormal.
         // renormalize the significand and clear the leading bit, then insert
         // the correct adjusted exponent in the destination type.
-        const scale: u32 = @clz(aAbs) -
-            @clz(@as(src_rep_t, srcMinNormal));
-        absResult = @as(dst_rep_t, aAbs) << @as(DstShift, @intCast(dstSigBits - srcSigBits + scale));
+        const scale: u32 = @clz(aAbs) - @clz(@as(src_rep_t, srcMinNormal));
+        absResult = @as(dst_rep_t, aAbs) << @intCast(dstSigBits - srcSigBits + scale);
         absResult ^= dstMinNormal;
         const resultExponent: u32 = dstExpBias - srcExpBias - scale + 1;
         absResult |= @as(dst_rep_t, @intCast(resultExponent)) << dstSigBits;
@@ -69,7 +67,7 @@ pub inline fn extendf(
 
     // Apply the signbit to (dst_t)abs(a).
     const result: dst_rep_t align(@alignOf(dst_t)) = absResult | @as(dst_rep_t, sign) << (dstBits - srcBits);
-    return @as(dst_t, @bitCast(result));
+    return @bitCast(result);
 }
 
 pub inline fn extend_f80(comptime src_t: type, a: std.meta.Int(.unsigned, @typeInfo(src_t).Float.bits)) f80 {
@@ -92,8 +90,6 @@ pub inline fn extend_f80(comptime src_t: type, a: std.meta.Int(.unsigned, @typeI
     const src_qnan = 1 << (src_sig_bits - 1);
     const src_nan_code = src_qnan - 1;
 
-    const SrcShift = std.math.Log2Int(src_rep_t);
-
     var dst: std.math.F80 = undefined;
 
     // Break a into a sign and representation of the absolute value
@@ -121,12 +117,11 @@ pub inline fn extend_f80(comptime src_t: type, a: std.meta.Int(.unsigned, @typeI
         // a is denormal.
         // renormalize the significand and clear the leading bit, then insert
         // the correct adjusted exponent in the destination type.
-        const scale: u16 = @clz(a_abs) -
-            @clz(@as(src_rep_t, src_min_normal));
+        const scale: u16 = @clz(a_abs) - @clz(@as(src_rep_t, src_min_normal));
 
-        dst.fraction = @as(u64, a_abs) << @as(u6, @intCast(dst_sig_bits - src_sig_bits + scale));
+        dst.fraction = @as(u64, a_abs) << @intCast(dst_sig_bits - src_sig_bits + scale);
         dst.fraction |= dst_int_bit; // bit 64 is always set for normal numbers
-        dst.exp = @truncate(a_abs >> @as(SrcShift, @intCast(src_sig_bits - scale)));
+        dst.exp = @truncate(a_abs >> @intCast(src_sig_bits - scale));
         dst.exp ^= 1;
         dst.exp |= dst_exp_bias - src_exp_bias - scale + 1;
     } else {
diff --git a/lib/compiler_rt/extendxftf2.zig b/lib/compiler_rt/extendxftf2.zig
index 3ddceb6c63..a47f4479f6 100644
--- a/lib/compiler_rt/extendxftf2.zig
+++ b/lib/compiler_rt/extendxftf2.zig
@@ -39,12 +39,12 @@ fn __extendxftf2(a: f80) callconv(.C) f128 {
         // renormalize the significand and clear the leading bit and integer part,
         // then insert the correct adjusted exponent in the destination type.
         const scale: u32 = @clz(a_rep.fraction);
-        abs_result = @as(u128, a_rep.fraction) << @as(u7, @intCast(dst_sig_bits - src_sig_bits + scale + 1));
+        abs_result = @as(u128, a_rep.fraction) << @intCast(dst_sig_bits - src_sig_bits + scale + 1);
         abs_result ^= dst_min_normal;
         abs_result |= @as(u128, scale + 1) << dst_sig_bits;
     }
 
     // Apply the signbit to (dst_t)abs(a).
     const result: u128 align(@alignOf(f128)) = abs_result | @as(u128, sign) << (dst_bits - 16);
-    return @as(f128, @bitCast(result));
+    return @bitCast(result);
 }
diff --git a/lib/compiler_rt/fabs.zig b/lib/compiler_rt/fabs.zig
index a58cb1fb08..e107291543 100644
--- a/lib/compiler_rt/fabs.zig
+++ b/lib/compiler_rt/fabs.zig
@@ -51,7 +51,7 @@ pub fn fabsl(x: c_longdouble) callconv(.C) c_longdouble {
 inline fn generic_fabs(x: anytype) @TypeOf(x) {
     const T = @TypeOf(x);
     const TBits = std.meta.Int(.unsigned, @typeInfo(T).Float.bits);
-    const float_bits = @as(TBits, @bitCast(x));
+    const float_bits: TBits = @bitCast(x);
     const remove_sign = ~@as(TBits, 0) >> 1;
-    return @as(T, @bitCast(float_bits & remove_sign));
+    return @bitCast(float_bits & remove_sign);
 }
diff --git a/lib/compiler_rt/fixdfti.zig b/lib/compiler_rt/fixdfti.zig
index 8ee7ce40c5..7dced515f1 100644
--- a/lib/compiler_rt/fixdfti.zig
+++ b/lib/compiler_rt/fixdfti.zig
@@ -19,5 +19,5 @@ pub fn __fixdfti(a: f64) callconv(.C) i128 {
 const v2u64 = @Vector(2, u64);
 
 fn __fixdfti_windows_x86_64(a: f64) callconv(.C) v2u64 {
-    return @as(v2u64, @bitCast(intFromFloat(i128, a)));
+    return @bitCast(intFromFloat(i128, a));
 }
diff --git a/lib/compiler_rt/fixhfti.zig b/lib/compiler_rt/fixhfti.zig
index 50fd26a9fa..bcc30ec763 100644
--- a/lib/compiler_rt/fixhfti.zig
+++ b/lib/compiler_rt/fixhfti.zig
@@ -19,5 +19,5 @@ pub fn __fixhfti(a: f16) callconv(.C) i128 {
 const v2u64 = @Vector(2, u64);
 
 fn __fixhfti_windows_x86_64(a: f16) callconv(.C) v2u64 {
-    return @as(v2u64, @bitCast(intFromFloat(i128, a)));
+    return @bitCast(intFromFloat(i128, a));
 }
diff --git a/lib/compiler_rt/fixsfti.zig b/lib/compiler_rt/fixsfti.zig
index 9110b3ca38..058d20f0b3 100644
--- a/lib/compiler_rt/fixsfti.zig
+++ b/lib/compiler_rt/fixsfti.zig
@@ -19,5 +19,5 @@ pub fn __fixsfti(a: f32) callconv(.C) i128 {
 const v2u64 = @Vector(2, u64);
 
 fn __fixsfti_windows_x86_64(a: f32) callconv(.C) v2u64 {
-    return @as(v2u64, @bitCast(intFromFloat(i128, a)));
+    return @bitCast(intFromFloat(i128, a));
 }
diff --git a/lib/compiler_rt/fixtfti.zig b/lib/compiler_rt/fixtfti.zig
index 6c7a8170f9..d38b092498 100644
--- a/lib/compiler_rt/fixtfti.zig
+++ b/lib/compiler_rt/fixtfti.zig
@@ -21,5 +21,5 @@ pub fn __fixtfti(a: f128) callconv(.C) i128 {
 const v2u64 = @Vector(2, u64);
 
 fn __fixtfti_windows_x86_64(a: f128) callconv(.C) v2u64 {
-    return @as(v2u64, @bitCast(intFromFloat(i128, a)));
+    return @bitCast(intFromFloat(i128, a));
 }
diff --git a/lib/compiler_rt/fixunsdfti.zig b/lib/compiler_rt/fixunsdfti.zig
index 31483d91f9..f4e1b84b87 100644
--- a/lib/compiler_rt/fixunsdfti.zig
+++ b/lib/compiler_rt/fixunsdfti.zig
@@ -19,5 +19,5 @@ pub fn __fixunsdfti(a: f64) callconv(.C) u128 {
 const v2u64 = @Vector(2, u64);
 
 fn __fixunsdfti_windows_x86_64(a: f64) callconv(.C) v2u64 {
-    return @as(v2u64, @bitCast(intFromFloat(u128, a)));
+    return @bitCast(intFromFloat(u128, a));
 }
diff --git a/lib/compiler_rt/fixunshfti.zig b/lib/compiler_rt/fixunshfti.zig
index 97a1541aa3..c35e6c7f94 100644
--- a/lib/compiler_rt/fixunshfti.zig
+++ b/lib/compiler_rt/fixunshfti.zig
@@ -19,5 +19,5 @@ pub fn __fixunshfti(a: f16) callconv(.C) u128 {
 const v2u64 = @Vector(2, u64);
 
 fn __fixunshfti_windows_x86_64(a: f16) callconv(.C) v2u64 {
-    return @as(v2u64, @bitCast(intFromFloat(u128, a)));
+    return @bitCast(intFromFloat(u128, a));
 }
diff --git a/lib/compiler_rt/fixunssfti.zig b/lib/compiler_rt/fixunssfti.zig
index d99b2bfd38..f65083413a 100644
--- a/lib/compiler_rt/fixunssfti.zig
+++ b/lib/compiler_rt/fixunssfti.zig
@@ -19,5 +19,5 @@ pub fn __fixunssfti(a: f32) callconv(.C) u128 {
 const v2u64 = @Vector(2, u64);
 
 fn __fixunssfti_windows_x86_64(a: f32) callconv(.C) v2u64 {
-    return @as(v2u64, @bitCast(intFromFloat(u128, a)));
+    return @bitCast(intFromFloat(u128, a));
 }
diff --git a/lib/compiler_rt/fixunstfti.zig b/lib/compiler_rt/fixunstfti.zig
index d796849b68..327f5209ce 100644
--- a/lib/compiler_rt/fixunstfti.zig
+++ b/lib/compiler_rt/fixunstfti.zig
@@ -21,5 +21,5 @@ pub fn __fixunstfti(a: f128) callconv(.C) u128 {
 const v2u64 = @Vector(2, u64);
 
 fn __fixunstfti_windows_x86_64(a: f128) callconv(.C) v2u64 {
-    return @as(v2u64, @bitCast(intFromFloat(u128, a)));
+    return @bitCast(intFromFloat(u128, a));
 }
diff --git a/lib/compiler_rt/fixunsxfti.zig b/lib/compiler_rt/fixunsxfti.zig
index 86216aa560..9b98522f51 100644
--- a/lib/compiler_rt/fixunsxfti.zig
+++ b/lib/compiler_rt/fixunsxfti.zig
@@ -19,5 +19,5 @@ pub fn __fixunsxfti(a: f80) callconv(.C) u128 {
 const v2u64 = @Vector(2, u64);
 
 fn __fixunsxfti_windows_x86_64(a: f80) callconv(.C) v2u64 {
-    return @as(v2u64, @bitCast(intFromFloat(u128, a)));
+    return @bitCast(intFromFloat(u128, a));
 }
diff --git a/lib/compiler_rt/fixxfti.zig b/lib/compiler_rt/fixxfti.zig
index f04c68d239..78cd10dfa5 100644
--- a/lib/compiler_rt/fixxfti.zig
+++ b/lib/compiler_rt/fixxfti.zig
@@ -19,5 +19,5 @@ pub fn __fixxfti(a: f80) callconv(.C) i128 {
 const v2u64 = @Vector(2, u64);
 
 fn __fixxfti_windows_x86_64(a: f80) callconv(.C) v2u64 {
-    return @as(v2u64, @bitCast(intFromFloat(i128, a)));
+    return @bitCast(intFromFloat(i128, a));
 }
diff --git a/lib/compiler_rt/float_from_int.zig b/lib/compiler_rt/float_from_int.zig
index c9ecba07f8..cb3fa67987 100644
--- a/lib/compiler_rt/float_from_int.zig
+++ b/lib/compiler_rt/float_from_int.zig
@@ -28,10 +28,10 @@ pub fn floatFromInt(comptime T: type, x: anytype) T {
         const shift_amt = fractional_bits - @as(math.Log2Int(uT), @intCast(exp));
 
         // Shift up result to line up with the significand - no rounding required
-        result = (@as(uT, @intCast(abs_val)) << shift_amt);
+        result = @as(uT, @intCast(abs_val)) << shift_amt;
         result ^= implicit_bit; // Remove implicit integer bit
     } else {
-        var shift_amt = @as(math.Log2Int(Z), @intCast(exp - fractional_bits));
+        var shift_amt: math.Log2Int(Z) = @intCast(exp - fractional_bits);
         const exact_tie: bool = @ctz(abs_val) == shift_amt - 1;
 
         // Shift down result and remove implicit integer bit
@@ -43,14 +43,14 @@ pub fn floatFromInt(comptime T: type, x: anytype) T {
 
     // Compute exponent
     if ((int_bits > max_exp) and (exp > max_exp)) // If exponent too large, overflow to infinity
-        return @as(T, @bitCast(sign_bit | @as(uT, @bitCast(inf))));
+        return @bitCast(sign_bit | @as(uT, @bitCast(inf)));
 
     result += (@as(uT, exp) + exp_bias) << math.floatMantissaBits(T);
 
     // If the result included a carry, we need to restore the explicit integer bit
     if (T == f80) result |= 1 << fractional_bits;
 
-    return @as(T, @bitCast(sign_bit | result));
+    return @bitCast(sign_bit | result);
 }
 
 test {
diff --git a/lib/compiler_rt/float_from_int_test.zig b/lib/compiler_rt/float_from_int_test.zig
index 867a8d5bd8..a06ba3a04e 100644
--- a/lib/compiler_rt/float_from_int_test.zig
+++ b/lib/compiler_rt/float_from_int_test.zig
@@ -43,7 +43,7 @@ test "floatsisf" {
     try test__floatsisf(1, 0x3f800000);
     try test__floatsisf(-1, 0xbf800000);
     try test__floatsisf(0x7FFFFFFF, 0x4f000000);
-    try test__floatsisf(@as(i32, @bitCast(@as(u32, @intCast(0x80000000)))), 0xcf000000);
+    try test__floatsisf(@bitCast(@as(u32, @intCast(0x80000000))), 0xcf000000);
 }
 
 test "floatunsisf" {
@@ -72,10 +72,10 @@ test "floatdisf" {
     try test__floatdisf(-2, -2.0);
     try test__floatdisf(0x7FFFFF8000000000, 0x1.FFFFFEp+62);
     try test__floatdisf(0x7FFFFF0000000000, 0x1.FFFFFCp+62);
-    try test__floatdisf(@as(i64, @bitCast(@as(u64, 0x8000008000000000))), -0x1.FFFFFEp+62);
-    try test__floatdisf(@as(i64, @bitCast(@as(u64, 0x8000010000000000))), -0x1.FFFFFCp+62);
-    try test__floatdisf(@as(i64, @bitCast(@as(u64, 0x8000000000000000))), -0x1.000000p+63);
-    try test__floatdisf(@as(i64, @bitCast(@as(u64, 0x8000000000000001))), -0x1.000000p+63);
+    try test__floatdisf(@bitCast(@as(u64, 0x8000008000000000)), -0x1.FFFFFEp+62);
+    try test__floatdisf(@bitCast(@as(u64, 0x8000010000000000)), -0x1.FFFFFCp+62);
+    try test__floatdisf(@bitCast(@as(u64, 0x8000000000000000)), -0x1.000000p+63);
+    try test__floatdisf(@bitCast(@as(u64, 0x8000000000000001)), -0x1.000000p+63);
     try test__floatdisf(0x0007FB72E8000000, 0x1.FEDCBAp+50);
     try test__floatdisf(0x0007FB72EA000000, 0x1.FEDCBAp+50);
     try test__floatdisf(0x0007FB72EB000000, 0x1.FEDCBAp+50);
@@ -228,7 +228,7 @@ test "floatuntisf" {
     try test__floatuntisf(make_uti(0x0000000000001FED, 0xCBE0000000000000), 0x1.FEDCBEp+76);
 
     // Test overflow to infinity
-    try test__floatuntisf(@as(u128, math.maxInt(u128)), @as(f32, @bitCast(math.inf(f32))));
+    try test__floatuntisf(math.maxInt(u128), @bitCast(math.inf(f32)));
 }
 
 fn test_one_floatsidf(a: i32, expected: u64) !void {
@@ -246,15 +246,15 @@ test "floatsidf" {
     try test_one_floatsidf(1, 0x3ff0000000000000);
     try test_one_floatsidf(-1, 0xbff0000000000000);
     try test_one_floatsidf(0x7FFFFFFF, 0x41dfffffffc00000);
-    try test_one_floatsidf(@as(i32, @bitCast(@as(u32, @intCast(0x80000000)))), 0xc1e0000000000000);
+    try test_one_floatsidf(@bitCast(@as(u32, @intCast(0x80000000))), 0xc1e0000000000000);
 }
 
 test "floatunsidf" {
     try test_one_floatunsidf(0, 0x0000000000000000);
     try test_one_floatunsidf(1, 0x3ff0000000000000);
     try test_one_floatunsidf(0x7FFFFFFF, 0x41dfffffffc00000);
-    try test_one_floatunsidf(@as(u32, @intCast(0x80000000)), 0x41e0000000000000);
-    try test_one_floatunsidf(@as(u32, @intCast(0xFFFFFFFF)), 0x41efffffffe00000);
+    try test_one_floatunsidf(@intCast(0x80000000), 0x41e0000000000000);
+    try test_one_floatunsidf(@intCast(0xFFFFFFFF), 0x41efffffffe00000);
 }
 
 fn test__floatdidf(a: i64, expected: f64) !void {
@@ -279,12 +279,12 @@ test "floatdidf" {
     try test__floatdidf(0x7FFFFFFFFFFFF800, 0x1.FFFFFFFFFFFFEp+62);
     try test__floatdidf(0x7FFFFF0000000000, 0x1.FFFFFCp+62);
     try test__floatdidf(0x7FFFFFFFFFFFF000, 0x1.FFFFFFFFFFFFCp+62);
-    try test__floatdidf(@as(i64, @bitCast(@as(u64, @intCast(0x8000008000000000)))), -0x1.FFFFFEp+62);
-    try test__floatdidf(@as(i64, @bitCast(@as(u64, @intCast(0x8000000000000800)))), -0x1.FFFFFFFFFFFFEp+62);
-    try test__floatdidf(@as(i64, @bitCast(@as(u64, @intCast(0x8000010000000000)))), -0x1.FFFFFCp+62);
-    try test__floatdidf(@as(i64, @bitCast(@as(u64, @intCast(0x8000000000001000)))), -0x1.FFFFFFFFFFFFCp+62);
-    try test__floatdidf(@as(i64, @bitCast(@as(u64, @intCast(0x8000000000000000)))), -0x1.000000p+63);
-    try test__floatdidf(@as(i64, @bitCast(@as(u64, @intCast(0x8000000000000001)))), -0x1.000000p+63); // 0x8000000000000001
+    try test__floatdidf(@bitCast(@as(u64, @intCast(0x8000008000000000))), -0x1.FFFFFEp+62);
+    try test__floatdidf(@bitCast(@as(u64, @intCast(0x8000000000000800))), -0x1.FFFFFFFFFFFFEp+62);
+    try test__floatdidf(@bitCast(@as(u64, @intCast(0x8000010000000000))), -0x1.FFFFFCp+62);
+    try test__floatdidf(@bitCast(@as(u64, @intCast(0x8000000000001000))), -0x1.FFFFFFFFFFFFCp+62);
+    try test__floatdidf(@bitCast(@as(u64, @intCast(0x8000000000000000))), -0x1.000000p+63);
+    try test__floatdidf(@bitCast(@as(u64, @intCast(0x8000000000000001))), -0x1.000000p+63); // 0x8000000000000001
     try test__floatdidf(0x0007FB72E8000000, 0x1.FEDCBAp+50);
     try test__floatdidf(0x0007FB72EA000000, 0x1.FEDCBA8p+50);
     try test__floatdidf(0x0007FB72EB000000, 0x1.FEDCBACp+50);
@@ -513,8 +513,8 @@ test "floatsitf" {
     try test__floatsitf(0x7FFFFFFF, 0x401dfffffffc00000000000000000000);
     try test__floatsitf(0x12345678, 0x401b2345678000000000000000000000);
     try test__floatsitf(-0x12345678, 0xc01b2345678000000000000000000000);
-    try test__floatsitf(@as(i32, @bitCast(@as(u32, @intCast(0xffffffff)))), 0xbfff0000000000000000000000000000);
-    try test__floatsitf(@as(i32, @bitCast(@as(u32, @intCast(0x80000000)))), 0xc01e0000000000000000000000000000);
+    try test__floatsitf(@bitCast(@as(u32, @intCast(0xffffffff))), 0xbfff0000000000000000000000000000);
+    try test__floatsitf(@bitCast(@as(u32, @intCast(0x80000000))), 0xc01e0000000000000000000000000000);
 }
 
 fn test__floatunsitf(a: u32, expected_hi: u64, expected_lo: u64) !void {
@@ -575,10 +575,10 @@ test "floatditf" {
     try test__floatditf(0x2, make_tf(0x4000000000000000, 0x0));
     try test__floatditf(0x1, make_tf(0x3fff000000000000, 0x0));
     try test__floatditf(0x0, make_tf(0x0, 0x0));
-    try test__floatditf(@as(i64, @bitCast(@as(u64, 0xffffffffffffffff))), make_tf(0xbfff000000000000, 0x0));
-    try test__floatditf(@as(i64, @bitCast(@as(u64, 0xfffffffffffffffe))), make_tf(0xc000000000000000, 0x0));
+    try test__floatditf(@bitCast(@as(u64, 0xffffffffffffffff)), make_tf(0xbfff000000000000, 0x0));
+    try test__floatditf(@bitCast(@as(u64, 0xfffffffffffffffe)), make_tf(0xc000000000000000, 0x0));
     try test__floatditf(-0x123456789abcdef1, make_tf(0xc03b23456789abcd, 0xef10000000000000));
-    try test__floatditf(@as(i64, @bitCast(@as(u64, 0x8000000000000000))), make_tf(0xc03e000000000000, 0x0));
+    try test__floatditf(@bitCast(@as(u64, 0x8000000000000000)), make_tf(0xc03e000000000000, 0x0));
 }
 
 test "floatunditf" {
@@ -773,7 +773,7 @@ fn make_ti(high: u64, low: u64) i128 {
     var result: u128 = high;
     result <<= 64;
     result |= low;
-    return @as(i128, @bitCast(result));
+    return @bitCast(result);
 }
 
 fn make_uti(high: u64, low: u64) u128 {
@@ -787,7 +787,7 @@ fn make_tf(high: u64, low: u64) f128 {
     var result: u128 = high;
     result <<= 64;
     result |= low;
-    return @as(f128, @bitCast(result));
+    return @bitCast(result);
 }
 
 test "conversion to f16" {
diff --git a/lib/compiler_rt/floor.zig b/lib/compiler_rt/floor.zig
index ac63837b75..5eb428e8a5 100644
--- a/lib/compiler_rt/floor.zig
+++ b/lib/compiler_rt/floor.zig
@@ -40,7 +40,7 @@ pub fn __floorh(x: f16) callconv(.C) f16 {
     }
 
     if (e >= 0) {
-        m = @as(u16, 1023) >> @as(u4, @intCast(e));
+        m = @as(u16, 1023) >> @intCast(e);
         if (u & m == 0) {
             return x;
         }
@@ -48,7 +48,7 @@ pub fn __floorh(x: f16) callconv(.C) f16 {
         if (u >> 15 != 0) {
             u += m;
         }
-        return @as(f16, @bitCast(u & ~m));
+        return @bitCast(u & ~m);
     } else {
         math.doNotOptimizeAway(x + 0x1.0p120);
         if (u >> 15 == 0) {
@@ -60,7 +60,7 @@ pub fn __floorh(x: f16) callconv(.C) f16 {
 }
 
 pub fn floorf(x: f32) callconv(.C) f32 {
-    var u = @as(u32, @bitCast(x));
+    var u: u32 = @bitCast(x);
     const e = @as(i32, @intCast((u >> 23) & 0xFF)) - 0x7F;
     var m: u32 = undefined;
 
@@ -74,7 +74,7 @@ pub fn floorf(x: f32) callconv(.C) f32 {
     }
 
     if (e >= 0) {
-        m = @as(u32, 0x007FFFFF) >> @as(u5, @intCast(e));
+        m = @as(u32, 0x007FFFFF) >> @intCast(e);
         if (u & m == 0) {
             return x;
         }
@@ -82,7 +82,7 @@ pub fn floorf(x: f32) callconv(.C) f32 {
         if (u >> 31 != 0) {
             u += m;
         }
-        return @as(f32, @bitCast(u & ~m));
+        return @bitCast(u & ~m);
     } else {
         math.doNotOptimizeAway(x + 0x1.0p120);
         if (u >> 31 == 0) {
@@ -96,7 +96,7 @@ pub fn floorf(x: f32) callconv(.C) f32 {
 pub fn floor(x: f64) callconv(.C) f64 {
     const f64_toint = 1.0 / math.floatEps(f64);
 
-    const u = @as(u64, @bitCast(x));
+    const u: u64 = @bitCast(x);
     const e = (u >> 52) & 0x7FF;
     var y: f64 = undefined;
 
@@ -126,7 +126,7 @@ pub fn floor(x: f64) callconv(.C) f64 {
 
 pub fn __floorx(x: f80) callconv(.C) f80 {
     // TODO: more efficient implementation
-    return @as(f80, @floatCast(floorq(x)));
+    return @floatCast(floorq(x));
 }
 
 pub fn floorq(x: f128) callconv(.C) f128 {
diff --git a/lib/compiler_rt/fma.zig b/lib/compiler_rt/fma.zig
index ed0e6649c6..5cda7e0a4d 100644
--- a/lib/compiler_rt/fma.zig
+++ b/lib/compiler_rt/fma.zig
@@ -28,7 +28,7 @@ comptime {
 
 pub fn __fmah(x: f16, y: f16, z: f16) callconv(.C) f16 {
     // TODO: more efficient implementation
-    return @as(f16, @floatCast(fmaf(x, y, z)));
+    return @floatCast(fmaf(x, y, z));
 }
 
 pub fn fmaf(x: f32, y: f32, z: f32) callconv(.C) f32 {
@@ -38,10 +38,10 @@ pub fn fmaf(x: f32, y: f32, z: f32) callconv(.C) f32 {
     const e = (u >> 52) & 0x7FF;
 
     if ((u & 0x1FFFFFFF) != 0x10000000 or e == 0x7FF or (xy_z - xy == z and xy_z - z == xy)) {
-        return @as(f32, @floatCast(xy_z));
+        return @floatCast(xy_z);
     } else {
         // TODO: Handle inexact case with double-rounding
-        return @as(f32, @floatCast(xy_z));
+        return @floatCast(xy_z);
     }
 }
 
@@ -95,7 +95,7 @@ pub fn fma(x: f64, y: f64, z: f64) callconv(.C) f64 {
 
 pub fn __fmax(a: f80, b: f80, c: f80) callconv(.C) f80 {
     // TODO: more efficient implementation
-    return @as(f80, @floatCast(fmaq(a, b, c)));
+    return @floatCast(fmaq(a, b, c));
 }
 
 /// Fused multiply-add: Compute x * y + z with a single rounding error.
@@ -201,12 +201,12 @@ fn dd_mul(a: f64, b: f64) dd {
 fn add_adjusted(a: f64, b: f64) f64 {
     var sum = dd_add(a, b);
     if (sum.lo != 0) {
-        var uhii = @as(u64, @bitCast(sum.hi));
+        var uhii: u64 = @bitCast(sum.hi);
         if (uhii & 1 == 0) {
             // hibits += copysign(1.0, sum.hi, sum.lo)
-            const uloi = @as(u64, @bitCast(sum.lo));
+            const uloi: u64 = @bitCast(sum.lo);
             uhii += 1 - ((uhii ^ uloi) >> 62);
-            sum.hi = @as(f64, @bitCast(uhii));
+            sum.hi = @bitCast(uhii);
         }
     }
     return sum.hi;
@@ -215,12 +215,12 @@ fn add_adjusted(a: f64, b: f64) f64 {
 fn add_and_denorm(a: f64, b: f64, scale: i32) f64 {
     var sum = dd_add(a, b);
     if (sum.lo != 0) {
-        var uhii = @as(u64, @bitCast(sum.hi));
+        var uhii: u64 = @bitCast(sum.hi);
         const bits_lost = -@as(i32, @intCast((uhii >> 52) & 0x7FF)) - scale + 1;
         if ((bits_lost != 1) == (uhii & 1 != 0)) {
-            const uloi = @as(u64, @bitCast(sum.lo));
+            const uloi: u64 = @bitCast(sum.lo);
             uhii += 1 - (((uhii ^ uloi) >> 62) & 2);
-            sum.hi = @as(f64, @bitCast(uhii));
+            sum.hi = @bitCast(uhii);
         }
     }
     return math.scalbn(sum.hi, scale);
@@ -257,12 +257,12 @@ fn dd_add128(a: f128, b: f128) dd128 {
 fn add_adjusted128(a: f128, b: f128) f128 {
     var sum = dd_add128(a, b);
     if (sum.lo != 0) {
-        var uhii = @as(u128, @bitCast(sum.hi));
+        var uhii: u128 = @bitCast(sum.hi);
         if (uhii & 1 == 0) {
             // hibits += copysign(1.0, sum.hi, sum.lo)
-            const uloi = @as(u128, @bitCast(sum.lo));
+            const uloi: u128 = @bitCast(sum.lo);
             uhii += 1 - ((uhii ^ uloi) >> 126);
-            sum.hi = @as(f128, @bitCast(uhii));
+            sum.hi = @bitCast(uhii);
         }
     }
     return sum.hi;
@@ -282,12 +282,12 @@ fn add_and_denorm128(a: f128, b: f128, scale: i32) f128 {
     // If we are losing only one bit to denormalization, however, we must
     // break the ties manually.
     if (sum.lo != 0) {
-        var uhii = @as(u128, @bitCast(sum.hi));
+        var uhii: u128 = @bitCast(sum.hi);
         const bits_lost = -@as(i32, @intCast((uhii >> 112) & 0x7FFF)) - scale + 1;
         if ((bits_lost != 1) == (uhii & 1 != 0)) {
-            const uloi = @as(u128, @bitCast(sum.lo));
+            const uloi: u128 = @bitCast(sum.lo);
             uhii += 1 - (((uhii ^ uloi) >> 126) & 2);
-            sum.hi = @as(f128, @bitCast(uhii));
+            sum.hi = @bitCast(uhii);
         }
     }
     return math.scalbn(sum.hi, scale);
diff --git a/lib/compiler_rt/fmod.zig b/lib/compiler_rt/fmod.zig
index b422e17166..1eb7707c60 100644
--- a/lib/compiler_rt/fmod.zig
+++ b/lib/compiler_rt/fmod.zig
@@ -82,8 +82,8 @@ pub fn __fmodx(a: f80, b: f80) callconv(.C) f80 {
 
     var highA: u64 = 0;
     var highB: u64 = 0;
-    var lowA: u64 = @as(u64, @truncate(aRep));
-    var lowB: u64 = @as(u64, @truncate(bRep));
+    var lowA: u64 = @truncate(aRep);
+    var lowB: u64 = @truncate(bRep);
 
     while (expA > expB) : (expA -= 1) {
         var high = highA -% highB;
@@ -125,7 +125,7 @@ pub fn __fmodx(a: f80, b: f80) callconv(.C) f80 {
     if (expA < -fractionalBits) {
         return @bitCast(signA);
     } else if (expA <= 0) {
-        return @bitCast((lowA >> @as(math.Log2Int(u64), @intCast(1 - expA))) | signA);
+        return @bitCast((lowA >> @intCast(1 - expA)) | signA);
     } else {
         return @bitCast(lowA | (@as(Z, @as(u16, @intCast(expA))) << significandBits) | signA);
     }
@@ -136,10 +136,10 @@ pub fn __fmodx(a: f80, b: f80) callconv(.C) f80 {
 pub fn fmodq(a: f128, b: f128) callconv(.C) f128 {
     var amod = a;
     var bmod = b;
-    const aPtr_u64 = @as([*]u64, @ptrCast(&amod));
-    const bPtr_u64 = @as([*]u64, @ptrCast(&bmod));
-    const aPtr_u16 = @as([*]u16, @ptrCast(&amod));
-    const bPtr_u16 = @as([*]u16, @ptrCast(&bmod));
+    const aPtr_u64: [*]u64 = @ptrCast(&amod);
+    const bPtr_u64: [*]u64 = @ptrCast(&bmod);
+    const aPtr_u16: [*]u16 = @ptrCast(&amod);
+    const bPtr_u16: [*]u16 = @ptrCast(&bmod);
 
     const exp_and_sign_index = comptime switch (builtin.target.cpu.arch.endian()) {
         .Little => 7,
@@ -173,8 +173,8 @@ pub fn fmodq(a: f128, b: f128) callconv(.C) f128 {
     }
 
     // Remove the sign from both
-    aPtr_u16[exp_and_sign_index] = @as(u16, @bitCast(@as(i16, @intCast(expA))));
-    bPtr_u16[exp_and_sign_index] = @as(u16, @bitCast(@as(i16, @intCast(expB))));
+    aPtr_u16[exp_and_sign_index] = @bitCast(@as(i16, @intCast(expA)));
+    bPtr_u16[exp_and_sign_index] = @bitCast(@as(i16, @intCast(expB)));
     if (amod <= bmod) {
         if (amod == bmod) {
             return 0 * a;
@@ -264,7 +264,6 @@ pub fn fmodl(a: c_longdouble, b: c_longdouble) callconv(.C) c_longdouble {
 inline fn generic_fmod(comptime T: type, x: T, y: T) T {
     const bits = @typeInfo(T).Float.bits;
     const uint = std.meta.Int(.unsigned, bits);
-    const log2uint = math.Log2Int(uint);
     comptime assert(T == f32 or T == f64);
     const digits = if (T == f32) 23 else 52;
     const exp_bits = if (T == f32) 9 else 12;
@@ -293,7 +292,7 @@ inline fn generic_fmod(comptime T: type, x: T, y: T) T {
             ex -= 1;
             i <<= 1;
         }) {}
-        ux <<= @as(log2uint, @intCast(@as(u32, @bitCast(-ex + 1))));
+        ux <<= @intCast(@as(u32, @bitCast(-ex + 1)));
     } else {
         ux &= math.maxInt(uint) >> exp_bits;
         ux |= 1 << digits;
@@ -304,7 +303,7 @@ inline fn generic_fmod(comptime T: type, x: T, y: T) T {
             ey -= 1;
             i <<= 1;
         }) {}
-        uy <<= @as(log2uint, @intCast(@as(u32, @bitCast(-ey + 1))));
+        uy <<= @intCast(@as(u32, @bitCast(-ey + 1)));
     } else {
         uy &= math.maxInt(uint) >> exp_bits;
         uy |= 1 << digits;
@@ -336,7 +335,7 @@ inline fn generic_fmod(comptime T: type, x: T, y: T) T {
         ux -%= 1 << digits;
         ux |= @as(uint, @as(u32, @bitCast(ex))) << digits;
     } else {
-        ux >>= @as(log2uint, @intCast(@as(u32, @bitCast(-ex + 1))));
+        ux >>= @intCast(@as(u32, @bitCast(-ex + 1)));
     }
     if (T == f32) {
         ux |= sx;
diff --git a/lib/compiler_rt/int.zig b/lib/compiler_rt/int.zig
index d61233e7cf..6cb9d5b3a3 100644
--- a/lib/compiler_rt/int.zig
+++ b/lib/compiler_rt/int.zig
@@ -52,8 +52,8 @@ test "test_divmodti4" {
         [_]i128{ -7, 5, -1, -2 },
         [_]i128{ 19, 5, 3, 4 },
         [_]i128{ 19, -5, -3, 4 },
-        [_]i128{ @as(i128, @bitCast(@as(u128, 0x80000000000000000000000000000000))), 8, @as(i128, @bitCast(@as(u128, 0xf0000000000000000000000000000000))), 0 },
-        [_]i128{ @as(i128, @bitCast(@as(u128, 0x80000000000000000000000000000007))), 8, @as(i128, @bitCast(@as(u128, 0xf0000000000000000000000000000001))), -1 },
+        [_]i128{ @bitCast(@as(u128, 0x80000000000000000000000000000000)), 8, @bitCast(@as(u128, 0xf0000000000000000000000000000000)), 0 },
+        [_]i128{ @bitCast(@as(u128, 0x80000000000000000000000000000007)), 8, @bitCast(@as(u128, 0xf0000000000000000000000000000001)), -1 },
     };
 
     for (cases) |case| {
@@ -85,8 +85,8 @@ test "test_divmoddi4" {
         [_]i64{ -7, 5, -1, -2 },
         [_]i64{ 19, 5, 3, 4 },
         [_]i64{ 19, -5, -3, 4 },
-        [_]i64{ @as(i64, @bitCast(@as(u64, 0x8000000000000000))), 8, @as(i64, @bitCast(@as(u64, 0xf000000000000000))), 0 },
-        [_]i64{ @as(i64, @bitCast(@as(u64, 0x8000000000000007))), 8, @as(i64, @bitCast(@as(u64, 0xf000000000000001))), -1 },
+        [_]i64{ @bitCast(@as(u64, 0x8000000000000000)), 8, @bitCast(@as(u64, 0xf000000000000000)), 0 },
+        [_]i64{ @bitCast(@as(u64, 0x8000000000000007)), 8, @bitCast(@as(u64, 0xf000000000000001)), -1 },
     };
 
     for (cases) |case| {
@@ -110,14 +110,14 @@ test "test_udivmoddi4" {
 
 pub fn __divdi3(a: i64, b: i64) callconv(.C) i64 {
     // Set aside the sign of the quotient.
-    const sign = @as(u64, @bitCast((a ^ b) >> 63));
+    const sign: u64 = @bitCast((a ^ b) >> 63);
     // Take absolute value of a and b via abs(x) = (x^(x >> 63)) - (x >> 63).
     const abs_a = (a ^ (a >> 63)) -% (a >> 63);
     const abs_b = (b ^ (b >> 63)) -% (b >> 63);
     // Unsigned division
-    const res = __udivmoddi4(@as(u64, @bitCast(abs_a)), @as(u64, @bitCast(abs_b)), null);
+    const res = __udivmoddi4(@bitCast(abs_a), @bitCast(abs_b), null);
     // Apply sign of quotient to result and return.
-    return @as(i64, @bitCast((res ^ sign) -% sign));
+    return @bitCast((res ^ sign) -% sign);
 }
 
 test "test_divdi3" {
@@ -151,7 +151,7 @@ pub fn __moddi3(a: i64, b: i64) callconv(.C) i64 {
     const abs_b = (b ^ (b >> 63)) -% (b >> 63);
     // Unsigned division
     var r: u64 = undefined;
-    _ = __udivmoddi4(@as(u64, @bitCast(abs_a)), @as(u64, @bitCast(abs_b)), &r);
+    _ = __udivmoddi4(@bitCast(abs_a), @bitCast(abs_b), &r);
     // Apply the sign of the dividend and return.
     return (@as(i64, @bitCast(r)) ^ (a >> 63)) -% (a >> 63);
 }
@@ -165,12 +165,12 @@ test "test_moddi3" {
         [_]i64{ -5, 3, -2 },
         [_]i64{ -5, -3, -2 },
 
-        [_]i64{ @as(i64, @bitCast(@as(u64, 0x8000000000000000))), 1, 0 },
-        [_]i64{ @as(i64, @bitCast(@as(u64, 0x8000000000000000))), -1, 0 },
-        [_]i64{ @as(i64, @bitCast(@as(u64, 0x8000000000000000))), 2, 0 },
-        [_]i64{ @as(i64, @bitCast(@as(u64, 0x8000000000000000))), -2, 0 },
-        [_]i64{ @as(i64, @bitCast(@as(u64, 0x8000000000000000))), 3, -2 },
-        [_]i64{ @as(i64, @bitCast(@as(u64, 0x8000000000000000))), -3, -2 },
+        [_]i64{ @bitCast(@as(u64, 0x8000000000000000)), 1, 0 },
+        [_]i64{ @bitCast(@as(u64, 0x8000000000000000)), -1, 0 },
+        [_]i64{ @bitCast(@as(u64, 0x8000000000000000)), 2, 0 },
+        [_]i64{ @bitCast(@as(u64, 0x8000000000000000)), -2, 0 },
+        [_]i64{ @bitCast(@as(u64, 0x8000000000000000)), 3, -2 },
+        [_]i64{ @bitCast(@as(u64, 0x8000000000000000)), -3, -2 },
     };
 
     for (cases) |case| {
@@ -225,8 +225,8 @@ test "test_divmodsi4" {
         [_]i32{ 19, 5, 3, 4 },
         [_]i32{ 19, -5, -3, 4 },
 
-        [_]i32{ @as(i32, @bitCast(@as(u32, 0x80000000))), 8, @as(i32, @bitCast(@as(u32, 0xf0000000))), 0 },
-        [_]i32{ @as(i32, @bitCast(@as(u32, 0x80000007))), 8, @as(i32, @bitCast(@as(u32, 0xf0000001))), -1 },
+        [_]i32{ @bitCast(@as(u32, 0x80000000)), 8, @bitCast(@as(u32, 0xf0000000)), 0 },
+        [_]i32{ @bitCast(@as(u32, 0x80000007)), 8, @bitCast(@as(u32, 0xf0000001)), -1 },
     };
 
     for (cases) |case| {
@@ -242,7 +242,7 @@ fn test_one_divmodsi4(a: i32, b: i32, expected_q: i32, expected_r: i32) !void {
 
 pub fn __udivmodsi4(a: u32, b: u32, rem: *u32) callconv(.C) u32 {
     const d = __udivsi3(a, b);
-    rem.* = @as(u32, @bitCast(@as(i32, @bitCast(a)) -% (@as(i32, @bitCast(d)) * @as(i32, @bitCast(b)))));
+    rem.* = @bitCast(@as(i32, @bitCast(a)) -% (@as(i32, @bitCast(d)) * @as(i32, @bitCast(b))));
     return d;
 }
 
@@ -256,14 +256,14 @@ fn __aeabi_idiv(n: i32, d: i32) callconv(.AAPCS) i32 {
 
 inline fn div_i32(n: i32, d: i32) i32 {
     // Set aside the sign of the quotient.
-    const sign = @as(u32, @bitCast((n ^ d) >> 31));
+    const sign: u32 = @bitCast((n ^ d) >> 31);
     // Take absolute value of a and b via abs(x) = (x^(x >> 31)) - (x >> 31).
     const abs_n = (n ^ (n >> 31)) -% (n >> 31);
     const abs_d = (d ^ (d >> 31)) -% (d >> 31);
     // abs(a) / abs(b)
     const res = @as(u32, @bitCast(abs_n)) / @as(u32, @bitCast(abs_d));
     // Apply sign of quotient to result and return.
-    return @as(i32, @bitCast((res ^ sign) -% sign));
+    return @bitCast((res ^ sign) -% sign);
 }
 
 test "test_divsi3" {
@@ -275,10 +275,10 @@ test "test_divsi3" {
         [_]i32{ -2, 1, -2 },
         [_]i32{ -2, -1, 2 },
 
-        [_]i32{ @as(i32, @bitCast(@as(u32, 0x80000000))), 1, @as(i32, @bitCast(@as(u32, 0x80000000))) },
-        [_]i32{ @as(i32, @bitCast(@as(u32, 0x80000000))), -1, @as(i32, @bitCast(@as(u32, 0x80000000))) },
-        [_]i32{ @as(i32, @bitCast(@as(u32, 0x80000000))), -2, 0x40000000 },
-        [_]i32{ @as(i32, @bitCast(@as(u32, 0x80000000))), 2, @as(i32, @bitCast(@as(u32, 0xC0000000))) },
+        [_]i32{ @bitCast(@as(u32, 0x80000000)), 1, @bitCast(@as(u32, 0x80000000)) },
+        [_]i32{ @bitCast(@as(u32, 0x80000000)), -1, @bitCast(@as(u32, 0x80000000)) },
+        [_]i32{ @bitCast(@as(u32, 0x80000000)), -2, 0x40000000 },
+        [_]i32{ @bitCast(@as(u32, 0x80000000)), 2, @bitCast(@as(u32, 0xC0000000)) },
     };
 
     for (cases) |case| {
@@ -317,12 +317,12 @@ inline fn div_u32(n: u32, d: u32) u32 {
     sr += 1;
     // 1 <= sr <= n_uword_bits - 1
     // Not a special case
-    var q: u32 = n << @as(u5, @intCast(n_uword_bits - sr));
-    var r: u32 = n >> @as(u5, @intCast(sr));
+    var q: u32 = n << @intCast(n_uword_bits - sr);
+    var r: u32 = n >> @intCast(sr);
     var carry: u32 = 0;
     while (sr > 0) : (sr -= 1) {
         // r:q = ((r:q)  << 1) | carry
-        r = (r << 1) | (q >> @as(u5, @intCast(n_uword_bits - 1)));
+        r = (r << 1) | (q >> @intCast(n_uword_bits - 1));
         q = (q << 1) | carry;
         // carry = 0;
         // if (r.all >= d.all)
@@ -330,8 +330,8 @@ inline fn div_u32(n: u32, d: u32) u32 {
         //      r.all -= d.all;
         //      carry = 1;
         // }
-        const s = @as(i32, @bitCast(d -% r -% 1)) >> @as(u5, @intCast(n_uword_bits - 1));
-        carry = @as(u32, @intCast(s & 1));
+        const s = @as(i32, @bitCast(d -% r -% 1)) >> @intCast(n_uword_bits - 1);
+        carry = @intCast(s & 1);
         r -= d & @as(u32, @bitCast(s));
     }
     q = (q << 1) | carry;
@@ -496,11 +496,11 @@ test "test_modsi3" {
         [_]i32{ 5, -3, 2 },
         [_]i32{ -5, 3, -2 },
         [_]i32{ -5, -3, -2 },
-        [_]i32{ @as(i32, @bitCast(@as(u32, @intCast(0x80000000)))), 1, 0x0 },
-        [_]i32{ @as(i32, @bitCast(@as(u32, @intCast(0x80000000)))), 2, 0x0 },
-        [_]i32{ @as(i32, @bitCast(@as(u32, @intCast(0x80000000)))), -2, 0x0 },
-        [_]i32{ @as(i32, @bitCast(@as(u32, @intCast(0x80000000)))), 3, -2 },
-        [_]i32{ @as(i32, @bitCast(@as(u32, @intCast(0x80000000)))), -3, -2 },
+        [_]i32{ @bitCast(@as(u32, @intCast(0x80000000))), 1, 0x0 },
+        [_]i32{ @bitCast(@as(u32, @intCast(0x80000000))), 2, 0x0 },
+        [_]i32{ @bitCast(@as(u32, @intCast(0x80000000))), -2, 0x0 },
+        [_]i32{ @bitCast(@as(u32, @intCast(0x80000000))), 3, -2 },
+        [_]i32{ @bitCast(@as(u32, @intCast(0x80000000))), -3, -2 },
     };
 
     for (cases) |case| {
diff --git a/lib/compiler_rt/int_from_float.zig b/lib/compiler_rt/int_from_float.zig
index aa2f78f922..7149bf53bf 100644
--- a/lib/compiler_rt/int_from_float.zig
+++ b/lib/compiler_rt/int_from_float.zig
@@ -17,7 +17,7 @@ pub inline fn intFromFloat(comptime I: type, a: anytype) I {
     const sig_mask = (@as(rep_t, 1) << sig_bits) - 1;
 
     // Break a into sign, exponent, significand
-    const a_rep: rep_t = @as(rep_t, @bitCast(a));
+    const a_rep: rep_t = @bitCast(a);
     const negative = (a_rep >> (float_bits - 1)) != 0;
     const exponent = @as(i32, @intCast((a_rep << 1) >> (sig_bits + 1))) - exp_bias;
     const significand: rep_t = (a_rep & sig_mask) | implicit_bit;
@@ -40,9 +40,9 @@ pub inline fn intFromFloat(comptime I: type, a: anytype) I {
     // Otherwise, shift left.
     var result: I = undefined;
     if (exponent < fractional_bits) {
-        result = @as(I, @intCast(significand >> @as(Log2Int(rep_t), @intCast(fractional_bits - exponent))));
+        result = @intCast(significand >> @intCast(fractional_bits - exponent));
     } else {
-        result = @as(I, @intCast(significand)) << @as(Log2Int(I), @intCast(exponent - fractional_bits));
+        result = @as(I, @intCast(significand)) << @intCast(exponent - fractional_bits);
     }
 
     if ((@typeInfo(I).Int.signedness == .signed) and negative)
diff --git a/lib/compiler_rt/log10.zig b/lib/compiler_rt/log10.zig
index 57ddbcf323..917a200123 100644
--- a/lib/compiler_rt/log10.zig
+++ b/lib/compiler_rt/log10.zig
@@ -28,7 +28,7 @@ comptime {
 
 pub fn __log10h(a: f16) callconv(.C) f16 {
     // TODO: more efficient implementation
-    return @as(f16, @floatCast(log10f(a)));
+    return @floatCast(log10f(a));
 }
 
 pub fn log10f(x_: f32) callconv(.C) f32 {
@@ -42,7 +42,7 @@ pub fn log10f(x_: f32) callconv(.C) f32 {
     const Lg4: f32 = 0xf89e26.0p-26;
 
     var x = x_;
-    var u = @as(u32, @bitCast(x));
+    var u: u32 = @bitCast(x);
     var ix = u;
     var k: i32 = 0;
 
@@ -59,7 +59,7 @@ pub fn log10f(x_: f32) callconv(.C) f32 {
 
         k -= 25;
         x *= 0x1.0p25;
-        ix = @as(u32, @bitCast(x));
+        ix = @bitCast(x);
     } else if (ix >= 0x7F800000) {
         return x;
     } else if (ix == 0x3F800000) {
@@ -70,7 +70,7 @@ pub fn log10f(x_: f32) callconv(.C) f32 {
     ix += 0x3F800000 - 0x3F3504F3;
     k += @as(i32, @intCast(ix >> 23)) - 0x7F;
     ix = (ix & 0x007FFFFF) + 0x3F3504F3;
-    x = @as(f32, @bitCast(ix));
+    x = @bitCast(ix);
 
     const f = x - 1.0;
     const s = f / (2.0 + f);
@@ -168,12 +168,12 @@ pub fn log10(x_: f64) callconv(.C) f64 {
 
 pub fn __log10x(a: f80) callconv(.C) f80 {
     // TODO: more efficient implementation
-    return @as(f80, @floatCast(log10q(a)));
+    return @floatCast(log10q(a));
 }
 
 pub fn log10q(a: f128) callconv(.C) f128 {
     // TODO: more correct implementation
-    return log10(@as(f64, @floatCast(a)));
+    return log10(@floatCast(a));
 }
 
 pub fn log10l(x: c_longdouble) callconv(.C) c_longdouble {
diff --git a/lib/compiler_rt/modti3_test.zig b/lib/compiler_rt/modti3_test.zig
index cad78f68bf..800547b48b 100644
--- a/lib/compiler_rt/modti3_test.zig
+++ b/lib/compiler_rt/modti3_test.zig
@@ -33,5 +33,5 @@ fn make_ti(high: u64, low: u64) i128 {
     var result: u128 = high;
     result <<= 64;
     result |= low;
-    return @as(i128, @bitCast(result));
+    return @bitCast(result);
 }
diff --git a/lib/compiler_rt/mulf3.zig b/lib/compiler_rt/mulf3.zig
index de22b1eae6..c61ade8e55 100644
--- a/lib/compiler_rt/mulf3.zig
+++ b/lib/compiler_rt/mulf3.zig
@@ -29,16 +29,16 @@ pub inline fn mulf3(comptime T: type, a: T, b: T) T {
 
     const absMask = signBit - 1;
     const qnanRep = @as(Z, @bitCast(math.nan(T))) | quietBit;
-    const infRep = @as(Z, @bitCast(math.inf(T)));
-    const minNormalRep = @as(Z, @bitCast(math.floatMin(T)));
+    const infRep: Z = @bitCast(math.inf(T));
+    const minNormalRep: Z = @bitCast(math.floatMin(T));
 
     const ZExp = if (typeWidth >= 32) u32 else Z;
-    const aExponent = @as(ZExp, @truncate((@as(Z, @bitCast(a)) >> significandBits) & maxExponent));
-    const bExponent = @as(ZExp, @truncate((@as(Z, @bitCast(b)) >> significandBits) & maxExponent));
+    const aExponent: ZExp = @truncate((@as(Z, @bitCast(a)) >> significandBits) & maxExponent);
+    const bExponent: ZExp = @truncate((@as(Z, @bitCast(b)) >> significandBits) & maxExponent);
     const productSign: Z = (@as(Z, @bitCast(a)) ^ @as(Z, @bitCast(b))) & signBit;
 
-    var aSignificand: ZSignificand = @as(ZSignificand, @intCast(@as(Z, @bitCast(a)) & significandMask));
-    var bSignificand: ZSignificand = @as(ZSignificand, @intCast(@as(Z, @bitCast(b)) & significandMask));
+    var aSignificand: ZSignificand = @intCast(@as(Z, @bitCast(a)) & significandMask);
+    var bSignificand: ZSignificand = @intCast(@as(Z, @bitCast(b)) & significandMask);
     var scale: i32 = 0;
 
     // Detect if a or b is zero, denormal, infinity, or NaN.
@@ -47,9 +47,9 @@ pub inline fn mulf3(comptime T: type, a: T, b: T) T {
         const bAbs: Z = @as(Z, @bitCast(b)) & absMask;
 
         // NaN * anything = qNaN
-        if (aAbs > infRep) return @as(T, @bitCast(@as(Z, @bitCast(a)) | quietBit));
+        if (aAbs > infRep) return @bitCast(@as(Z, @bitCast(a)) | quietBit);
         // anything * NaN = qNaN
-        if (bAbs > infRep) return @as(T, @bitCast(@as(Z, @bitCast(b)) | quietBit));
+        if (bAbs > infRep) return @bitCast(@as(Z, @bitCast(b)) | quietBit);
 
         if (aAbs == infRep) {
             // infinity * non-zero = +/- infinity
@@ -110,7 +110,7 @@ pub inline fn mulf3(comptime T: type, a: T, b: T) T {
     }
 
     // If we have overflowed the type, return +/- infinity.
-    if (productExponent >= maxExponent) return @as(T, @bitCast(infRep | productSign));
+    if (productExponent >= maxExponent) return @bitCast(infRep | productSign);
 
     var result: Z = undefined;
     if (productExponent <= 0) {
@@ -120,8 +120,8 @@ pub inline fn mulf3(comptime T: type, a: T, b: T) T {
         // a zero of the appropriate sign.  Mathematically there is no need to
         // handle this case separately, but we make it a special case to
         // simplify the shift logic.
-        const shift: u32 = @as(u32, @truncate(@as(Z, 1) -% @as(u32, @bitCast(productExponent))));
-        if (shift >= ZSignificandBits) return @as(T, @bitCast(productSign));
+        const shift: u32 = @truncate(@as(Z, 1) -% @as(u32, @bitCast(productExponent)));
+        if (shift >= ZSignificandBits) return @bitCast(productSign);
 
         // Otherwise, shift the significand of the result so that the round
         // bit is the high bit of productLo.
@@ -156,7 +156,7 @@ pub inline fn mulf3(comptime T: type, a: T, b: T) T {
     // Insert the sign of the result:
     result |= productSign;
 
-    return @as(T, @bitCast(result));
+    return @bitCast(result);
 }
 
 /// Returns `true` if the right shift is inexact (i.e. any bit shifted out is non-zero)
@@ -165,15 +165,14 @@ pub inline fn mulf3(comptime T: type, a: T, b: T) T {
 fn wideShrWithTruncation(comptime Z: type, hi: *Z, lo: *Z, count: u32) bool {
     @setRuntimeSafety(builtin.is_test);
     const typeWidth = @typeInfo(Z).Int.bits;
-    const S = math.Log2Int(Z);
     var inexact = false;
     if (count < typeWidth) {
-        inexact = (lo.* << @as(S, @intCast(typeWidth -% count))) != 0;
-        lo.* = (hi.* << @as(S, @intCast(typeWidth -% count))) | (lo.* >> @as(S, @intCast(count)));
-        hi.* = hi.* >> @as(S, @intCast(count));
+        inexact = (lo.* << @intCast(typeWidth -% count)) != 0;
+        lo.* = (hi.* << @intCast(typeWidth -% count)) | (lo.* >> @intCast(count));
+        hi.* = hi.* >> @intCast(count);
     } else if (count < 2 * typeWidth) {
-        inexact = (hi.* << @as(S, @intCast(2 * typeWidth -% count)) | lo.*) != 0;
-        lo.* = hi.* >> @as(S, @intCast(count -% typeWidth));
+        inexact = (hi.* << @intCast(2 * typeWidth -% count) | lo.*) != 0;
+        lo.* = hi.* >> @intCast(count -% typeWidth);
         hi.* = 0;
     } else {
         inexact = (hi.* | lo.*) != 0;
@@ -188,7 +187,7 @@ fn normalize(comptime T: type, significand: *PowerOfTwoSignificandZ(T)) i32 {
     const integerBit = @as(Z, 1) << math.floatFractionalBits(T);
 
     const shift = @clz(significand.*) - @clz(integerBit);
-    significand.* <<= @as(math.Log2Int(Z), @intCast(shift));
+    significand.* <<= @intCast(shift);
     return @as(i32, 1) - shift;
 }
 
diff --git a/lib/compiler_rt/parity.zig b/lib/compiler_rt/parity.zig
index 02050ba6bc..219102c226 100644
--- a/lib/compiler_rt/parity.zig
+++ b/lib/compiler_rt/parity.zig
@@ -26,12 +26,7 @@ pub fn __parityti2(a: i128) callconv(.C) i32 {
 }
 
 inline fn parityXi2(comptime T: type, a: T) i32 {
-    var x = switch (@bitSizeOf(T)) {
-        32 => @as(u32, @bitCast(a)),
-        64 => @as(u64, @bitCast(a)),
-        128 => @as(u128, @bitCast(a)),
-        else => unreachable,
-    };
+    var x: std.meta.Int(.unsigned, @typeInfo(T).Int.bits) = @bitCast(a);
     // Bit Twiddling Hacks: Compute parity in parallel
     comptime var shift: u8 = @bitSizeOf(T) / 2;
     inline while (shift > 2) {
@@ -39,7 +34,7 @@ inline fn parityXi2(comptime T: type, a: T) i32 {
         shift = shift >> 1;
     }
     x &= 0xf;
-    return (@as(u16, @intCast(0x6996)) >> @as(u4, @intCast(x))) & 1; // optimization for >>2 and >>1
+    return (@as(u16, 0x6996) >> @intCast(x)) & 1; // optimization for >>2 and >>1
 }
 
 test {
diff --git a/lib/compiler_rt/paritydi2_test.zig b/lib/compiler_rt/paritydi2_test.zig
index 5ae8e2d2e7..92f8e6a53e 100644
--- a/lib/compiler_rt/paritydi2_test.zig
+++ b/lib/compiler_rt/paritydi2_test.zig
@@ -3,13 +3,13 @@ const parity = @import("parity.zig");
 const testing = std.testing;
 
 fn paritydi2Naive(a: i64) i32 {
-    var x = @as(u64, @bitCast(a));
+    var x: u64 = @bitCast(a);
     var has_parity: bool = false;
     while (x > 0) {
         has_parity = !has_parity;
         x = x & (x - 1);
     }
-    return @as(i32, @intCast(@intFromBool(has_parity)));
+    return @intCast(@intFromBool(has_parity));
 }
 
 fn test__paritydi2(a: i64) !void {
@@ -22,9 +22,9 @@ test "paritydi2" {
     try test__paritydi2(0);
     try test__paritydi2(1);
     try test__paritydi2(2);
-    try test__paritydi2(@as(i64, @bitCast(@as(u64, 0xffffffff_fffffffd))));
-    try test__paritydi2(@as(i64, @bitCast(@as(u64, 0xffffffff_fffffffe))));
-    try test__paritydi2(@as(i64, @bitCast(@as(u64, 0xffffffff_ffffffff))));
+    try test__paritydi2(@bitCast(@as(u64, 0xffffffff_fffffffd)));
+    try test__paritydi2(@bitCast(@as(u64, 0xffffffff_fffffffe)));
+    try test__paritydi2(@bitCast(@as(u64, 0xffffffff_ffffffff)));
 
     const RndGen = std.rand.DefaultPrng;
     var rnd = RndGen.init(42);
diff --git a/lib/compiler_rt/paritysi2_test.zig b/lib/compiler_rt/paritysi2_test.zig
index 3726170b53..804dc74c33 100644
--- a/lib/compiler_rt/paritysi2_test.zig
+++ b/lib/compiler_rt/paritysi2_test.zig
@@ -3,13 +3,13 @@ const parity = @import("parity.zig");
 const testing = std.testing;
 
 fn paritysi2Naive(a: i32) i32 {
-    var x = @as(u32, @bitCast(a));
+    var x: u32 = @bitCast(a);
     var has_parity: bool = false;
     while (x > 0) {
         has_parity = !has_parity;
         x = x & (x - 1);
     }
-    return @as(i32, @intCast(@intFromBool(has_parity)));
+    return @intCast(@intFromBool(has_parity));
 }
 
 fn test__paritysi2(a: i32) !void {
@@ -22,9 +22,9 @@ test "paritysi2" {
     try test__paritysi2(0);
     try test__paritysi2(1);
     try test__paritysi2(2);
-    try test__paritysi2(@as(i32, @bitCast(@as(u32, 0xfffffffd))));
-    try test__paritysi2(@as(i32, @bitCast(@as(u32, 0xfffffffe))));
-    try test__paritysi2(@as(i32, @bitCast(@as(u32, 0xffffffff))));
+    try test__paritysi2(@bitCast(@as(u32, 0xfffffffd)));
+    try test__paritysi2(@bitCast(@as(u32, 0xfffffffe)));
+    try test__paritysi2(@bitCast(@as(u32, 0xffffffff)));
 
     const RndGen = std.rand.DefaultPrng;
     var rnd = RndGen.init(42);
diff --git a/lib/compiler_rt/parityti2_test.zig b/lib/compiler_rt/parityti2_test.zig
index 6defa900b3..f934ee9021 100644
--- a/lib/compiler_rt/parityti2_test.zig
+++ b/lib/compiler_rt/parityti2_test.zig
@@ -9,7 +9,7 @@ fn parityti2Naive(a: i128) i32 {
         has_parity = !has_parity;
         x = x & (x - 1);
     }
-    return @as(i32, @intCast(@intFromBool(has_parity)));
+    return @intCast(@intFromBool(has_parity));
 }
 
 fn test__parityti2(a: i128) !void {
@@ -22,9 +22,9 @@ test "parityti2" {
     try test__parityti2(0);
     try test__parityti2(1);
     try test__parityti2(2);
-    try test__parityti2(@as(i128, @bitCast(@as(u128, 0xffffffff_ffffffff_ffffffff_fffffffd))));
-    try test__parityti2(@as(i128, @bitCast(@as(u128, 0xffffffff_ffffffff_ffffffff_fffffffe))));
-    try test__parityti2(@as(i128, @bitCast(@as(u128, 0xffffffff_ffffffff_ffffffff_ffffffff))));
+    try test__parityti2(@bitCast(@as(u128, 0xffffffff_ffffffff_ffffffff_fffffffd)));
+    try test__parityti2(@bitCast(@as(u128, 0xffffffff_ffffffff_ffffffff_fffffffe)));
+    try test__parityti2(@bitCast(@as(u128, 0xffffffff_ffffffff_ffffffff_ffffffff)));
 
     const RndGen = std.rand.DefaultPrng;
     var rnd = RndGen.init(42);
diff --git a/lib/compiler_rt/popcount.zig b/lib/compiler_rt/popcount.zig
index ab61b0d535..64a73b804f 100644
--- a/lib/compiler_rt/popcount.zig
+++ b/lib/compiler_rt/popcount.zig
@@ -37,7 +37,7 @@ inline fn popcountXi2(comptime ST: type, a: ST) i32 {
         i128 => u128,
         else => unreachable,
     };
-    var x = @as(UT, @bitCast(a));
+    var x: UT = @bitCast(a);
     x -= (x >> 1) & (~@as(UT, 0) / 3); // 0x55...55, aggregate duos
     x = ((x >> 2) & (~@as(UT, 0) / 5)) // 0x33...33, aggregate nibbles
     + (x & (~@as(UT, 0) / 5));
@@ -46,7 +46,7 @@ inline fn popcountXi2(comptime ST: type, a: ST) i32 {
     // 8 most significant bits of x + (x<<8) + (x<<16) + ..
     x *%= ~@as(UT, 0) / 255; // 0x01...01
     x >>= (@bitSizeOf(ST) - 8);
-    return @as(i32, @intCast(x));
+    return @intCast(x);
 }
 
 test {
diff --git a/lib/compiler_rt/rem_pio2.zig b/lib/compiler_rt/rem_pio2.zig
index 642e7cd3e2..33575b7f65 100644
--- a/lib/compiler_rt/rem_pio2.zig
+++ b/lib/compiler_rt/rem_pio2.zig
@@ -25,10 +25,6 @@ const pio2_3 = 2.02226624871116645580e-21; // 0x3BA3198A, 0x2E000000
 // pio2_3t:  pi/2 - (pio2_1+pio2_2+pio2_3)
 const pio2_3t = 8.47842766036889956997e-32; // 0x397B839A, 0x252049C1
 
-fn U(x: anytype) usize {
-    return @as(usize, @intCast(x));
-}
-
 fn medium(ix: u32, x: f64, y: *[2]f64) i32 {
     var w: f64 = undefined;
     var t: f64 = undefined;
@@ -41,7 +37,7 @@ fn medium(ix: u32, x: f64, y: *[2]f64) i32 {
 
     // rint(x/(pi/2))
     @"fn" = x * invpio2 + toint - toint;
-    n = @as(i32, @intFromFloat(@"fn"));
+    n = @intFromFloat(@"fn");
     r = x - @"fn" * pio2_1;
     w = @"fn" * pio2_1t; // 1st round, good to 85 bits
     // Matters with directed rounding.
@@ -174,16 +170,16 @@ pub fn rem_pio2(x: f64, y: *[2]f64) i32 {
     ui = @bitCast(x);
     ui &= std.math.maxInt(u64) >> 12;
     ui |= @as(u64, 0x3ff + 23) << 52;
-    z = @as(f64, @bitCast(ui));
+    z = @bitCast(ui);
 
     i = 0;
     while (i < 2) : (i += 1) {
-        tx[U(i)] = @as(f64, @floatFromInt(@as(i32, @intFromFloat(z))));
-        z = (z - tx[U(i)]) * 0x1p24;
+        tx[@intCast(i)] = @floatFromInt(@as(i32, @intFromFloat(z)));
+        z = (z - tx[@intCast(i)]) * 0x1p24;
     }
-    tx[U(i)] = z;
+    tx[@intCast(i)] = z;
     // skip zero terms, first term is non-zero
-    while (tx[U(i)] == 0.0) {
+    while (tx[@intCast(i)] == 0.0) {
         i -= 1;
     }
     n = rem_pio2_large(tx[0..], ty[0..], @as(i32, @intCast((ix >> 20))) - (0x3ff + 23), i + 1, 1);
diff --git a/lib/compiler_rt/rem_pio2_large.zig b/lib/compiler_rt/rem_pio2_large.zig
index fea4dc608d..e0e7ed0d08 100644
--- a/lib/compiler_rt/rem_pio2_large.zig
+++ b/lib/compiler_rt/rem_pio2_large.zig
@@ -149,10 +149,6 @@ const PIo2 = [_]f64{
     2.16741683877804819444e-51, // 0x3569F31D, 0x00000000
 };
 
-fn U(x: anytype) usize {
-    return @as(usize, @intCast(x));
-}
-
 /// Returns the last three digits of N with y = x - N*pi/2 so that |y| < pi/2.
 ///
 /// The method is to compute the integer (mod 8) and fraction parts of
@@ -295,7 +291,7 @@ pub fn rem_pio2_large(x: []f64, y: []f64, e0: i32, nx: i32, prec: usize) i32 {
         i += 1;
         j += 1;
     }) {
-        f[U(i)] = if (j < 0) 0.0 else @as(f64, @floatFromInt(ipio2[U(j)]));
+        f[@intCast(i)] = if (j < 0) 0.0 else @floatFromInt(ipio2[@intCast(j)]);
     }
 
     // compute q[0],q[1],...q[jk]
@@ -304,9 +300,9 @@ pub fn rem_pio2_large(x: []f64, y: []f64, e0: i32, nx: i32, prec: usize) i32 {
         j = 0;
         fw = 0;
         while (j <= jx) : (j += 1) {
-            fw += x[U(j)] * f[U(jx + i - j)];
+            fw += x[@intCast(j)] * f[@intCast(jx + i - j)];
         }
-        q[U(i)] = fw;
+        q[@intCast(i)] = fw;
     }
 
     jz = jk;
@@ -317,29 +313,29 @@ pub fn rem_pio2_large(x: []f64, y: []f64, e0: i32, nx: i32, prec: usize) i32 {
         // distill q[] into iq[] reversingly
         i = 0;
         j = jz;
-        z = q[U(jz)];
+        z = q[@intCast(jz)];
         while (j > 0) : ({
             i += 1;
             j -= 1;
         }) {
             fw = @floatFromInt(@as(i32, @intFromFloat(0x1p-24 * z)));
-            iq[U(i)] = @as(i32, @intFromFloat(z - 0x1p24 * fw));
-            z = q[U(j - 1)] + fw;
+            iq[@intCast(i)] = @intFromFloat(z - 0x1p24 * fw);
+            z = q[@intCast(j - 1)] + fw;
         }
 
         // compute n
         z = math.scalbn(z, q0); // actual value of z
         z -= 8.0 * @floor(z * 0.125); // trim off integer >= 8
         n = @intFromFloat(z);
-        z -= @as(f64, @floatFromInt(n));
+        z -= @floatFromInt(n);
         ih = 0;
         if (q0 > 0) { // need iq[jz-1] to determine n
-            i = iq[U(jz - 1)] >> @as(u5, @intCast(24 - q0));
+            i = iq[@intCast(jz - 1)] >> @intCast(24 - q0);
             n += i;
-            iq[U(jz - 1)] -= i << @as(u5, @intCast(24 - q0));
-            ih = iq[U(jz - 1)] >> @as(u5, @intCast(23 - q0));
+            iq[@intCast(jz - 1)] -= i << @intCast(24 - q0);
+            ih = iq[@intCast(jz - 1)] >> @intCast(23 - q0);
         } else if (q0 == 0) {
-            ih = iq[U(jz - 1)] >> 23;
+            ih = iq[@intCast(jz - 1)] >> 23;
         } else if (z >= 0.5) {
             ih = 2;
         }
@@ -349,20 +345,20 @@ pub fn rem_pio2_large(x: []f64, y: []f64, e0: i32, nx: i32, prec: usize) i32 {
             carry = 0;
             i = 0;
             while (i < jz) : (i += 1) { // compute 1-q
-                j = iq[U(i)];
+                j = iq[@intCast(i)];
                 if (carry == 0) {
                     if (j != 0) {
                         carry = 1;
-                        iq[U(i)] = 0x1000000 - j;
+                        iq[@intCast(i)] = 0x1000000 - j;
                     }
                 } else {
-                    iq[U(i)] = 0xffffff - j;
+                    iq[@intCast(i)] = 0xffffff - j;
                 }
             }
             if (q0 > 0) { // rare case: chance is 1 in 12
                 switch (q0) {
-                    1 => iq[U(jz - 1)] &= 0x7fffff,
-                    2 => iq[U(jz - 1)] &= 0x3fffff,
+                    1 => iq[@intCast(jz - 1)] &= 0x7fffff,
+                    2 => iq[@intCast(jz - 1)] &= 0x3fffff,
                     else => unreachable,
                 }
             }
@@ -379,24 +375,24 @@ pub fn rem_pio2_large(x: []f64, y: []f64, e0: i32, nx: i32, prec: usize) i32 {
             j = 0;
             i = jz - 1;
             while (i >= jk) : (i -= 1) {
-                j |= iq[U(i)];
+                j |= iq[@intCast(i)];
             }
 
             if (j == 0) { // need recomputation
                 k = 1;
-                while (iq[U(jk - k)] == 0) : (k += 1) {
+                while (iq[@intCast(jk - k)] == 0) : (k += 1) {
                     // k = no. of terms needed
                 }
 
                 i = jz + 1;
                 while (i <= jz + k) : (i += 1) { // add q[jz+1] to q[jz+k]
-                    f[U(jx + i)] = @as(f64, @floatFromInt(ipio2[U(jv + i)]));
+                    f[@intCast(jx + i)] = @floatFromInt(ipio2[@intCast(jv + i)]);
                     j = 0;
                     fw = 0;
                     while (j <= jx) : (j += 1) {
-                        fw += x[U(j)] * f[U(jx + i - j)];
+                        fw += x[@intCast(j)] * f[@intCast(jx + i - j)];
                     }
-                    q[U(i)] = fw;
+                    q[@intCast(i)] = fw;
                 }
                 jz += k;
                 continue :recompute; // mimic goto recompute
@@ -407,7 +403,7 @@ pub fn rem_pio2_large(x: []f64, y: []f64, e0: i32, nx: i32, prec: usize) i32 {
         if (z == 0.0) {
             jz -= 1;
             q0 -= 24;
-            while (iq[U(jz)] == 0) {
+            while (iq[@intCast(jz)] == 0) {
                 jz -= 1;
                 q0 -= 24;
             }
@@ -415,12 +411,12 @@ pub fn rem_pio2_large(x: []f64, y: []f64, e0: i32, nx: i32, prec: usize) i32 {
             z = math.scalbn(z, -q0);
             if (z >= 0x1p24) {
                 fw = @floatFromInt(@as(i32, @intFromFloat(0x1p-24 * z)));
-                iq[U(jz)] = @as(i32, @intFromFloat(z - 0x1p24 * fw));
+                iq[@intCast(jz)] = @intFromFloat(z - 0x1p24 * fw);
                 jz += 1;
                 q0 += 24;
-                iq[U(jz)] = @as(i32, @intFromFloat(fw));
+                iq[@intCast(jz)] = @intFromFloat(fw);
             } else {
-                iq[U(jz)] = @as(i32, @intFromFloat(z));
+                iq[@intCast(jz)] = @intFromFloat(z);
             }
         }
 
@@ -428,7 +424,7 @@ pub fn rem_pio2_large(x: []f64, y: []f64, e0: i32, nx: i32, prec: usize) i32 {
         fw = math.scalbn(@as(f64, 1.0), q0);
         i = jz;
         while (i >= 0) : (i -= 1) {
-            q[U(i)] = fw * @as(f64, @floatFromInt(iq[U(i)]));
+            q[@intCast(i)] = fw * @as(f64, @floatFromInt(iq[@intCast(i)]));
             fw *= 0x1p-24;
         }
 
@@ -438,9 +434,9 @@ pub fn rem_pio2_large(x: []f64, y: []f64, e0: i32, nx: i32, prec: usize) i32 {
             fw = 0;
             k = 0;
             while (k <= jp and k <= jz - i) : (k += 1) {
-                fw += PIo2[U(k)] * q[U(i + k)];
+                fw += PIo2[@intCast(k)] * q[@intCast(i + k)];
             }
-            fq[U(jz - i)] = fw;
+            fq[@intCast(jz - i)] = fw;
         }
 
         // compress fq[] into y[]
@@ -449,7 +445,7 @@ pub fn rem_pio2_large(x: []f64, y: []f64, e0: i32, nx: i32, prec: usize) i32 {
                 fw = 0.0;
                 i = jz;
                 while (i >= 0) : (i -= 1) {
-                    fw += fq[U(i)];
+                    fw += fq[@intCast(i)];
                 }
                 y[0] = if (ih == 0) fw else -fw;
             },
@@ -458,7 +454,7 @@ pub fn rem_pio2_large(x: []f64, y: []f64, e0: i32, nx: i32, prec: usize) i32 {
                 fw = 0.0;
                 i = jz;
                 while (i >= 0) : (i -= 1) {
-                    fw += fq[U(i)];
+                    fw += fq[@intCast(i)];
                 }
                 // TODO: drop excess precision here once double_t is used
                 fw = fw;
@@ -466,27 +462,27 @@ pub fn rem_pio2_large(x: []f64, y: []f64, e0: i32, nx: i32, prec: usize) i32 {
                 fw = fq[0] - fw;
                 i = 1;
                 while (i <= jz) : (i += 1) {
-                    fw += fq[U(i)];
+                    fw += fq[@intCast(i)];
                 }
                 y[1] = if (ih == 0) fw else -fw;
             },
             3 => { // painful
                 i = jz;
                 while (i > 0) : (i -= 1) {
-                    fw = fq[U(i - 1)] + fq[U(i)];
-                    fq[U(i)] += fq[U(i - 1)] - fw;
-                    fq[U(i - 1)] = fw;
+                    fw = fq[@intCast(i - 1)] + fq[@intCast(i)];
+                    fq[@intCast(i)] += fq[@intCast(i - 1)] - fw;
+                    fq[@intCast(i - 1)] = fw;
                 }
                 i = jz;
                 while (i > 1) : (i -= 1) {
-                    fw = fq[U(i - 1)] + fq[U(i)];
-                    fq[U(i)] += fq[U(i - 1)] - fw;
-                    fq[U(i - 1)] = fw;
+                    fw = fq[@intCast(i - 1)] + fq[@intCast(i)];
+                    fq[@intCast(i)] += fq[@intCast(i - 1)] - fw;
+                    fq[@intCast(i - 1)] = fw;
                 }
                 fw = 0;
                 i = jz;
                 while (i >= 2) : (i -= 1) {
-                    fw += fq[U(i)];
+                    fw += fq[@intCast(i)];
                 }
                 if (ih == 0) {
                     y[0] = fq[0];
diff --git a/lib/compiler_rt/shift.zig b/lib/compiler_rt/shift.zig
index 0ca5637d9d..59701f747d 100644
--- a/lib/compiler_rt/shift.zig
+++ b/lib/compiler_rt/shift.zig
@@ -30,20 +30,19 @@ comptime {
 // Precondition: 0 <= b < bits_in_dword
 inline fn ashlXi3(comptime T: type, a: T, b: i32) T {
     const word_t = common.HalveInt(T, false);
-    const S = Log2Int(word_t.HalfT);
 
     const input = word_t{ .all = a };
     var output: word_t = undefined;
 
     if (b >= word_t.bits) {
         output.s.low = 0;
-        output.s.high = input.s.low << @as(S, @intCast(b - word_t.bits));
+        output.s.high = input.s.low << @intCast(b - word_t.bits);
     } else if (b == 0) {
         return a;
     } else {
-        output.s.low = input.s.low << @as(S, @intCast(b));
-        output.s.high = input.s.high << @as(S, @intCast(b));
-        output.s.high |= input.s.low >> @as(S, @intCast(word_t.bits - b));
+        output.s.low = input.s.low << @intCast(b);
+        output.s.high = input.s.high << @intCast(b);
+        output.s.high |= input.s.low >> @intCast(word_t.bits - b);
     }
 
     return output.all;
@@ -53,24 +52,20 @@ inline fn ashlXi3(comptime T: type, a: T, b: i32) T {
 // Precondition: 0 <= b < T.bit_count
 inline fn ashrXi3(comptime T: type, a: T, b: i32) T {
     const word_t = common.HalveInt(T, true);
-    const S = Log2Int(word_t.HalfT);
 
     const input = word_t{ .all = a };
     var output: word_t = undefined;
 
     if (b >= word_t.bits) {
         output.s.high = input.s.high >> (word_t.bits - 1);
-        output.s.low = input.s.high >> @as(S, @intCast(b - word_t.bits));
+        output.s.low = input.s.high >> @intCast(b - word_t.bits);
     } else if (b == 0) {
         return a;
     } else {
-        output.s.high = input.s.high >> @as(S, @intCast(b));
-        output.s.low = input.s.high << @as(S, @intCast(word_t.bits - b));
+        output.s.high = input.s.high >> @intCast(b);
+        output.s.low = input.s.high << @intCast(word_t.bits - b);
         // Avoid sign-extension here
-        output.s.low |= @as(
-            word_t.HalfT,
-            @bitCast(@as(word_t.HalfTU, @bitCast(input.s.low)) >> @as(S, @intCast(b))),
-        );
+        output.s.low |= @bitCast(@as(word_t.HalfTU, @bitCast(input.s.low)) >> @intCast(b));
     }
 
     return output.all;
@@ -80,20 +75,19 @@ inline fn ashrXi3(comptime T: type, a: T, b: i32) T {
 // Precondition: 0 <= b < T.bit_count
 inline fn lshrXi3(comptime T: type, a: T, b: i32) T {
     const word_t = common.HalveInt(T, false);
-    const S = Log2Int(word_t.HalfT);
 
     const input = word_t{ .all = a };
     var output: word_t = undefined;
 
     if (b >= word_t.bits) {
         output.s.high = 0;
-        output.s.low = input.s.high >> @as(S, @intCast(b - word_t.bits));
+        output.s.low = input.s.high >> @intCast(b - word_t.bits);
     } else if (b == 0) {
         return a;
     } else {
-        output.s.high = input.s.high >> @as(S, @intCast(b));
-        output.s.low = input.s.high << @as(S, @intCast(word_t.bits - b));
-        output.s.low |= input.s.low >> @as(S, @intCast(b));
+        output.s.high = input.s.high >> @intCast(b);
+        output.s.low = input.s.high << @intCast(word_t.bits - b);
+        output.s.low |= input.s.low >> @intCast(b);
     }
 
     return output.all;
diff --git a/lib/compiler_rt/sin.zig b/lib/compiler_rt/sin.zig
index 40c8287b87..b0180953e0 100644
--- a/lib/compiler_rt/sin.zig
+++ b/lib/compiler_rt/sin.zig
@@ -31,7 +31,7 @@ comptime {
 
 pub fn __sinh(x: f16) callconv(.C) f16 {
     // TODO: more efficient implementation
-    return @as(f16, @floatCast(sinf(x)));
+    return @floatCast(sinf(x));
 }
 
 pub fn sinf(x: f32) callconv(.C) f32 {
@@ -41,7 +41,7 @@ pub fn sinf(x: f32) callconv(.C) f32 {
     const s3pio2: f64 = 3.0 * math.pi / 2.0; // 0x4012D97C, 0x7F3321D2
     const s4pio2: f64 = 4.0 * math.pi / 2.0; // 0x401921FB, 0x54442D18
 
-    var ix = @as(u32, @bitCast(x));
+    var ix: u32 = @bitCast(x);
     const sign = ix >> 31 != 0;
     ix &= 0x7fffffff;
 
@@ -120,12 +120,12 @@ pub fn sin(x: f64) callconv(.C) f64 {
 
 pub fn __sinx(x: f80) callconv(.C) f80 {
     // TODO: more efficient implementation
-    return @as(f80, @floatCast(sinq(x)));
+    return @floatCast(sinq(x));
 }
 
 pub fn sinq(x: f128) callconv(.C) f128 {
     // TODO: more correct implementation
-    return sin(@as(f64, @floatCast(x)));
+    return sin(@floatCast(x));
 }
 
 pub fn sinl(x: c_longdouble) callconv(.C) c_longdouble {
@@ -180,11 +180,11 @@ test "sin64.special" {
 }
 
 test "sin32 #9901" {
-    const float = @as(f32, @bitCast(@as(u32, 0b11100011111111110000000000000000)));
+    const float: f32 = @bitCast(@as(u32, 0b11100011111111110000000000000000));
     _ = sinf(float);
 }
 
 test "sin64 #9901" {
-    const float = @as(f64, @bitCast(@as(u64, 0b1111111101000001000000001111110111111111100000000000000000000001)));
+    const float: f64 = @bitCast(@as(u64, 0b1111111101000001000000001111110111111111100000000000000000000001));
     _ = sin(float);
 }
diff --git a/lib/compiler_rt/sqrt.zig b/lib/compiler_rt/sqrt.zig
index 9996ac0582..cb686a2d62 100644
--- a/lib/compiler_rt/sqrt.zig
+++ b/lib/compiler_rt/sqrt.zig
@@ -20,13 +20,13 @@ comptime {
 
 pub fn __sqrth(x: f16) callconv(.C) f16 {
     // TODO: more efficient implementation
-    return @as(f16, @floatCast(sqrtf(x)));
+    return @floatCast(sqrtf(x));
 }
 
 pub fn sqrtf(x: f32) callconv(.C) f32 {
     const tiny: f32 = 1.0e-30;
-    const sign: i32 = @as(i32, @bitCast(@as(u32, 0x80000000)));
-    var ix: i32 = @as(i32, @bitCast(x));
+    const sign: i32 = @bitCast(@as(u32, 0x80000000));
+    var ix: i32 = @bitCast(x);
 
     if ((ix & 0x7F800000) == 0x7F800000) {
         return x * x + x; // sqrt(nan) = nan, sqrt(+inf) = +inf, sqrt(-inf) = nan
@@ -96,7 +96,7 @@ pub fn sqrtf(x: f32) callconv(.C) f32 {
 
     ix = (q >> 1) + 0x3f000000;
     ix += m << 23;
-    return @as(f32, @bitCast(ix));
+    return @bitCast(ix);
 }
 
 /// NOTE: The original code is full of implicit signed -> unsigned assumptions and u32 wraparound
@@ -105,10 +105,10 @@ pub fn sqrtf(x: f32) callconv(.C) f32 {
 pub fn sqrt(x: f64) callconv(.C) f64 {
     const tiny: f64 = 1.0e-300;
     const sign: u32 = 0x80000000;
-    const u = @as(u64, @bitCast(x));
+    const u: u64 = @bitCast(x);
 
-    var ix0 = @as(u32, @intCast(u >> 32));
-    var ix1 = @as(u32, @intCast(u & 0xFFFFFFFF));
+    var ix0: u32 = @intCast(u >> 32);
+    var ix1: u32 = @intCast(u & 0xFFFFFFFF);
 
     // sqrt(nan) = nan, sqrt(+inf) = +inf, sqrt(-inf) = nan
     if (ix0 & 0x7FF00000 == 0x7FF00000) {
@@ -140,8 +140,8 @@ pub fn sqrt(x: f64) callconv(.C) f64 {
             ix0 <<= 1;
         }
         m -= @as(i32, @intCast(i)) - 1;
-        ix0 |= ix1 >> @as(u5, @intCast(32 - i));
-        ix1 <<= @as(u5, @intCast(i));
+        ix0 |= ix1 >> @intCast(32 - i);
+        ix1 <<= @intCast(i);
     }
 
     // unbias exponent
@@ -225,21 +225,21 @@ pub fn sqrt(x: f64) callconv(.C) f64 {
 
     // NOTE: musl here appears to rely on signed twos-complement wraparound. +% has the same
     // behaviour at least.
-    var iix0 = @as(i32, @intCast(ix0));
+    var iix0: i32 = @intCast(ix0);
     iix0 = iix0 +% (m << 20);
 
     const uz = (@as(u64, @intCast(iix0)) << 32) | ix1;
-    return @as(f64, @bitCast(uz));
+    return @bitCast(uz);
 }
 
 pub fn __sqrtx(x: f80) callconv(.C) f80 {
     // TODO: more efficient implementation
-    return @as(f80, @floatCast(sqrtq(x)));
+    return @floatCast(sqrtq(x));
 }
 
 pub fn sqrtq(x: f128) callconv(.C) f128 {
     // TODO: more correct implementation
-    return sqrt(@as(f64, @floatCast(x)));
+    return sqrt(@floatCast(x));
 }
 
 pub fn sqrtl(x: c_longdouble) callconv(.C) c_longdouble {
diff --git a/lib/compiler_rt/tan.zig b/lib/compiler_rt/tan.zig
index 58290cc9b7..367883754f 100644
--- a/lib/compiler_rt/tan.zig
+++ b/lib/compiler_rt/tan.zig
@@ -106,12 +106,12 @@ pub fn tan(x: f64) callconv(.C) f64 {
 
 pub fn __tanx(x: f80) callconv(.C) f80 {
     // TODO: more efficient implementation
-    return @as(f80, @floatCast(tanq(x)));
+    return @floatCast(tanq(x));
 }
 
 pub fn tanq(x: f128) callconv(.C) f128 {
     // TODO: more correct implementation
-    return tan(@as(f64, @floatCast(x)));
+    return tan(@floatCast(x));
 }
 
 pub fn tanl(x: c_longdouble) callconv(.C) c_longdouble {
diff --git a/lib/compiler_rt/trig.zig b/lib/compiler_rt/trig.zig
index c422d76b46..a2ec255459 100644
--- a/lib/compiler_rt/trig.zig
+++ b/lib/compiler_rt/trig.zig
@@ -70,7 +70,7 @@ pub fn __cosdf(x: f64) f32 {
     const z = x * x;
     const w = z * z;
     const r = C2 + z * C3;
-    return @as(f32, @floatCast(((1.0 + z * C0) + w * C1) + (w * z) * r));
+    return @floatCast(((1.0 + z * C0) + w * C1) + (w * z) * r);
 }
 
 /// kernel sin function on ~[-pi/4, pi/4] (except on -0), pi/4 ~ 0.7854
@@ -131,7 +131,7 @@ pub fn __sindf(x: f64) f32 {
     const w = z * z;
     const r = S3 + z * S4;
     const s = z * x;
-    return @as(f32, @floatCast((x + s * (S1 + z * S2)) + s * w * r));
+    return @floatCast((x + s * (S1 + z * S2)) + s * w * r);
 }
 
 /// kernel tan function on ~[-pi/4, pi/4] (except on -0), pi/4 ~ 0.7854
@@ -231,11 +231,11 @@ pub fn __tan(x_: f64, y_: f64, odd: bool) f64 {
     }
     // -1.0/(x+r) has up to 2ulp error, so compute it accurately
     w0 = w;
-    w0 = @as(f64, @bitCast(@as(u64, @bitCast(w0)) & 0xffffffff00000000));
+    w0 = @bitCast(@as(u64, @bitCast(w0)) & 0xffffffff00000000);
     v = r - (w0 - x); // w0+v = r+x
     a = -1.0 / w;
     a0 = a;
-    a0 = @as(f64, @bitCast(@as(u64, @bitCast(a0)) & 0xffffffff00000000));
+    a0 = @bitCast(@as(u64, @bitCast(a0)) & 0xffffffff00000000);
     return a0 + a * (1.0 + a0 * w0 + a0 * v);
 }
 
@@ -269,5 +269,5 @@ pub fn __tandf(x: f64, odd: bool) f32 {
     const s = z * x;
     const u = T[0] + z * T[1];
     const r0 = (x + s * u) + (s * w) * (t + w * r);
-    return @as(f32, @floatCast(if (odd) -1.0 / r0 else r0));
+    return @floatCast(if (odd) -1.0 / r0 else r0);
 }
diff --git a/lib/compiler_rt/trunc.zig b/lib/compiler_rt/trunc.zig
index 604d310ae0..80b7a2bf89 100644
--- a/lib/compiler_rt/trunc.zig
+++ b/lib/compiler_rt/trunc.zig
@@ -42,7 +42,7 @@ pub fn truncf(x: f32) callconv(.C) f32 {
         e = 1;
     }
 
-    m = @as(u32, math.maxInt(u32)) >> @as(u5, @intCast(e));
+    m = @as(u32, math.maxInt(u32)) >> @intCast(e);
     if (u & m == 0) {
         return x;
     } else {
@@ -63,7 +63,7 @@ pub fn trunc(x: f64) callconv(.C) f64 {
         e = 1;
     }
 
-    m = @as(u64, math.maxInt(u64)) >> @as(u6, @intCast(e));
+    m = @as(u64, math.maxInt(u64)) >> @intCast(e);
     if (u & m == 0) {
         return x;
     } else {
@@ -74,11 +74,11 @@ pub fn trunc(x: f64) callconv(.C) f64 {
 
 pub fn __truncx(x: f80) callconv(.C) f80 {
     // TODO: more efficient implementation
-    return @as(f80, @floatCast(truncq(x)));
+    return @floatCast(truncq(x));
 }
 
 pub fn truncq(x: f128) callconv(.C) f128 {
-    const u = @as(u128, @bitCast(x));
+    const u: u128 = @bitCast(x);
     var e = @as(i32, @intCast(((u >> 112) & 0x7FFF))) - 0x3FFF + 16;
     var m: u128 = undefined;
 
@@ -89,12 +89,12 @@ pub fn truncq(x: f128) callconv(.C) f128 {
         e = 1;
     }
 
-    m = @as(u128, math.maxInt(u128)) >> @as(u7, @intCast(e));
+    m = @as(u128, math.maxInt(u128)) >> @intCast(e);
     if (u & m == 0) {
         return x;
     } else {
         math.doNotOptimizeAway(x + 0x1p120);
-        return @as(f128, @bitCast(u & ~m));
+        return @bitCast(u & ~m);
     }
 }
 
diff --git a/lib/compiler_rt/truncdfhf2.zig b/lib/compiler_rt/truncdfhf2.zig
index ce849a8b9e..29e57f6685 100644
--- a/lib/compiler_rt/truncdfhf2.zig
+++ b/lib/compiler_rt/truncdfhf2.zig
@@ -12,9 +12,9 @@ comptime {
 }
 
 pub fn __truncdfhf2(a: f64) callconv(.C) common.F16T(f64) {
-    return @as(common.F16T(f64), @bitCast(truncf(f16, f64, a)));
+    return @bitCast(truncf(f16, f64, a));
 }
 
 fn __aeabi_d2h(a: f64) callconv(.AAPCS) u16 {
-    return @as(common.F16T(f64), @bitCast(truncf(f16, f64, a)));
+    return @bitCast(truncf(f16, f64, a));
 }
diff --git a/lib/compiler_rt/truncf.zig b/lib/compiler_rt/truncf.zig
index e8df4b910f..02b6c7d4bd 100644
--- a/lib/compiler_rt/truncf.zig
+++ b/lib/compiler_rt/truncf.zig
@@ -5,7 +5,6 @@ pub inline fn truncf(comptime dst_t: type, comptime src_t: type, a: src_t) dst_t
     const dst_rep_t = std.meta.Int(.unsigned, @typeInfo(dst_t).Float.bits);
     const srcSigBits = std.math.floatMantissaBits(src_t);
     const dstSigBits = std.math.floatMantissaBits(dst_t);
-    const SrcShift = std.math.Log2Int(src_rep_t);
 
     // Various constants whose values follow from the type parameters.
     // Any reasonable optimizer will fold and propagate all of these.
@@ -38,7 +37,7 @@ pub inline fn truncf(comptime dst_t: type, comptime src_t: type, a: src_t) dst_t
     const dstNaNCode = dstQNaN - 1;
 
     // Break a into a sign and representation of the absolute value
-    const aRep: src_rep_t = @as(src_rep_t, @bitCast(a));
+    const aRep: src_rep_t = @bitCast(a);
     const aAbs: src_rep_t = aRep & srcAbsMask;
     const sign: src_rep_t = aRep & srcSignMask;
     var absResult: dst_rep_t = undefined;
@@ -47,7 +46,7 @@ pub inline fn truncf(comptime dst_t: type, comptime src_t: type, a: src_t) dst_t
         // The exponent of a is within the range of normal numbers in the
         // destination format.  We can convert by simply right-shifting with
         // rounding and adjusting the exponent.
-        absResult = @as(dst_rep_t, @truncate(aAbs >> (srcSigBits - dstSigBits)));
+        absResult = @truncate(aAbs >> (srcSigBits - dstSigBits));
         absResult -%= @as(dst_rep_t, srcExpBias - dstExpBias) << dstSigBits;
 
         const roundBits: src_rep_t = aAbs & roundMask;
@@ -64,7 +63,7 @@ pub inline fn truncf(comptime dst_t: type, comptime src_t: type, a: src_t) dst_t
         // bit and inserting the (truncated) trailing NaN field.
         absResult = @as(dst_rep_t, @intCast(dstInfExp)) << dstSigBits;
         absResult |= dstQNaN;
-        absResult |= @as(dst_rep_t, @intCast(((aAbs & srcNaNCode) >> (srcSigBits - dstSigBits)) & dstNaNCode));
+        absResult |= @intCast(((aAbs & srcNaNCode) >> (srcSigBits - dstSigBits)) & dstNaNCode);
     } else if (aAbs >= overflow) {
         // a overflows to infinity.
         absResult = @as(dst_rep_t, @intCast(dstInfExp)) << dstSigBits;
@@ -81,9 +80,9 @@ pub inline fn truncf(comptime dst_t: type, comptime src_t: type, a: src_t) dst_t
         if (shift > srcSigBits) {
             absResult = 0;
         } else {
-            const sticky: src_rep_t = @intFromBool(significand << @as(SrcShift, @intCast(srcBits - shift)) != 0);
-            const denormalizedSignificand: src_rep_t = significand >> @as(SrcShift, @intCast(shift)) | sticky;
-            absResult = @as(dst_rep_t, @intCast(denormalizedSignificand >> (srcSigBits - dstSigBits)));
+            const sticky: src_rep_t = @intFromBool(significand << @intCast(srcBits - shift) != 0);
+            const denormalizedSignificand: src_rep_t = significand >> @intCast(shift) | sticky;
+            absResult = @intCast(denormalizedSignificand >> (srcSigBits - dstSigBits));
             const roundBits: src_rep_t = denormalizedSignificand & roundMask;
             if (roundBits > halfway) {
                 // Round to nearest
@@ -96,8 +95,8 @@ pub inline fn truncf(comptime dst_t: type, comptime src_t: type, a: src_t) dst_t
     }
 
     const result: dst_rep_t align(@alignOf(dst_t)) = absResult |
-        @as(dst_rep_t, @truncate(sign >> @as(SrcShift, @intCast(srcBits - dstBits))));
-    return @as(dst_t, @bitCast(result));
+        @as(dst_rep_t, @truncate(sign >> @intCast(srcBits - dstBits)));
+    return @bitCast(result);
 }
 
 pub inline fn trunc_f80(comptime dst_t: type, a: f80) dst_t {
@@ -133,7 +132,7 @@ pub inline fn trunc_f80(comptime dst_t: type, a: f80) dst_t {
         // destination format.  We can convert by simply right-shifting with
         // rounding and adjusting the exponent.
         abs_result = @as(dst_rep_t, a_rep.exp) << dst_sig_bits;
-        abs_result |= @as(dst_rep_t, @truncate(a_rep.fraction >> (src_sig_bits - dst_sig_bits)));
+        abs_result |= @truncate(a_rep.fraction >> (src_sig_bits - dst_sig_bits));
         abs_result -%= @as(dst_rep_t, src_exp_bias - dst_exp_bias) << dst_sig_bits;
 
         const round_bits = a_rep.fraction & round_mask;
@@ -150,7 +149,7 @@ pub inline fn trunc_f80(comptime dst_t: type, a: f80) dst_t {
         // bit and inserting the (truncated) trailing NaN field.
         abs_result = @as(dst_rep_t, @intCast(dst_inf_exp)) << dst_sig_bits;
         abs_result |= dst_qnan;
-        abs_result |= @as(dst_rep_t, @intCast((a_rep.fraction >> (src_sig_bits - dst_sig_bits)) & dst_nan_mask));
+        abs_result |= @intCast((a_rep.fraction >> (src_sig_bits - dst_sig_bits)) & dst_nan_mask);
     } else if (a_rep.exp >= overflow) {
         // a overflows to infinity.
         abs_result = @as(dst_rep_t, @intCast(dst_inf_exp)) << dst_sig_bits;
@@ -164,9 +163,9 @@ pub inline fn trunc_f80(comptime dst_t: type, a: f80) dst_t {
         if (shift > src_sig_bits) {
             abs_result = 0;
         } else {
-            const sticky = @intFromBool(a_rep.fraction << @as(u6, @intCast(shift)) != 0);
-            const denormalized_significand = a_rep.fraction >> @as(u6, @intCast(shift)) | sticky;
-            abs_result = @as(dst_rep_t, @intCast(denormalized_significand >> (src_sig_bits - dst_sig_bits)));
+            const sticky = @intFromBool(a_rep.fraction << @intCast(shift) != 0);
+            const denormalized_significand = a_rep.fraction >> @intCast(shift) | sticky;
+            abs_result = @intCast(denormalized_significand >> (src_sig_bits - dst_sig_bits));
             const round_bits = denormalized_significand & round_mask;
             if (round_bits > halfway) {
                 // Round to nearest
@@ -179,7 +178,7 @@ pub inline fn trunc_f80(comptime dst_t: type, a: f80) dst_t {
     }
 
     const result align(@alignOf(dst_t)) = abs_result | @as(dst_rep_t, sign) << dst_bits - 16;
-    return @as(dst_t, @bitCast(result));
+    return @bitCast(result);
 }
 
 test {
diff --git a/lib/compiler_rt/truncsfhf2.zig b/lib/compiler_rt/truncsfhf2.zig
index c747d8e37a..ffc74b75e9 100644
--- a/lib/compiler_rt/truncsfhf2.zig
+++ b/lib/compiler_rt/truncsfhf2.zig
@@ -13,13 +13,13 @@ comptime {
 }
 
 pub fn __truncsfhf2(a: f32) callconv(.C) common.F16T(f32) {
-    return @as(common.F16T(f32), @bitCast(truncf(f16, f32, a)));
+    return @bitCast(truncf(f16, f32, a));
 }
 
 fn __gnu_f2h_ieee(a: f32) callconv(.C) common.F16T(f32) {
-    return @as(common.F16T(f32), @bitCast(truncf(f16, f32, a)));
+    return @bitCast(truncf(f16, f32, a));
 }
 
 fn __aeabi_f2h(a: f32) callconv(.AAPCS) u16 {
-    return @as(common.F16T(f32), @bitCast(truncf(f16, f32, a)));
+    return @bitCast(truncf(f16, f32, a));
 }
diff --git a/lib/compiler_rt/trunctfhf2.zig b/lib/compiler_rt/trunctfhf2.zig
index 9c7a3b6dba..6107b6ba49 100644
--- a/lib/compiler_rt/trunctfhf2.zig
+++ b/lib/compiler_rt/trunctfhf2.zig
@@ -8,5 +8,5 @@ comptime {
 }
 
 pub fn __trunctfhf2(a: f128) callconv(.C) common.F16T(f128) {
-    return @as(common.F16T(f128), @bitCast(truncf(f16, f128, a)));
+    return @bitCast(truncf(f16, f128, a));
 }
diff --git a/lib/compiler_rt/truncxfhf2.zig b/lib/compiler_rt/truncxfhf2.zig
index 6dbeca7637..5dbd161b84 100644
--- a/lib/compiler_rt/truncxfhf2.zig
+++ b/lib/compiler_rt/truncxfhf2.zig
@@ -8,5 +8,5 @@ comptime {
 }
 
 fn __truncxfhf2(a: f80) callconv(.C) common.F16T(f80) {
-    return @as(common.F16T(f80), @bitCast(trunc_f80(f16, a)));
+    return @bitCast(trunc_f80(f16, a));
 }
diff --git a/lib/compiler_rt/udivmod.zig b/lib/compiler_rt/udivmod.zig
index 0e2a7d9ed1..c9dd132b1b 100644
--- a/lib/compiler_rt/udivmod.zig
+++ b/lib/compiler_rt/udivmod.zig
@@ -21,11 +21,11 @@ fn divwide_generic(comptime T: type, _u1: T, _u0: T, v_: T, r: *T) T {
     var un64: T = undefined;
     var un10: T = undefined;
 
-    const s = @as(Log2Int(T), @intCast(@clz(v)));
+    const s: Log2Int(T) = @intCast(@clz(v));
     if (s > 0) {
         // Normalize divisor
         v <<= s;
-        un64 = (_u1 << s) | (_u0 >> @as(Log2Int(T), @intCast((@bitSizeOf(T) - @as(T, @intCast(s))))));
+        un64 = (_u1 << s) | (_u0 >> @intCast((@bitSizeOf(T) - @as(T, @intCast(s)))));
         un10 = _u0 << s;
     } else {
         // Avoid undefined behavior of (u0 >> @bitSizeOf(T))
@@ -101,8 +101,8 @@ pub fn udivmod(comptime T: type, a_: T, b_: T, maybe_rem: ?*T) T {
         return 0;
     }
 
-    var a = @as([2]HalfT, @bitCast(a_));
-    var b = @as([2]HalfT, @bitCast(b_));
+    var a: [2]HalfT = @bitCast(a_);
+    var b: [2]HalfT = @bitCast(b_);
     var q: [2]HalfT = undefined;
     var r: [2]HalfT = undefined;
 
@@ -119,16 +119,16 @@ pub fn udivmod(comptime T: type, a_: T, b_: T, maybe_rem: ?*T) T {
             q[lo] = divwide(HalfT, a[hi] % b[lo], a[lo], b[lo], &r[lo]);
         }
         if (maybe_rem) |rem| {
-            rem.* = @as(T, @bitCast(r));
+            rem.* = @bitCast(r);
         }
-        return @as(T, @bitCast(q));
+        return @bitCast(q);
     }
 
     // 0 <= shift <= 63
     var shift: Log2Int(T) = @clz(b[hi]) - @clz(a[hi]);
-    var af = @as(T, @bitCast(a));
+    var af: T = @bitCast(a);
     var bf = @as(T, @bitCast(b)) << shift;
-    q = @as([2]HalfT, @bitCast(@as(T, 0)));
+    q = @bitCast(@as(T, 0));
 
     for (0..shift + 1) |_| {
         q[lo] <<= 1;
@@ -138,12 +138,12 @@ pub fn udivmod(comptime T: type, a_: T, b_: T, maybe_rem: ?*T) T {
         //     q[lo] |= 1;
         // }
         const s = @as(SignedT, @bitCast(bf -% af -% 1)) >> (@bitSizeOf(T) - 1);
-        q[lo] |= @as(HalfT, @intCast(s & 1));
+        q[lo] |= @intCast(s & 1);
         af -= bf & @as(T, @bitCast(s));
         bf >>= 1;
     }
     if (maybe_rem) |rem| {
-        rem.* = @as(T, @bitCast(af));
+        rem.* = @bitCast(af);
     }
-    return @as(T, @bitCast(q));
+    return @bitCast(q);
 }
diff --git a/lib/compiler_rt/udivmodti4.zig b/lib/compiler_rt/udivmodti4.zig
index 8f4748fa7d..bb98819dcc 100644
--- a/lib/compiler_rt/udivmodti4.zig
+++ b/lib/compiler_rt/udivmodti4.zig
@@ -20,7 +20,7 @@ pub fn __udivmodti4(a: u128, b: u128, maybe_rem: ?*u128) callconv(.C) u128 {
 const v2u64 = @Vector(2, u64);
 
 fn __udivmodti4_windows_x86_64(a: v2u64, b: v2u64, maybe_rem: ?*u128) callconv(.C) v2u64 {
-    return @as(v2u64, @bitCast(udivmod(u128, @as(u128, @bitCast(a)), @as(u128, @bitCast(b)), maybe_rem)));
+    return @bitCast(udivmod(u128, @bitCast(a), @bitCast(b), maybe_rem));
 }
 
 test {
diff --git a/lib/compiler_rt/udivti3.zig b/lib/compiler_rt/udivti3.zig
index 1205d65336..f89868dc48 100644
--- a/lib/compiler_rt/udivti3.zig
+++ b/lib/compiler_rt/udivti3.zig
@@ -20,5 +20,5 @@ pub fn __udivti3(a: u128, b: u128) callconv(.C) u128 {
 const v2u64 = @Vector(2, u64);
 
 fn __udivti3_windows_x86_64(a: v2u64, b: v2u64) callconv(.C) v2u64 {
-    return @as(v2u64, @bitCast(udivmod(u128, @as(u128, @bitCast(a)), @as(u128, @bitCast(b)), null)));
+    return @bitCast(udivmod(u128, @bitCast(a), @bitCast(b), null));
 }
diff --git a/lib/compiler_rt/umodti3.zig b/lib/compiler_rt/umodti3.zig
index 41de97d2bb..ea2db7ee0b 100644
--- a/lib/compiler_rt/umodti3.zig
+++ b/lib/compiler_rt/umodti3.zig
@@ -23,6 +23,6 @@ const v2u64 = @Vector(2, u64);
 
 fn __umodti3_windows_x86_64(a: v2u64, b: v2u64) callconv(.C) v2u64 {
     var r: u128 = undefined;
-    _ = udivmod(u128, @as(u128, @bitCast(a)), @as(u128, @bitCast(b)), &r);
-    return @as(v2u64, @bitCast(r));
+    _ = udivmod(u128, @bitCast(a), @bitCast(b), &r);
+    return @bitCast(r);
 }