Merge pull request #16163 from mlugg/feat/builtins-infer-dest-ty

Infer destination type of cast builtins using result type

1 files changed, 205 insertions, 205 deletions

diff --git a/src/InternPool.zig b/src/InternPool.zig
index 33d4108e6d..1a89c239ef 100644
--- a/src/InternPool.zig
+++ b/src/InternPool.zig
@@ -80,7 +80,7 @@ const KeyAdapter = struct {
 
     pub fn eql(ctx: @This(), a: Key, b_void: void, b_map_index: usize) bool {
         _ = b_void;
-        return ctx.intern_pool.indexToKey(@enumFromInt(Index, b_map_index)).eql(a, ctx.intern_pool);
+        return ctx.intern_pool.indexToKey(@as(Index, @enumFromInt(b_map_index))).eql(a, ctx.intern_pool);
     }
 
     pub fn hash(ctx: @This(), a: Key) u32 {
@@ -95,7 +95,7 @@ pub const OptionalMapIndex = enum(u32) {
 
     pub fn unwrap(oi: OptionalMapIndex) ?MapIndex {
         if (oi == .none) return null;
-        return @enumFromInt(MapIndex, @intFromEnum(oi));
+        return @as(MapIndex, @enumFromInt(@intFromEnum(oi)));
     }
 };
 
@@ -104,7 +104,7 @@ pub const MapIndex = enum(u32) {
     _,
 
     pub fn toOptional(i: MapIndex) OptionalMapIndex {
-        return @enumFromInt(OptionalMapIndex, @intFromEnum(i));
+        return @as(OptionalMapIndex, @enumFromInt(@intFromEnum(i)));
     }
 };
 
@@ -114,7 +114,7 @@ pub const RuntimeIndex = enum(u32) {
     _,
 
     pub fn increment(ri: *RuntimeIndex) void {
-        ri.* = @enumFromInt(RuntimeIndex, @intFromEnum(ri.*) + 1);
+        ri.* = @as(RuntimeIndex, @enumFromInt(@intFromEnum(ri.*) + 1));
     }
 };
 
@@ -130,11 +130,11 @@ pub const NullTerminatedString = enum(u32) {
     _,
 
     pub fn toString(self: NullTerminatedString) String {
-        return @enumFromInt(String, @intFromEnum(self));
+        return @as(String, @enumFromInt(@intFromEnum(self)));
     }
 
     pub fn toOptional(self: NullTerminatedString) OptionalNullTerminatedString {
-        return @enumFromInt(OptionalNullTerminatedString, @intFromEnum(self));
+        return @as(OptionalNullTerminatedString, @enumFromInt(@intFromEnum(self)));
     }
 
     const Adapter = struct {
@@ -196,7 +196,7 @@ pub const OptionalNullTerminatedString = enum(u32) {
 
     pub fn unwrap(oi: OptionalNullTerminatedString) ?NullTerminatedString {
         if (oi == .none) return null;
-        return @enumFromInt(NullTerminatedString, @intFromEnum(oi));
+        return @as(NullTerminatedString, @enumFromInt(@intFromEnum(oi)));
     }
 };
 
@@ -282,7 +282,7 @@ pub const Key = union(enum) {
             const map = &ip.maps.items[@intFromEnum(self.names_map.unwrap().?)];
             const adapter: NullTerminatedString.Adapter = .{ .strings = self.names };
             const field_index = map.getIndexAdapted(name, adapter) orelse return null;
-            return @intCast(u32, field_index);
+            return @as(u32, @intCast(field_index));
         }
     };
 
@@ -420,7 +420,7 @@ pub const Key = union(enum) {
             const map = &ip.maps.items[@intFromEnum(self.names_map.unwrap().?)];
             const adapter: NullTerminatedString.Adapter = .{ .strings = self.names };
             const field_index = map.getIndexAdapted(name, adapter) orelse return null;
-            return @intCast(u32, field_index);
+            return @as(u32, @intCast(field_index));
         }
 
         /// Look up field index based on tag value.
@@ -440,7 +440,7 @@ pub const Key = union(enum) {
                 const map = &ip.maps.items[@intFromEnum(values_map)];
                 const adapter: Index.Adapter = .{ .indexes = self.values };
                 const field_index = map.getIndexAdapted(int_tag_val, adapter) orelse return null;
-                return @intCast(u32, field_index);
+                return @as(u32, @intCast(field_index));
             }
             // Auto-numbered enum. Convert `int_tag_val` to field index.
             const field_index = switch (ip.indexToKey(int_tag_val).int.storage) {
@@ -511,12 +511,12 @@ pub const Key = union(enum) {
 
         pub fn paramIsComptime(self: @This(), i: u5) bool {
             assert(i < self.param_types.len);
-            return @truncate(u1, self.comptime_bits >> i) != 0;
+            return @as(u1, @truncate(self.comptime_bits >> i)) != 0;
         }
 
         pub fn paramIsNoalias(self: @This(), i: u5) bool {
             assert(i < self.param_types.len);
-            return @truncate(u1, self.noalias_bits >> i) != 0;
+            return @as(u1, @truncate(self.noalias_bits >> i)) != 0;
         }
     };
 
@@ -685,7 +685,7 @@ pub const Key = union(enum) {
     };
 
     pub fn hash32(key: Key, ip: *const InternPool) u32 {
-        return @truncate(u32, key.hash64(ip));
+        return @as(u32, @truncate(key.hash64(ip)));
     }
 
     pub fn hash64(key: Key, ip: *const InternPool) u64 {
@@ -767,7 +767,7 @@ pub const Key = union(enum) {
                 switch (float.storage) {
                     inline else => |val| std.hash.autoHash(
                         &hasher,
-                        @bitCast(std.meta.Int(.unsigned, @bitSizeOf(@TypeOf(val))), val),
+                        @as(std.meta.Int(.unsigned, @bitSizeOf(@TypeOf(val))), @bitCast(val)),
                     ),
                 }
                 return hasher.final();
@@ -812,18 +812,18 @@ pub const Key = union(enum) {
 
                 if (child == .u8_type) {
                     switch (aggregate.storage) {
-                        .bytes => |bytes| for (bytes[0..@intCast(usize, len)]) |byte| {
+                        .bytes => |bytes| for (bytes[0..@as(usize, @intCast(len))]) |byte| {
                             std.hash.autoHash(&hasher, KeyTag.int);
                             std.hash.autoHash(&hasher, byte);
                         },
-                        .elems => |elems| for (elems[0..@intCast(usize, len)]) |elem| {
+                        .elems => |elems| for (elems[0..@as(usize, @intCast(len))]) |elem| {
                             const elem_key = ip.indexToKey(elem);
                             std.hash.autoHash(&hasher, @as(KeyTag, elem_key));
                             switch (elem_key) {
                                 .undef => {},
                                 .int => |int| std.hash.autoHash(
                                     &hasher,
-                                    @intCast(u8, int.storage.u64),
+                                    @as(u8, @intCast(int.storage.u64)),
                                 ),
                                 else => unreachable,
                             }
@@ -837,7 +837,7 @@ pub const Key = union(enum) {
                                     .undef => {},
                                     .int => |int| std.hash.autoHash(
                                         &hasher,
-                                        @intCast(u8, int.storage.u64),
+                                        @as(u8, @intCast(int.storage.u64)),
                                     ),
                                     else => unreachable,
                                 }
@@ -849,7 +849,7 @@ pub const Key = union(enum) {
 
                 switch (aggregate.storage) {
                     .bytes => unreachable,
-                    .elems => |elems| for (elems[0..@intCast(usize, len)]) |elem|
+                    .elems => |elems| for (elems[0..@as(usize, @intCast(len))]) |elem|
                         std.hash.autoHash(&hasher, elem),
                     .repeated_elem => |elem| {
                         var remaining = len;
@@ -1061,10 +1061,10 @@ pub const Key = union(enum) {
                     // These are strange: we'll sometimes represent them as f128, even if the
                     // underlying type is smaller. f80 is an exception: see float_c_longdouble_f80.
                     const a_val = switch (a_info.storage) {
-                        inline else => |val| @floatCast(f128, val),
+                        inline else => |val| @as(f128, @floatCast(val)),
                     };
                     const b_val = switch (b_info.storage) {
-                        inline else => |val| @floatCast(f128, val),
+                        inline else => |val| @as(f128, @floatCast(val)),
                     };
                     return a_val == b_val;
                 }
@@ -1092,7 +1092,7 @@ pub const Key = union(enum) {
                 const len = ip.aggregateTypeLen(a_info.ty);
                 const StorageTag = @typeInfo(Key.Aggregate.Storage).Union.tag_type.?;
                 if (@as(StorageTag, a_info.storage) != @as(StorageTag, b_info.storage)) {
-                    for (0..@intCast(usize, len)) |elem_index| {
+                    for (0..@as(usize, @intCast(len))) |elem_index| {
                         const a_elem = switch (a_info.storage) {
                             .bytes => |bytes| ip.getIfExists(.{ .int = .{
                                 .ty = .u8_type,
@@ -1119,16 +1119,16 @@ pub const Key = union(enum) {
                         const b_bytes = b_info.storage.bytes;
                         return std.mem.eql(
                             u8,
-                            a_bytes[0..@intCast(usize, len)],
-                            b_bytes[0..@intCast(usize, len)],
+                            a_bytes[0..@as(usize, @intCast(len))],
+                            b_bytes[0..@as(usize, @intCast(len))],
                         );
                     },
                     .elems => |a_elems| {
                         const b_elems = b_info.storage.elems;
                         return std.mem.eql(
                             Index,
-                            a_elems[0..@intCast(usize, len)],
-                            b_elems[0..@intCast(usize, len)],
+                            a_elems[0..@as(usize, @intCast(len))],
+                            b_elems[0..@as(usize, @intCast(len))],
                         );
                     },
                     .repeated_elem => |a_elem| {
@@ -2291,7 +2291,7 @@ pub const Alignment = enum(u6) {
     pub fn fromByteUnits(n: u64) Alignment {
         if (n == 0) return .none;
         assert(std.math.isPowerOfTwo(n));
-        return @enumFromInt(Alignment, @ctz(n));
+        return @as(Alignment, @enumFromInt(@ctz(n)));
     }
 
     pub fn fromNonzeroByteUnits(n: u64) Alignment {
@@ -2368,11 +2368,11 @@ pub const PackedU64 = packed struct(u64) {
     b: u32,
 
     pub fn get(x: PackedU64) u64 {
-        return @bitCast(u64, x);
+        return @as(u64, @bitCast(x));
     }
 
     pub fn init(x: u64) PackedU64 {
-        return @bitCast(PackedU64, x);
+        return @as(PackedU64, @bitCast(x));
     }
 };
 
@@ -2435,14 +2435,14 @@ pub const Float64 = struct {
 
     pub fn get(self: Float64) f64 {
         const int_bits = @as(u64, self.piece0) | (@as(u64, self.piece1) << 32);
-        return @bitCast(f64, int_bits);
+        return @as(f64, @bitCast(int_bits));
     }
 
     fn pack(val: f64) Float64 {
-        const bits = @bitCast(u64, val);
+        const bits = @as(u64, @bitCast(val));
         return .{
-            .piece0 = @truncate(u32, bits),
-            .piece1 = @truncate(u32, bits >> 32),
+            .piece0 = @as(u32, @truncate(bits)),
+            .piece1 = @as(u32, @truncate(bits >> 32)),
         };
     }
 };
@@ -2457,15 +2457,15 @@ pub const Float80 = struct {
         const int_bits = @as(u80, self.piece0) |
             (@as(u80, self.piece1) << 32) |
             (@as(u80, self.piece2) << 64);
-        return @bitCast(f80, int_bits);
+        return @as(f80, @bitCast(int_bits));
     }
 
     fn pack(val: f80) Float80 {
-        const bits = @bitCast(u80, val);
+        const bits = @as(u80, @bitCast(val));
         return .{
-            .piece0 = @truncate(u32, bits),
-            .piece1 = @truncate(u32, bits >> 32),
-            .piece2 = @truncate(u16, bits >> 64),
+            .piece0 = @as(u32, @truncate(bits)),
+            .piece1 = @as(u32, @truncate(bits >> 32)),
+            .piece2 = @as(u16, @truncate(bits >> 64)),
         };
     }
 };
@@ -2482,16 +2482,16 @@ pub const Float128 = struct {
             (@as(u128, self.piece1) << 32) |
             (@as(u128, self.piece2) << 64) |
             (@as(u128, self.piece3) << 96);
-        return @bitCast(f128, int_bits);
+        return @as(f128, @bitCast(int_bits));
     }
 
     fn pack(val: f128) Float128 {
-        const bits = @bitCast(u128, val);
+        const bits = @as(u128, @bitCast(val));
         return .{
-            .piece0 = @truncate(u32, bits),
-            .piece1 = @truncate(u32, bits >> 32),
-            .piece2 = @truncate(u32, bits >> 64),
-            .piece3 = @truncate(u32, bits >> 96),
+            .piece0 = @as(u32, @truncate(bits)),
+            .piece1 = @as(u32, @truncate(bits >> 32)),
+            .piece2 = @as(u32, @truncate(bits >> 64)),
+            .piece3 = @as(u32, @truncate(bits >> 96)),
         };
     }
 };
@@ -2575,13 +2575,13 @@ pub fn indexToKey(ip: *const InternPool, index: Index) Key {
         .type_int_signed => .{
             .int_type = .{
                 .signedness = .signed,
-                .bits = @intCast(u16, data),
+                .bits = @as(u16, @intCast(data)),
             },
         },
         .type_int_unsigned => .{
             .int_type = .{
                 .signedness = .unsigned,
-                .bits = @intCast(u16, data),
+                .bits = @as(u16, @intCast(data)),
             },
         },
         .type_array_big => {
@@ -2600,8 +2600,8 @@ pub fn indexToKey(ip: *const InternPool, index: Index) Key {
                 .sentinel = .none,
             } };
         },
-        .simple_type => .{ .simple_type = @enumFromInt(SimpleType, data) },
-        .simple_value => .{ .simple_value = @enumFromInt(SimpleValue, data) },
+        .simple_type => .{ .simple_type = @as(SimpleType, @enumFromInt(data)) },
+        .simple_value => .{ .simple_value = @as(SimpleValue, @enumFromInt(data)) },
 
         .type_vector => {
             const vector_info = ip.extraData(Vector, data);
@@ -2620,8 +2620,8 @@ pub fn indexToKey(ip: *const InternPool, index: Index) Key {
             return .{ .ptr_type = ptr_info };
         },
 
-        .type_optional => .{ .opt_type = @enumFromInt(Index, data) },
-        .type_anyframe => .{ .anyframe_type = @enumFromInt(Index, data) },
+        .type_optional => .{ .opt_type = @as(Index, @enumFromInt(data)) },
+        .type_anyframe => .{ .anyframe_type = @as(Index, @enumFromInt(data)) },
 
         .type_error_union => .{ .error_union_type = ip.extraData(Key.ErrorUnionType, data) },
         .type_error_set => {
@@ -2629,17 +2629,17 @@ pub fn indexToKey(ip: *const InternPool, index: Index) Key {
             const names_len = error_set.data.names_len;
             const names = ip.extra.items[error_set.end..][0..names_len];
             return .{ .error_set_type = .{
-                .names = @ptrCast([]const NullTerminatedString, names),
+                .names = @as([]const NullTerminatedString, @ptrCast(names)),
                 .names_map = error_set.data.names_map.toOptional(),
             } };
         },
         .type_inferred_error_set => .{
-            .inferred_error_set_type = @enumFromInt(Module.Fn.InferredErrorSet.Index, data),
+            .inferred_error_set_type = @as(Module.Fn.InferredErrorSet.Index, @enumFromInt(data)),
         },
 
         .type_opaque => .{ .opaque_type = ip.extraData(Key.OpaqueType, data) },
         .type_struct => {
-            const struct_index = @enumFromInt(Module.Struct.OptionalIndex, data);
+            const struct_index = @as(Module.Struct.OptionalIndex, @enumFromInt(data));
             const namespace = if (struct_index.unwrap()) |i|
                 ip.structPtrConst(i).namespace.toOptional()
             else
@@ -2651,7 +2651,7 @@ pub fn indexToKey(ip: *const InternPool, index: Index) Key {
         },
         .type_struct_ns => .{ .struct_type = .{
             .index = .none,
-            .namespace = @enumFromInt(Module.Namespace.Index, data).toOptional(),
+            .namespace = @as(Module.Namespace.Index, @enumFromInt(data)).toOptional(),
         } },
 
         .type_struct_anon => {
@@ -2661,9 +2661,9 @@ pub fn indexToKey(ip: *const InternPool, index: Index) Key {
             const values = ip.extra.items[type_struct_anon.end + fields_len ..][0..fields_len];
             const names = ip.extra.items[type_struct_anon.end + 2 * fields_len ..][0..fields_len];
             return .{ .anon_struct_type = .{
-                .types = @ptrCast([]const Index, types),
-                .values = @ptrCast([]const Index, values),
-                .names = @ptrCast([]const NullTerminatedString, names),
+                .types = @as([]const Index, @ptrCast(types)),
+                .values = @as([]const Index, @ptrCast(values)),
+                .names = @as([]const NullTerminatedString, @ptrCast(names)),
             } };
         },
         .type_tuple_anon => {
@@ -2672,30 +2672,30 @@ pub fn indexToKey(ip: *const InternPool, index: Index) Key {
             const types = ip.extra.items[type_struct_anon.end..][0..fields_len];
             const values = ip.extra.items[type_struct_anon.end + fields_len ..][0..fields_len];
             return .{ .anon_struct_type = .{
-                .types = @ptrCast([]const Index, types),
-                .values = @ptrCast([]const Index, values),
+                .types = @as([]const Index, @ptrCast(types)),
+                .values = @as([]const Index, @ptrCast(values)),
                 .names = &.{},
             } };
         },
 
         .type_union_untagged => .{ .union_type = .{
-            .index = @enumFromInt(Module.Union.Index, data),
+            .index = @as(Module.Union.Index, @enumFromInt(data)),
             .runtime_tag = .none,
         } },
         .type_union_tagged => .{ .union_type = .{
-            .index = @enumFromInt(Module.Union.Index, data),
+            .index = @as(Module.Union.Index, @enumFromInt(data)),
             .runtime_tag = .tagged,
         } },
         .type_union_safety => .{ .union_type = .{
-            .index = @enumFromInt(Module.Union.Index, data),
+            .index = @as(Module.Union.Index, @enumFromInt(data)),
             .runtime_tag = .safety,
         } },
 
         .type_enum_auto => {
             const enum_auto = ip.extraDataTrail(EnumAuto, data);
-            const names = @ptrCast(
+            const names = @as(
                 []const NullTerminatedString,
-                ip.extra.items[enum_auto.end..][0..enum_auto.data.fields_len],
+                @ptrCast(ip.extra.items[enum_auto.end..][0..enum_auto.data.fields_len]),
             );
             return .{ .enum_type = .{
                 .decl = enum_auto.data.decl,
@@ -2712,10 +2712,10 @@ pub fn indexToKey(ip: *const InternPool, index: Index) Key {
         .type_enum_nonexhaustive => ip.indexToKeyEnum(data, .nonexhaustive),
         .type_function => .{ .func_type = ip.indexToKeyFuncType(data) },
 
-        .undef => .{ .undef = @enumFromInt(Index, data) },
+        .undef => .{ .undef = @as(Index, @enumFromInt(data)) },
         .runtime_value => .{ .runtime_value = ip.extraData(Tag.TypeValue, data) },
         .opt_null => .{ .opt = .{
-            .ty = @enumFromInt(Index, data),
+            .ty = @as(Index, @enumFromInt(data)),
             .val = .none,
         } },
         .opt_payload => {
@@ -2877,7 +2877,7 @@ pub fn indexToKey(ip: *const InternPool, index: Index) Key {
         } },
         .int_i32 => .{ .int = .{
             .ty = .i32_type,
-            .storage = .{ .i64 = @bitCast(i32, data) },
+            .storage = .{ .i64 = @as(i32, @bitCast(data)) },
         } },
         .int_usize => .{ .int = .{
             .ty = .usize_type,
@@ -2889,7 +2889,7 @@ pub fn indexToKey(ip: *const InternPool, index: Index) Key {
         } },
         .int_comptime_int_i32 => .{ .int = .{
             .ty = .comptime_int_type,
-            .storage = .{ .i64 = @bitCast(i32, data) },
+            .storage = .{ .i64 = @as(i32, @bitCast(data)) },
         } },
         .int_positive => ip.indexToKeyBigInt(data, true),
         .int_negative => ip.indexToKeyBigInt(data, false),
@@ -2913,11 +2913,11 @@ pub fn indexToKey(ip: *const InternPool, index: Index) Key {
         },
         .float_f16 => .{ .float = .{
             .ty = .f16_type,
-            .storage = .{ .f16 = @bitCast(f16, @intCast(u16, data)) },
+            .storage = .{ .f16 = @as(f16, @bitCast(@as(u16, @intCast(data)))) },
         } },
         .float_f32 => .{ .float = .{
             .ty = .f32_type,
-            .storage = .{ .f32 = @bitCast(f32, data) },
+            .storage = .{ .f32 = @as(f32, @bitCast(data)) },
         } },
         .float_f64 => .{ .float = .{
             .ty = .f64_type,
@@ -2959,13 +2959,13 @@ pub fn indexToKey(ip: *const InternPool, index: Index) Key {
         .extern_func => .{ .extern_func = ip.extraData(Tag.ExternFunc, data) },
         .func => .{ .func = ip.extraData(Tag.Func, data) },
         .only_possible_value => {
-            const ty = @enumFromInt(Index, data);
+            const ty = @as(Index, @enumFromInt(data));
             const ty_item = ip.items.get(@intFromEnum(ty));
             return switch (ty_item.tag) {
                 .type_array_big => {
-                    const sentinel = @ptrCast(
+                    const sentinel = @as(
                         *const [1]Index,
-                        &ip.extra.items[ty_item.data + std.meta.fieldIndex(Array, "sentinel").?],
+                        @ptrCast(&ip.extra.items[ty_item.data + std.meta.fieldIndex(Array, "sentinel").?]),
                     );
                     return .{ .aggregate = .{
                         .ty = ty,
@@ -2994,7 +2994,7 @@ pub fn indexToKey(ip: *const InternPool, index: Index) Key {
                     const values = ip.extra.items[type_struct_anon.end + fields_len ..][0..fields_len];
                     return .{ .aggregate = .{
                         .ty = ty,
-                        .storage = .{ .elems = @ptrCast([]const Index, values) },
+                        .storage = .{ .elems = @as([]const Index, @ptrCast(values)) },
                     } };
                 },
 
@@ -3010,7 +3010,7 @@ pub fn indexToKey(ip: *const InternPool, index: Index) Key {
         },
         .bytes => {
             const extra = ip.extraData(Bytes, data);
-            const len = @intCast(u32, ip.aggregateTypeLenIncludingSentinel(extra.ty));
+            const len = @as(u32, @intCast(ip.aggregateTypeLenIncludingSentinel(extra.ty)));
             return .{ .aggregate = .{
                 .ty = extra.ty,
                 .storage = .{ .bytes = ip.string_bytes.items[@intFromEnum(extra.bytes)..][0..len] },
@@ -3018,8 +3018,8 @@ pub fn indexToKey(ip: *const InternPool, index: Index) Key {
         },
         .aggregate => {
             const extra = ip.extraDataTrail(Tag.Aggregate, data);
-            const len = @intCast(u32, ip.aggregateTypeLenIncludingSentinel(extra.data.ty));
-            const fields = @ptrCast([]const Index, ip.extra.items[extra.end..][0..len]);
+            const len = @as(u32, @intCast(ip.aggregateTypeLenIncludingSentinel(extra.data.ty)));
+            const fields = @as([]const Index, @ptrCast(ip.extra.items[extra.end..][0..len]));
             return .{ .aggregate = .{
                 .ty = extra.data.ty,
                 .storage = .{ .elems = fields },
@@ -3048,14 +3048,14 @@ pub fn indexToKey(ip: *const InternPool, index: Index) Key {
                 .val = .{ .payload = extra.val },
             } };
         },
-        .enum_literal => .{ .enum_literal = @enumFromInt(NullTerminatedString, data) },
+        .enum_literal => .{ .enum_literal = @as(NullTerminatedString, @enumFromInt(data)) },
         .enum_tag => .{ .enum_tag = ip.extraData(Tag.EnumTag, data) },
 
         .memoized_call => {
             const extra = ip.extraDataTrail(MemoizedCall, data);
             return .{ .memoized_call = .{
                 .func = extra.data.func,
-                .arg_values = @ptrCast([]const Index, ip.extra.items[extra.end..][0..extra.data.args_len]),
+                .arg_values = @as([]const Index, @ptrCast(ip.extra.items[extra.end..][0..extra.data.args_len])),
                 .result = extra.data.result,
             } };
         },
@@ -3064,9 +3064,9 @@ pub fn indexToKey(ip: *const InternPool, index: Index) Key {
 
 fn indexToKeyFuncType(ip: *const InternPool, data: u32) Key.FuncType {
     const type_function = ip.extraDataTrail(TypeFunction, data);
-    const param_types = @ptrCast(
+    const param_types = @as(
         []Index,
-        ip.extra.items[type_function.end..][0..type_function.data.params_len],
+        @ptrCast(ip.extra.items[type_function.end..][0..type_function.data.params_len]),
     );
     return .{
         .param_types = param_types,
@@ -3087,13 +3087,13 @@ fn indexToKeyFuncType(ip: *const InternPool, data: u32) Key.FuncType {
 
 fn indexToKeyEnum(ip: *const InternPool, data: u32, tag_mode: Key.EnumType.TagMode) Key {
     const enum_explicit = ip.extraDataTrail(EnumExplicit, data);
-    const names = @ptrCast(
+    const names = @as(
         []const NullTerminatedString,
-        ip.extra.items[enum_explicit.end..][0..enum_explicit.data.fields_len],
+        @ptrCast(ip.extra.items[enum_explicit.end..][0..enum_explicit.data.fields_len]),
     );
-    const values = if (enum_explicit.data.values_map != .none) @ptrCast(
+    const values = if (enum_explicit.data.values_map != .none) @as(
         []const Index,
-        ip.extra.items[enum_explicit.end + names.len ..][0..enum_explicit.data.fields_len],
+        @ptrCast(ip.extra.items[enum_explicit.end + names.len ..][0..enum_explicit.data.fields_len]),
     ) else &[0]Index{};
 
     return .{ .enum_type = .{
@@ -3122,7 +3122,7 @@ fn indexToKeyBigInt(ip: *const InternPool, limb_index: u32, positive: bool) Key
 pub fn get(ip: *InternPool, gpa: Allocator, key: Key) Allocator.Error!Index {
     const adapter: KeyAdapter = .{ .intern_pool = ip };
     const gop = try ip.map.getOrPutAdapted(gpa, key, adapter);
-    if (gop.found_existing) return @enumFromInt(Index, gop.index);
+    if (gop.found_existing) return @as(Index, @enumFromInt(gop.index));
     try ip.items.ensureUnusedCapacity(gpa, 1);
     switch (key) {
         .int_type => |int_type| {
@@ -3150,7 +3150,7 @@ pub fn get(ip: *InternPool, gpa: Allocator, key: Key) Allocator.Error!Index {
                     .tag = .type_slice,
                     .data = @intFromEnum(ptr_type_index),
                 });
-                return @enumFromInt(Index, ip.items.len - 1);
+                return @as(Index, @enumFromInt(ip.items.len - 1));
             }
 
             var ptr_type_adjusted = ptr_type;
@@ -3174,7 +3174,7 @@ pub fn get(ip: *InternPool, gpa: Allocator, key: Key) Allocator.Error!Index {
                             .child = array_type.child,
                         }),
                     });
-                    return @enumFromInt(Index, ip.items.len - 1);
+                    return @as(Index, @enumFromInt(ip.items.len - 1));
                 }
             }
 
@@ -3223,7 +3223,7 @@ pub fn get(ip: *InternPool, gpa: Allocator, key: Key) Allocator.Error!Index {
             assert(std.sort.isSorted(NullTerminatedString, error_set_type.names, {}, NullTerminatedString.indexLessThan));
             const names_map = try ip.addMap(gpa);
             try addStringsToMap(ip, gpa, names_map, error_set_type.names);
-            const names_len = @intCast(u32, error_set_type.names.len);
+            const names_len = @as(u32, @intCast(error_set_type.names.len));
             try ip.extra.ensureUnusedCapacity(gpa, @typeInfo(ErrorSet).Struct.fields.len + names_len);
             ip.items.appendAssumeCapacity(.{
                 .tag = .type_error_set,
@@ -3232,7 +3232,7 @@ pub fn get(ip: *InternPool, gpa: Allocator, key: Key) Allocator.Error!Index {
                     .names_map = names_map,
                 }),
             });
-            ip.extra.appendSliceAssumeCapacity(@ptrCast([]const u32, error_set_type.names));
+            ip.extra.appendSliceAssumeCapacity(@as([]const u32, @ptrCast(error_set_type.names)));
         },
         .inferred_error_set_type => |ies_index| {
             ip.items.appendAssumeCapacity(.{
@@ -3284,7 +3284,7 @@ pub fn get(ip: *InternPool, gpa: Allocator, key: Key) Allocator.Error!Index {
             assert(anon_struct_type.types.len == anon_struct_type.values.len);
             for (anon_struct_type.types) |elem| assert(elem != .none);
 
-            const fields_len = @intCast(u32, anon_struct_type.types.len);
+            const fields_len = @as(u32, @intCast(anon_struct_type.types.len));
             if (anon_struct_type.names.len == 0) {
                 try ip.extra.ensureUnusedCapacity(
                     gpa,
@@ -3296,9 +3296,9 @@ pub fn get(ip: *InternPool, gpa: Allocator, key: Key) Allocator.Error!Index {
                         .fields_len = fields_len,
                     }),
                 });
-                ip.extra.appendSliceAssumeCapacity(@ptrCast([]const u32, anon_struct_type.types));
-                ip.extra.appendSliceAssumeCapacity(@ptrCast([]const u32, anon_struct_type.values));
-                return @enumFromInt(Index, ip.items.len - 1);
+                ip.extra.appendSliceAssumeCapacity(@as([]const u32, @ptrCast(anon_struct_type.types)));
+                ip.extra.appendSliceAssumeCapacity(@as([]const u32, @ptrCast(anon_struct_type.values)));
+                return @as(Index, @enumFromInt(ip.items.len - 1));
             }
 
             assert(anon_struct_type.names.len == anon_struct_type.types.len);
@@ -3313,10 +3313,10 @@ pub fn get(ip: *InternPool, gpa: Allocator, key: Key) Allocator.Error!Index {
                     .fields_len = fields_len,
                 }),
             });
-            ip.extra.appendSliceAssumeCapacity(@ptrCast([]const u32, anon_struct_type.types));
-            ip.extra.appendSliceAssumeCapacity(@ptrCast([]const u32, anon_struct_type.values));
-            ip.extra.appendSliceAssumeCapacity(@ptrCast([]const u32, anon_struct_type.names));
-            return @enumFromInt(Index, ip.items.len - 1);
+            ip.extra.appendSliceAssumeCapacity(@as([]const u32, @ptrCast(anon_struct_type.types)));
+            ip.extra.appendSliceAssumeCapacity(@as([]const u32, @ptrCast(anon_struct_type.values)));
+            ip.extra.appendSliceAssumeCapacity(@as([]const u32, @ptrCast(anon_struct_type.names)));
+            return @as(Index, @enumFromInt(ip.items.len - 1));
         },
 
         .union_type => |union_type| {
@@ -3348,7 +3348,7 @@ pub fn get(ip: *InternPool, gpa: Allocator, key: Key) Allocator.Error!Index {
                     const names_map = try ip.addMap(gpa);
                     try addStringsToMap(ip, gpa, names_map, enum_type.names);
 
-                    const fields_len = @intCast(u32, enum_type.names.len);
+                    const fields_len = @as(u32, @intCast(enum_type.names.len));
                     try ip.extra.ensureUnusedCapacity(gpa, @typeInfo(EnumAuto).Struct.fields.len +
                         fields_len);
                     ip.items.appendAssumeCapacity(.{
@@ -3361,8 +3361,8 @@ pub fn get(ip: *InternPool, gpa: Allocator, key: Key) Allocator.Error!Index {
                             .fields_len = fields_len,
                         }),
                     });
-                    ip.extra.appendSliceAssumeCapacity(@ptrCast([]const u32, enum_type.names));
-                    return @enumFromInt(Index, ip.items.len - 1);
+                    ip.extra.appendSliceAssumeCapacity(@as([]const u32, @ptrCast(enum_type.names)));
+                    return @as(Index, @enumFromInt(ip.items.len - 1));
                 },
                 .explicit => return finishGetEnum(ip, gpa, enum_type, .type_enum_explicit),
                 .nonexhaustive => return finishGetEnum(ip, gpa, enum_type, .type_enum_nonexhaustive),
@@ -3373,7 +3373,7 @@ pub fn get(ip: *InternPool, gpa: Allocator, key: Key) Allocator.Error!Index {
             assert(func_type.return_type != .none);
             for (func_type.param_types) |param_type| assert(param_type != .none);
 
-            const params_len = @intCast(u32, func_type.param_types.len);
+            const params_len = @as(u32, @intCast(func_type.param_types.len));
 
             try ip.extra.ensureUnusedCapacity(gpa, @typeInfo(TypeFunction).Struct.fields.len +
                 params_len);
@@ -3397,7 +3397,7 @@ pub fn get(ip: *InternPool, gpa: Allocator, key: Key) Allocator.Error!Index {
                     },
                 }),
             });
-            ip.extra.appendSliceAssumeCapacity(@ptrCast([]const u32, func_type.param_types));
+            ip.extra.appendSliceAssumeCapacity(@as([]const u32, @ptrCast(func_type.param_types)));
         },
 
         .variable => |variable| {
@@ -3559,7 +3559,7 @@ pub fn get(ip: *InternPool, gpa: Allocator, key: Key) Allocator.Error!Index {
                     });
                 },
             }
-            assert(ptr.ty == ip.indexToKey(@enumFromInt(Index, ip.items.len - 1)).ptr.ty);
+            assert(ptr.ty == ip.indexToKey(@as(Index, @enumFromInt(ip.items.len - 1))).ptr.ty);
         },
 
         .opt => |opt| {
@@ -3593,7 +3593,7 @@ pub fn get(ip: *InternPool, gpa: Allocator, key: Key) Allocator.Error!Index {
                             .lazy_ty = lazy_ty,
                         }),
                     });
-                    return @enumFromInt(Index, ip.items.len - 1);
+                    return @as(Index, @enumFromInt(ip.items.len - 1));
                 },
             }
             switch (int.ty) {
@@ -3608,7 +3608,7 @@ pub fn get(ip: *InternPool, gpa: Allocator, key: Key) Allocator.Error!Index {
                     inline .u64, .i64 => |x| {
                         ip.items.appendAssumeCapacity(.{
                             .tag = .int_u8,
-                            .data = @intCast(u8, x),
+                            .data = @as(u8, @intCast(x)),
                         });
                         break :b;
                     },
@@ -3625,7 +3625,7 @@ pub fn get(ip: *InternPool, gpa: Allocator, key: Key) Allocator.Error!Index {
                     inline .u64, .i64 => |x| {
                         ip.items.appendAssumeCapacity(.{
                             .tag = .int_u16,
-                            .data = @intCast(u16, x),
+                            .data = @as(u16, @intCast(x)),
                         });
                         break :b;
                     },
@@ -3642,7 +3642,7 @@ pub fn get(ip: *InternPool, gpa: Allocator, key: Key) Allocator.Error!Index {
                     inline .u64, .i64 => |x| {
                         ip.items.appendAssumeCapacity(.{
                             .tag = .int_u32,
-                            .data = @intCast(u32, x),
+                            .data = @as(u32, @intCast(x)),
                         });
                         break :b;
                     },
@@ -3653,14 +3653,14 @@ pub fn get(ip: *InternPool, gpa: Allocator, key: Key) Allocator.Error!Index {
                         const casted = big_int.to(i32) catch unreachable;
                         ip.items.appendAssumeCapacity(.{
                             .tag = .int_i32,
-                            .data = @bitCast(u32, casted),
+                            .data = @as(u32, @bitCast(casted)),
                         });
                         break :b;
                     },
                     inline .u64, .i64 => |x| {
                         ip.items.appendAssumeCapacity(.{
                             .tag = .int_i32,
-                            .data = @bitCast(u32, @intCast(i32, x)),
+                            .data = @as(u32, @bitCast(@as(i32, @intCast(x)))),
                         });
                         break :b;
                     },
@@ -3699,7 +3699,7 @@ pub fn get(ip: *InternPool, gpa: Allocator, key: Key) Allocator.Error!Index {
                         if (big_int.to(i32)) |casted| {
                             ip.items.appendAssumeCapacity(.{
                                 .tag = .int_comptime_int_i32,
-                                .data = @bitCast(u32, casted),
+                                .data = @as(u32, @bitCast(casted)),
                             });
                             break :b;
                         } else |_| {}
@@ -3715,7 +3715,7 @@ pub fn get(ip: *InternPool, gpa: Allocator, key: Key) Allocator.Error!Index {
                         if (std.math.cast(i32, x)) |casted| {
                             ip.items.appendAssumeCapacity(.{
                                 .tag = .int_comptime_int_i32,
-                                .data = @bitCast(u32, casted),
+                                .data = @as(u32, @bitCast(casted)),
                             });
                             break :b;
                         }
@@ -3734,7 +3734,7 @@ pub fn get(ip: *InternPool, gpa: Allocator, key: Key) Allocator.Error!Index {
                                 .value = casted,
                             }),
                         });
-                        return @enumFromInt(Index, ip.items.len - 1);
+                        return @as(Index, @enumFromInt(ip.items.len - 1));
                     } else |_| {}
 
                     const tag: Tag = if (big_int.positive) .int_positive else .int_negative;
@@ -3749,7 +3749,7 @@ pub fn get(ip: *InternPool, gpa: Allocator, key: Key) Allocator.Error!Index {
                                 .value = casted,
                             }),
                         });
-                        return @enumFromInt(Index, ip.items.len - 1);
+                        return @as(Index, @enumFromInt(ip.items.len - 1));
                     }
 
                     var buf: [2]Limb = undefined;
@@ -3816,11 +3816,11 @@ pub fn get(ip: *InternPool, gpa: Allocator, key: Key) Allocator.Error!Index {
             switch (float.ty) {
                 .f16_type => ip.items.appendAssumeCapacity(.{
                     .tag = .float_f16,
-                    .data = @bitCast(u16, float.storage.f16),
+                    .data = @as(u16, @bitCast(float.storage.f16)),
                 }),
                 .f32_type => ip.items.appendAssumeCapacity(.{
                     .tag = .float_f32,
-                    .data = @bitCast(u32, float.storage.f32),
+                    .data = @as(u32, @bitCast(float.storage.f32)),
                 }),
                 .f64_type => ip.items.appendAssumeCapacity(.{
                     .tag = .float_f64,
@@ -3872,13 +3872,13 @@ pub fn get(ip: *InternPool, gpa: Allocator, key: Key) Allocator.Error!Index {
                     assert(child == .u8_type);
                     if (bytes.len != len) {
                         assert(bytes.len == len_including_sentinel);
-                        assert(bytes[@intCast(usize, len)] == ip.indexToKey(sentinel).int.storage.u64);
+                        assert(bytes[@as(usize, @intCast(len))] == ip.indexToKey(sentinel).int.storage.u64);
                     }
                 },
                 .elems => |elems| {
                     if (elems.len != len) {
                         assert(elems.len == len_including_sentinel);
-                        assert(elems[@intCast(usize, len)] == sentinel);
+                        assert(elems[@as(usize, @intCast(len))] == sentinel);
                     }
                 },
                 .repeated_elem => |elem| {
@@ -3912,7 +3912,7 @@ pub fn get(ip: *InternPool, gpa: Allocator, key: Key) Allocator.Error!Index {
                     .tag = .only_possible_value,
                     .data = @intFromEnum(aggregate.ty),
                 });
-                return @enumFromInt(Index, ip.items.len - 1);
+                return @as(Index, @enumFromInt(ip.items.len - 1));
             }
 
             switch (ty_key) {
@@ -3940,16 +3940,16 @@ pub fn get(ip: *InternPool, gpa: Allocator, key: Key) Allocator.Error!Index {
                         .tag = .only_possible_value,
                         .data = @intFromEnum(aggregate.ty),
                     });
-                    return @enumFromInt(Index, ip.items.len - 1);
+                    return @as(Index, @enumFromInt(ip.items.len - 1));
                 },
                 else => {},
             }
 
             repeated: {
                 switch (aggregate.storage) {
-                    .bytes => |bytes| for (bytes[1..@intCast(usize, len)]) |byte|
+                    .bytes => |bytes| for (bytes[1..@as(usize, @intCast(len))]) |byte|
                         if (byte != bytes[0]) break :repeated,
-                    .elems => |elems| for (elems[1..@intCast(usize, len)]) |elem|
+                    .elems => |elems| for (elems[1..@as(usize, @intCast(len))]) |elem|
                         if (elem != elems[0]) break :repeated,
                     .repeated_elem => {},
                 }
@@ -3979,12 +3979,12 @@ pub fn get(ip: *InternPool, gpa: Allocator, key: Key) Allocator.Error!Index {
                         .elem_val = elem,
                     }),
                 });
-                return @enumFromInt(Index, ip.items.len - 1);
+                return @as(Index, @enumFromInt(ip.items.len - 1));
             }
 
             if (child == .u8_type) bytes: {
                 const string_bytes_index = ip.string_bytes.items.len;
-                try ip.string_bytes.ensureUnusedCapacity(gpa, @intCast(usize, len_including_sentinel + 1));
+                try ip.string_bytes.ensureUnusedCapacity(gpa, @as(usize, @intCast(len_including_sentinel + 1)));
                 try ip.extra.ensureUnusedCapacity(gpa, @typeInfo(Bytes).Struct.fields.len);
                 switch (aggregate.storage) {
                     .bytes => |bytes| ip.string_bytes.appendSliceAssumeCapacity(bytes),
@@ -3994,15 +3994,15 @@ pub fn get(ip: *InternPool, gpa: Allocator, key: Key) Allocator.Error!Index {
                             break :bytes;
                         },
                         .int => |int| ip.string_bytes.appendAssumeCapacity(
-                            @intCast(u8, int.storage.u64),
+                            @as(u8, @intCast(int.storage.u64)),
                         ),
                         else => unreachable,
                     },
                     .repeated_elem => |elem| switch (ip.indexToKey(elem)) {
                         .undef => break :bytes,
                         .int => |int| @memset(
-                            ip.string_bytes.addManyAsSliceAssumeCapacity(@intCast(usize, len)),
-                            @intCast(u8, int.storage.u64),
+                            ip.string_bytes.addManyAsSliceAssumeCapacity(@as(usize, @intCast(len))),
+                            @as(u8, @intCast(int.storage.u64)),
                         ),
                         else => unreachable,
                     },
@@ -4010,12 +4010,12 @@ pub fn get(ip: *InternPool, gpa: Allocator, key: Key) Allocator.Error!Index {
                 const has_internal_null =
                     std.mem.indexOfScalar(u8, ip.string_bytes.items[string_bytes_index..], 0) != null;
                 if (sentinel != .none) ip.string_bytes.appendAssumeCapacity(
-                    @intCast(u8, ip.indexToKey(sentinel).int.storage.u64),
+                    @as(u8, @intCast(ip.indexToKey(sentinel).int.storage.u64)),
                 );
                 const string = if (has_internal_null)
-                    @enumFromInt(String, string_bytes_index)
+                    @as(String, @enumFromInt(string_bytes_index))
                 else
-                    (try ip.getOrPutTrailingString(gpa, @intCast(usize, len_including_sentinel))).toString();
+                    (try ip.getOrPutTrailingString(gpa, @as(usize, @intCast(len_including_sentinel)))).toString();
                 ip.items.appendAssumeCapacity(.{
                     .tag = .bytes,
                     .data = ip.addExtraAssumeCapacity(Bytes{
@@ -4023,12 +4023,12 @@ pub fn get(ip: *InternPool, gpa: Allocator, key: Key) Allocator.Error!Index {
                         .bytes = string,
                     }),
                 });
-                return @enumFromInt(Index, ip.items.len - 1);
+                return @as(Index, @enumFromInt(ip.items.len - 1));
             }
 
             try ip.extra.ensureUnusedCapacity(
                 gpa,
-                @typeInfo(Tag.Aggregate).Struct.fields.len + @intCast(usize, len_including_sentinel),
+                @typeInfo(Tag.Aggregate).Struct.fields.len + @as(usize, @intCast(len_including_sentinel)),
             );
             ip.items.appendAssumeCapacity(.{
                 .tag = .aggregate,
@@ -4036,7 +4036,7 @@ pub fn get(ip: *InternPool, gpa: Allocator, key: Key) Allocator.Error!Index {
                     .ty = aggregate.ty,
                 }),
             });
-            ip.extra.appendSliceAssumeCapacity(@ptrCast([]const u32, aggregate.storage.elems));
+            ip.extra.appendSliceAssumeCapacity(@as([]const u32, @ptrCast(aggregate.storage.elems)));
             if (sentinel != .none) ip.extra.appendAssumeCapacity(@intFromEnum(sentinel));
         },
 
@@ -4058,14 +4058,14 @@ pub fn get(ip: *InternPool, gpa: Allocator, key: Key) Allocator.Error!Index {
                 .tag = .memoized_call,
                 .data = ip.addExtraAssumeCapacity(MemoizedCall{
                     .func = memoized_call.func,
-                    .args_len = @intCast(u32, memoized_call.arg_values.len),
+                    .args_len = @as(u32, @intCast(memoized_call.arg_values.len)),
                     .result = memoized_call.result,
                 }),
             });
-            ip.extra.appendSliceAssumeCapacity(@ptrCast([]const u32, memoized_call.arg_values));
+            ip.extra.appendSliceAssumeCapacity(@as([]const u32, @ptrCast(memoized_call.arg_values)));
         },
     }
-    return @enumFromInt(Index, ip.items.len - 1);
+    return @as(Index, @enumFromInt(ip.items.len - 1));
 }
 
 /// Provides API for completing an enum type after calling `getIncompleteEnum`.
@@ -4093,10 +4093,10 @@ pub const IncompleteEnumType = struct {
         const field_index = map.count();
         const strings = ip.extra.items[self.names_start..][0..field_index];
         const adapter: NullTerminatedString.Adapter = .{
-            .strings = @ptrCast([]const NullTerminatedString, strings),
+            .strings = @as([]const NullTerminatedString, @ptrCast(strings)),
         };
         const gop = try map.getOrPutAdapted(gpa, name, adapter);
-        if (gop.found_existing) return @intCast(u32, gop.index);
+        if (gop.found_existing) return @as(u32, @intCast(gop.index));
         ip.extra.items[self.names_start + field_index] = @intFromEnum(name);
         return null;
     }
@@ -4109,15 +4109,15 @@ pub const IncompleteEnumType = struct {
         gpa: Allocator,
         value: Index,
     ) Allocator.Error!?u32 {
-        assert(ip.typeOf(value) == @enumFromInt(Index, ip.extra.items[self.tag_ty_index]));
+        assert(ip.typeOf(value) == @as(Index, @enumFromInt(ip.extra.items[self.tag_ty_index])));
         const map = &ip.maps.items[@intFromEnum(self.values_map.unwrap().?)];
         const field_index = map.count();
         const indexes = ip.extra.items[self.values_start..][0..field_index];
         const adapter: Index.Adapter = .{
-            .indexes = @ptrCast([]const Index, indexes),
+            .indexes = @as([]const Index, @ptrCast(indexes)),
         };
         const gop = try map.getOrPutAdapted(gpa, value, adapter);
-        if (gop.found_existing) return @intCast(u32, gop.index);
+        if (gop.found_existing) return @as(u32, @intCast(gop.index));
         ip.extra.items[self.values_start + field_index] = @intFromEnum(value);
         return null;
     }
@@ -4177,7 +4177,7 @@ fn getIncompleteEnumAuto(
     });
     ip.extra.appendNTimesAssumeCapacity(@intFromEnum(Index.none), enum_type.fields_len);
     return .{
-        .index = @enumFromInt(Index, ip.items.len - 1),
+        .index = @as(Index, @enumFromInt(ip.items.len - 1)),
         .tag_ty_index = extra_index + std.meta.fieldIndex(EnumAuto, "int_tag_type").?,
         .names_map = names_map,
         .names_start = extra_index + extra_fields_len,
@@ -4228,7 +4228,7 @@ fn getIncompleteEnumExplicit(
     // This is both fields and values (if present).
     ip.extra.appendNTimesAssumeCapacity(@intFromEnum(Index.none), reserved_len);
     return .{
-        .index = @enumFromInt(Index, ip.items.len - 1),
+        .index = @as(Index, @enumFromInt(ip.items.len - 1)),
         .tag_ty_index = extra_index + std.meta.fieldIndex(EnumExplicit, "int_tag_type").?,
         .names_map = names_map,
         .names_start = extra_index + extra_fields_len,
@@ -4251,7 +4251,7 @@ pub fn finishGetEnum(
         try addIndexesToMap(ip, gpa, values_map, enum_type.values);
         break :m values_map.toOptional();
     };
-    const fields_len = @intCast(u32, enum_type.names.len);
+    const fields_len = @as(u32, @intCast(enum_type.names.len));
     try ip.extra.ensureUnusedCapacity(gpa, @typeInfo(EnumExplicit).Struct.fields.len +
         fields_len);
     ip.items.appendAssumeCapacity(.{
@@ -4265,15 +4265,15 @@ pub fn finishGetEnum(
             .values_map = values_map,
         }),
     });
-    ip.extra.appendSliceAssumeCapacity(@ptrCast([]const u32, enum_type.names));
-    ip.extra.appendSliceAssumeCapacity(@ptrCast([]const u32, enum_type.values));
-    return @enumFromInt(Index, ip.items.len - 1);
+    ip.extra.appendSliceAssumeCapacity(@as([]const u32, @ptrCast(enum_type.names)));
+    ip.extra.appendSliceAssumeCapacity(@as([]const u32, @ptrCast(enum_type.values)));
+    return @as(Index, @enumFromInt(ip.items.len - 1));
 }
 
 pub fn getIfExists(ip: *const InternPool, key: Key) ?Index {
     const adapter: KeyAdapter = .{ .intern_pool = ip };
     const index = ip.map.getIndexAdapted(key, adapter) orelse return null;
-    return @enumFromInt(Index, index);
+    return @as(Index, @enumFromInt(index));
 }
 
 pub fn getAssumeExists(ip: *const InternPool, key: Key) Index {
@@ -4311,7 +4311,7 @@ fn addIndexesToMap(
 fn addMap(ip: *InternPool, gpa: Allocator) Allocator.Error!MapIndex {
     const ptr = try ip.maps.addOne(gpa);
     ptr.* = .{};
-    return @enumFromInt(MapIndex, ip.maps.items.len - 1);
+    return @as(MapIndex, @enumFromInt(ip.maps.items.len - 1));
 }
 
 /// This operation only happens under compile error conditions.
@@ -4320,7 +4320,7 @@ fn addMap(ip: *InternPool, gpa: Allocator) Allocator.Error!MapIndex {
 pub const remove = @compileError("InternPool.remove is not currently a supported operation; put a TODO there instead");
 
 fn addInt(ip: *InternPool, gpa: Allocator, ty: Index, tag: Tag, limbs: []const Limb) !void {
-    const limbs_len = @intCast(u32, limbs.len);
+    const limbs_len = @as(u32, @intCast(limbs.len));
     try ip.reserveLimbs(gpa, @typeInfo(Int).Struct.fields.len + limbs_len);
     ip.items.appendAssumeCapacity(.{
         .tag = tag,
@@ -4339,7 +4339,7 @@ fn addExtra(ip: *InternPool, gpa: Allocator, extra: anytype) Allocator.Error!u32
 }
 
 fn addExtraAssumeCapacity(ip: *InternPool, extra: anytype) u32 {
-    const result = @intCast(u32, ip.extra.items.len);
+    const result = @as(u32, @intCast(ip.extra.items.len));
     inline for (@typeInfo(@TypeOf(extra)).Struct.fields) |field| {
         ip.extra.appendAssumeCapacity(switch (field.type) {
             u32 => @field(extra, field.name),
@@ -4354,12 +4354,12 @@ fn addExtraAssumeCapacity(ip: *InternPool, extra: anytype) u32 {
             String => @intFromEnum(@field(extra, field.name)),
             NullTerminatedString => @intFromEnum(@field(extra, field.name)),
             OptionalNullTerminatedString => @intFromEnum(@field(extra, field.name)),
-            i32 => @bitCast(u32, @field(extra, field.name)),
-            Tag.TypePointer.Flags => @bitCast(u32, @field(extra, field.name)),
-            TypeFunction.Flags => @bitCast(u32, @field(extra, field.name)),
-            Tag.TypePointer.PackedOffset => @bitCast(u32, @field(extra, field.name)),
+            i32 => @as(u32, @bitCast(@field(extra, field.name))),
+            Tag.TypePointer.Flags => @as(u32, @bitCast(@field(extra, field.name))),
+            TypeFunction.Flags => @as(u32, @bitCast(@field(extra, field.name))),
+            Tag.TypePointer.PackedOffset => @as(u32, @bitCast(@field(extra, field.name))),
             Tag.TypePointer.VectorIndex => @intFromEnum(@field(extra, field.name)),
-            Tag.Variable.Flags => @bitCast(u32, @field(extra, field.name)),
+            Tag.Variable.Flags => @as(u32, @bitCast(@field(extra, field.name))),
             else => @compileError("bad field type: " ++ @typeName(field.type)),
         });
     }
@@ -4380,7 +4380,7 @@ fn addLimbsExtraAssumeCapacity(ip: *InternPool, extra: anytype) u32 {
         @sizeOf(u64) => {},
         else => @compileError("unsupported host"),
     }
-    const result = @intCast(u32, ip.limbs.items.len);
+    const result = @as(u32, @intCast(ip.limbs.items.len));
     inline for (@typeInfo(@TypeOf(extra)).Struct.fields, 0..) |field, i| {
         const new: u32 = switch (field.type) {
             u32 => @field(extra, field.name),
@@ -4411,23 +4411,23 @@ fn extraDataTrail(ip: *const InternPool, comptime T: type, index: usize) struct
         const int32 = ip.extra.items[i + index];
         @field(result, field.name) = switch (field.type) {
             u32 => int32,
-            Index => @enumFromInt(Index, int32),
-            Module.Decl.Index => @enumFromInt(Module.Decl.Index, int32),
-            Module.Namespace.Index => @enumFromInt(Module.Namespace.Index, int32),
-            Module.Namespace.OptionalIndex => @enumFromInt(Module.Namespace.OptionalIndex, int32),
-            Module.Fn.Index => @enumFromInt(Module.Fn.Index, int32),
-            MapIndex => @enumFromInt(MapIndex, int32),
-            OptionalMapIndex => @enumFromInt(OptionalMapIndex, int32),
-            RuntimeIndex => @enumFromInt(RuntimeIndex, int32),
-            String => @enumFromInt(String, int32),
-            NullTerminatedString => @enumFromInt(NullTerminatedString, int32),
-            OptionalNullTerminatedString => @enumFromInt(OptionalNullTerminatedString, int32),
-            i32 => @bitCast(i32, int32),
-            Tag.TypePointer.Flags => @bitCast(Tag.TypePointer.Flags, int32),
-            TypeFunction.Flags => @bitCast(TypeFunction.Flags, int32),
-            Tag.TypePointer.PackedOffset => @bitCast(Tag.TypePointer.PackedOffset, int32),
-            Tag.TypePointer.VectorIndex => @enumFromInt(Tag.TypePointer.VectorIndex, int32),
-            Tag.Variable.Flags => @bitCast(Tag.Variable.Flags, int32),
+            Index => @as(Index, @enumFromInt(int32)),
+            Module.Decl.Index => @as(Module.Decl.Index, @enumFromInt(int32)),
+            Module.Namespace.Index => @as(Module.Namespace.Index, @enumFromInt(int32)),
+            Module.Namespace.OptionalIndex => @as(Module.Namespace.OptionalIndex, @enumFromInt(int32)),
+            Module.Fn.Index => @as(Module.Fn.Index, @enumFromInt(int32)),
+            MapIndex => @as(MapIndex, @enumFromInt(int32)),
+            OptionalMapIndex => @as(OptionalMapIndex, @enumFromInt(int32)),
+            RuntimeIndex => @as(RuntimeIndex, @enumFromInt(int32)),
+            String => @as(String, @enumFromInt(int32)),
+            NullTerminatedString => @as(NullTerminatedString, @enumFromInt(int32)),
+            OptionalNullTerminatedString => @as(OptionalNullTerminatedString, @enumFromInt(int32)),
+            i32 => @as(i32, @bitCast(int32)),
+            Tag.TypePointer.Flags => @as(Tag.TypePointer.Flags, @bitCast(int32)),
+            TypeFunction.Flags => @as(TypeFunction.Flags, @bitCast(int32)),
+            Tag.TypePointer.PackedOffset => @as(Tag.TypePointer.PackedOffset, @bitCast(int32)),
+            Tag.TypePointer.VectorIndex => @as(Tag.TypePointer.VectorIndex, @enumFromInt(int32)),
+            Tag.Variable.Flags => @as(Tag.Variable.Flags, @bitCast(int32)),
             else => @compileError("bad field type: " ++ @typeName(field.type)),
         };
     }
@@ -4452,13 +4452,13 @@ fn limbData(ip: *const InternPool, comptime T: type, index: usize) T {
     inline for (@typeInfo(T).Struct.fields, 0..) |field, i| {
         const host_int = ip.limbs.items[index + i / 2];
         const int32 = if (i % 2 == 0)
-            @truncate(u32, host_int)
+            @as(u32, @truncate(host_int))
         else
-            @truncate(u32, host_int >> 32);
+            @as(u32, @truncate(host_int >> 32));
 
         @field(result, field.name) = switch (field.type) {
             u32 => int32,
-            Index => @enumFromInt(Index, int32),
+            Index => @as(Index, @enumFromInt(int32)),
             else => @compileError("bad field type: " ++ @typeName(field.type)),
         };
     }
@@ -4494,8 +4494,8 @@ fn limbsSliceToIndex(ip: *const InternPool, limbs: []const Limb) LimbsAsIndexes
     };
     // TODO: https://github.com/ziglang/zig/issues/1738
     return .{
-        .start = @intCast(u32, @divExact(@intFromPtr(limbs.ptr) - @intFromPtr(host_slice.ptr), @sizeOf(Limb))),
-        .len = @intCast(u32, limbs.len),
+        .start = @as(u32, @intCast(@divExact(@intFromPtr(limbs.ptr) - @intFromPtr(host_slice.ptr), @sizeOf(Limb)))),
+        .len = @as(u32, @intCast(limbs.len)),
     };
 }
 
@@ -4557,7 +4557,7 @@ pub fn slicePtrType(ip: *const InternPool, i: Index) Index {
     }
     const item = ip.items.get(@intFromEnum(i));
     switch (item.tag) {
-        .type_slice => return @enumFromInt(Index, item.data),
+        .type_slice => return @as(Index, @enumFromInt(item.data)),
         else => unreachable, // not a slice type
     }
 }
@@ -4727,7 +4727,7 @@ pub fn getCoerced(ip: *InternPool, gpa: Allocator, val: Index, new_ty: Index) Al
                     .val = error_union.val,
                 } }),
             .aggregate => |aggregate| {
-                const new_len = @intCast(usize, ip.aggregateTypeLen(new_ty));
+                const new_len = @as(usize, @intCast(ip.aggregateTypeLen(new_ty)));
                 direct: {
                     const old_ty_child = switch (ip.indexToKey(old_ty)) {
                         inline .array_type, .vector_type => |seq_type| seq_type.child,
@@ -4862,7 +4862,7 @@ pub fn indexToStructType(ip: *const InternPool, val: Index) Module.Struct.Option
     const tags = ip.items.items(.tag);
     if (tags[@intFromEnum(val)] != .type_struct) return .none;
     const datas = ip.items.items(.data);
-    return @enumFromInt(Module.Struct.Index, datas[@intFromEnum(val)]).toOptional();
+    return @as(Module.Struct.Index, @enumFromInt(datas[@intFromEnum(val)])).toOptional();
 }
 
 pub fn indexToUnionType(ip: *const InternPool, val: Index) Module.Union.OptionalIndex {
@@ -4873,7 +4873,7 @@ pub fn indexToUnionType(ip: *const InternPool, val: Index) Module.Union.Optional
         else => return .none,
     }
     const datas = ip.items.items(.data);
-    return @enumFromInt(Module.Union.Index, datas[@intFromEnum(val)]).toOptional();
+    return @as(Module.Union.Index, @enumFromInt(datas[@intFromEnum(val)])).toOptional();
 }
 
 pub fn indexToFuncType(ip: *const InternPool, val: Index) ?Key.FuncType {
@@ -4899,7 +4899,7 @@ pub fn indexToInferredErrorSetType(ip: *const InternPool, val: Index) Module.Fn.
     const tags = ip.items.items(.tag);
     if (tags[@intFromEnum(val)] != .type_inferred_error_set) return .none;
     const datas = ip.items.items(.data);
-    return @enumFromInt(Module.Fn.InferredErrorSet.Index, datas[@intFromEnum(val)]).toOptional();
+    return @as(Module.Fn.InferredErrorSet.Index, @enumFromInt(datas[@intFromEnum(val)])).toOptional();
 }
 
 /// includes .comptime_int_type
@@ -5057,7 +5057,7 @@ fn dumpStatsFallible(ip: *const InternPool, arena: Allocator) anyerror!void {
             .type_enum_auto => @sizeOf(EnumAuto),
             .type_opaque => @sizeOf(Key.OpaqueType),
             .type_struct => b: {
-                const struct_index = @enumFromInt(Module.Struct.Index, data);
+                const struct_index = @as(Module.Struct.Index, @enumFromInt(data));
                 const struct_obj = ip.structPtrConst(struct_index);
                 break :b @sizeOf(Module.Struct) +
                     @sizeOf(Module.Namespace) +
@@ -5124,13 +5124,13 @@ fn dumpStatsFallible(ip: *const InternPool, arena: Allocator) anyerror!void {
 
             .bytes => b: {
                 const info = ip.extraData(Bytes, data);
-                const len = @intCast(u32, ip.aggregateTypeLenIncludingSentinel(info.ty));
+                const len = @as(u32, @intCast(ip.aggregateTypeLenIncludingSentinel(info.ty)));
                 break :b @sizeOf(Bytes) + len +
                     @intFromBool(ip.string_bytes.items[@intFromEnum(info.bytes) + len - 1] != 0);
             },
             .aggregate => b: {
                 const info = ip.extraData(Tag.Aggregate, data);
-                const fields_len = @intCast(u32, ip.aggregateTypeLenIncludingSentinel(info.ty));
+                const fields_len = @as(u32, @intCast(ip.aggregateTypeLenIncludingSentinel(info.ty)));
                 break :b @sizeOf(Tag.Aggregate) + (@sizeOf(Index) * fields_len);
             },
             .repeated => @sizeOf(Repeated),
@@ -5181,8 +5181,8 @@ fn dumpAllFallible(ip: *const InternPool) anyerror!void {
     for (tags, datas, 0..) |tag, data, i| {
         try w.print("${d} = {s}(", .{ i, @tagName(tag) });
         switch (tag) {
-            .simple_type => try w.print("{s}", .{@tagName(@enumFromInt(SimpleType, data))}),
-            .simple_value => try w.print("{s}", .{@tagName(@enumFromInt(SimpleValue, data))}),
+            .simple_type => try w.print("{s}", .{@tagName(@as(SimpleType, @enumFromInt(data)))}),
+            .simple_value => try w.print("{s}", .{@tagName(@as(SimpleValue, @enumFromInt(data)))}),
 
             .type_int_signed,
             .type_int_unsigned,
@@ -5311,7 +5311,7 @@ pub fn createStruct(
     }
     const ptr = try ip.allocated_structs.addOne(gpa);
     ptr.* = initialization;
-    return @enumFromInt(Module.Struct.Index, ip.allocated_structs.len - 1);
+    return @as(Module.Struct.Index, @enumFromInt(ip.allocated_structs.len - 1));
 }
 
 pub fn destroyStruct(ip: *InternPool, gpa: Allocator, index: Module.Struct.Index) void {
@@ -5333,7 +5333,7 @@ pub fn createUnion(
     }
     const ptr = try ip.allocated_unions.addOne(gpa);
     ptr.* = initialization;
-    return @enumFromInt(Module.Union.Index, ip.allocated_unions.len - 1);
+    return @as(Module.Union.Index, @enumFromInt(ip.allocated_unions.len - 1));
 }
 
 pub fn destroyUnion(ip: *InternPool, gpa: Allocator, index: Module.Union.Index) void {
@@ -5355,7 +5355,7 @@ pub fn createFunc(
     }
     const ptr = try ip.allocated_funcs.addOne(gpa);
     ptr.* = initialization;
-    return @enumFromInt(Module.Fn.Index, ip.allocated_funcs.len - 1);
+    return @as(Module.Fn.Index, @enumFromInt(ip.allocated_funcs.len - 1));
 }
 
 pub fn destroyFunc(ip: *InternPool, gpa: Allocator, index: Module.Fn.Index) void {
@@ -5377,7 +5377,7 @@ pub fn createInferredErrorSet(
     }
     const ptr = try ip.allocated_inferred_error_sets.addOne(gpa);
     ptr.* = initialization;
-    return @enumFromInt(Module.Fn.InferredErrorSet.Index, ip.allocated_inferred_error_sets.len - 1);
+    return @as(Module.Fn.InferredErrorSet.Index, @enumFromInt(ip.allocated_inferred_error_sets.len - 1));
 }
 
 pub fn destroyInferredErrorSet(ip: *InternPool, gpa: Allocator, index: Module.Fn.InferredErrorSet.Index) void {
@@ -5406,7 +5406,7 @@ pub fn getOrPutStringFmt(
     args: anytype,
 ) Allocator.Error!NullTerminatedString {
     // ensure that references to string_bytes in args do not get invalidated
-    const len = @intCast(usize, std.fmt.count(format, args) + 1);
+    const len = @as(usize, @intCast(std.fmt.count(format, args) + 1));
     try ip.string_bytes.ensureUnusedCapacity(gpa, len);
     ip.string_bytes.writer(undefined).print(format, args) catch unreachable;
     ip.string_bytes.appendAssumeCapacity(0);
@@ -5430,7 +5430,7 @@ pub fn getOrPutTrailingString(
     len: usize,
 ) Allocator.Error!NullTerminatedString {
     const string_bytes = &ip.string_bytes;
-    const str_index = @intCast(u32, string_bytes.items.len - len);
+    const str_index = @as(u32, @intCast(string_bytes.items.len - len));
     if (len > 0 and string_bytes.getLast() == 0) {
         _ = string_bytes.pop();
     } else {
@@ -5444,11 +5444,11 @@ pub fn getOrPutTrailingString(
     });
     if (gop.found_existing) {
         string_bytes.shrinkRetainingCapacity(str_index);
-        return @enumFromInt(NullTerminatedString, gop.key_ptr.*);
+        return @as(NullTerminatedString, @enumFromInt(gop.key_ptr.*));
     } else {
         gop.key_ptr.* = str_index;
         string_bytes.appendAssumeCapacity(0);
-        return @enumFromInt(NullTerminatedString, str_index);
+        return @as(NullTerminatedString, @enumFromInt(str_index));
     }
 }
 
@@ -5456,7 +5456,7 @@ pub fn getString(ip: *InternPool, s: []const u8) OptionalNullTerminatedString {
     if (ip.string_table.getKeyAdapted(s, std.hash_map.StringIndexAdapter{
         .bytes = &ip.string_bytes,
     })) |index| {
-        return @enumFromInt(NullTerminatedString, index).toOptional();
+        return @as(NullTerminatedString, @enumFromInt(index)).toOptional();
     } else {
         return .none;
     }
@@ -5596,7 +5596,7 @@ pub fn typeOf(ip: *const InternPool, index: Index) Index {
             .undef,
             .opt_null,
             .only_possible_value,
-            => @enumFromInt(Index, ip.items.items(.data)[@intFromEnum(index)]),
+            => @as(Index, @enumFromInt(ip.items.items(.data)[@intFromEnum(index)])),
 
             .simple_value => unreachable, // handled via Index above
 
@@ -5628,7 +5628,7 @@ pub fn typeOf(ip: *const InternPool, index: Index) Index {
             => |t| {
                 const extra_index = ip.items.items(.data)[@intFromEnum(index)];
                 const field_index = std.meta.fieldIndex(t.Payload(), "ty").?;
-                return @enumFromInt(Index, ip.extra.items[extra_index + field_index]);
+                return @as(Index, @enumFromInt(ip.extra.items[extra_index + field_index]));
             },
 
             .int_u8 => .u8_type,
@@ -5670,7 +5670,7 @@ pub fn typeOf(ip: *const InternPool, index: Index) Index {
 /// Assumes that the enum's field indexes equal its value tags.
 pub fn toEnum(ip: *const InternPool, comptime E: type, i: Index) E {
     const int = ip.indexToKey(i).enum_tag.int;
-    return @enumFromInt(E, ip.indexToKey(int).int.storage.u64);
+    return @as(E, @enumFromInt(ip.indexToKey(int).int.storage.u64));
 }
 
 pub fn aggregateTypeLen(ip: *const InternPool, ty: Index) u64 {
@@ -5703,9 +5703,9 @@ pub fn funcReturnType(ip: *const InternPool, ty: Index) Index {
         else => unreachable,
     };
     assert(child_item.tag == .type_function);
-    return @enumFromInt(Index, ip.extra.items[
+    return @as(Index, @enumFromInt(ip.extra.items[
         child_item.data + std.meta.fieldIndex(TypeFunction, "return_type").?
-    ]);
+    ]));
 }
 
 pub fn isNoReturn(ip: *const InternPool, ty: Index) bool {
@@ -5736,9 +5736,9 @@ pub fn getBackingDecl(ip: *const InternPool, val: Index) Module.Decl.OptionalInd
         switch (ip.items.items(.tag)[base]) {
             inline .ptr_decl,
             .ptr_mut_decl,
-            => |tag| return @enumFromInt(Module.Decl.OptionalIndex, ip.extra.items[
+            => |tag| return @as(Module.Decl.OptionalIndex, @enumFromInt(ip.extra.items[
                 ip.items.items(.data)[base] + std.meta.fieldIndex(tag.Payload(), "decl").?
-            ]),
+            ])),
             inline .ptr_eu_payload,
             .ptr_opt_payload,
             .ptr_elem,