diff --git a/lib/build-web/fuzz.zig b/lib/build-web/fuzz.zig
index a05f9d2e649ac7edfe800b41d6aae9a3799c87ec..29b37e34650391858c451937c1098f4a2f0072a5 100644
--- a/lib/build-web/fuzz.zig
+++ b/lib/build-web/fuzz.zig
@@ -256,7 +256,7 @@ fn updateStats() error{OutOfMemory}!void {
 
     if (recent_coverage_update.items.len == 0) return;
 
-    const hdr: *abi.fuzz.CoverageUpdateHeader = @alignCast(@ptrCast(
+    const hdr: *abi.fuzz.CoverageUpdateHeader = @ptrCast(@alignCast(
         recent_coverage_update.items[0..@sizeOf(abi.fuzz.CoverageUpdateHeader)],
     ));
 
diff --git a/lib/compiler_rt/memcpy.zig b/lib/compiler_rt/memcpy.zig
index 424e92954d78e38c1317d9a987efe57238274200..a31bbe62a0328d80af65118a24ae047721fa995c 100644
--- a/lib/compiler_rt/memcpy.zig
+++ b/lib/compiler_rt/memcpy.zig
@@ -110,7 +110,7 @@ inline fn copyForwards(
     const d = dest + alignment_offset;
     const s = src + alignment_offset;
 
-    copyBlocksAlignedSource(@ptrCast(d), @alignCast(@ptrCast(s)), n);
+    copyBlocksAlignedSource(@ptrCast(d), @ptrCast(@alignCast(s)), n);
 
     // copy last `@sizeOf(Element)` bytes unconditionally, since block copy
     // methods only copy a multiple of `@sizeOf(Element)` bytes.
diff --git a/lib/compiler_rt/memmove.zig b/lib/compiler_rt/memmove.zig
index 46c5a631cb2e110862c75624ddf80e3a81b7c1a8..c57ba9c3cc2c89adc3699f2e5a98c527ed9165bd 100644
--- a/lib/compiler_rt/memmove.zig
+++ b/lib/compiler_rt/memmove.zig
@@ -157,7 +157,7 @@ inline fn copyForwards(
     const d = dest + alignment_offset;
     const s = src + alignment_offset;
 
-    copyBlocksAlignedSource(@ptrCast(d), @alignCast(@ptrCast(s)), n);
+    copyBlocksAlignedSource(@ptrCast(d), @ptrCast(@alignCast(s)), n);
 
     // copy last `copy_size` bytes unconditionally, since block copy
     // methods only copy a multiple of `copy_size` bytes.
diff --git a/lib/std/Io.zig b/lib/std/Io.zig
index c55c28f1771fb0be0a5b12394f98b5c7b32037fd..7405eabf1055eed493cb673fe6f73ede7832de76 100644
--- a/lib/std/Io.zig
+++ b/lib/std/Io.zig
@@ -304,7 +304,7 @@ pub fn GenericReader(
         const Self = @This();
 
         fn typeErasedReadFn(context: *const anyopaque, buffer: []u8) anyerror!usize {
-            const ptr: *const Context = @alignCast(@ptrCast(context));
+            const ptr: *const Context = @ptrCast(@alignCast(context));
             return readFn(ptr.*, buffer);
         }
 
@@ -397,7 +397,7 @@ pub fn GenericWriter(
         }
 
         fn typeErasedWriteFn(context: *const anyopaque, bytes: []const u8) anyerror!usize {
-            const ptr: *const Context = @alignCast(@ptrCast(context));
+            const ptr: *const Context = @ptrCast(@alignCast(context));
             return writeFn(ptr.*, bytes);
         }
 
diff --git a/lib/std/Io/Reader.zig b/lib/std/Io/Reader.zig
index 05ab489286248870a2d7622d4a0e53601ba54312..7ec0f6760034db7bfc621daca8622480f9ca1fb7 100644
--- a/lib/std/Io/Reader.zig
+++ b/lib/std/Io/Reader.zig
@@ -1698,7 +1698,7 @@ pub fn adaptToOldInterface(r: *Reader) std.Io.AnyReader {
 }
 
 fn derpRead(context: *const anyopaque, buffer: []u8) anyerror!usize {
-    const r: *Reader = @constCast(@alignCast(@ptrCast(context)));
+    const r: *Reader = @ptrCast(@alignCast(@constCast(context)));
     return r.readSliceShort(buffer);
 }
 
diff --git a/lib/std/array_hash_map.zig b/lib/std/array_hash_map.zig
index ac9c70df8eaf1352092f01dd94b87b0013d26684..9ddd0fe2bde337975c0b503f41c1fc26425929dd 100644
--- a/lib/std/array_hash_map.zig
+++ b/lib/std/array_hash_map.zig
@@ -2086,7 +2086,7 @@ const IndexHeader = struct {
     /// Returns the attached array of indexes.  I must match the type
     /// returned by capacityIndexType.
     fn indexes(header: *IndexHeader, comptime I: type) []Index(I) {
-        const start_ptr: [*]Index(I) = @alignCast(@ptrCast(@as([*]u8, @ptrCast(header)) + @sizeOf(IndexHeader)));
+        const start_ptr: [*]Index(I) = @ptrCast(@alignCast(@as([*]u8, @ptrCast(header)) + @sizeOf(IndexHeader)));
         return start_ptr[0..header.length()];
     }
 
@@ -2122,7 +2122,7 @@ const IndexHeader = struct {
         const nbytes = @sizeOf(IndexHeader) + index_size * len;
         const bytes = try gpa.alignedAlloc(u8, .of(IndexHeader), nbytes);
         @memset(bytes[@sizeOf(IndexHeader)..], 0xff);
-        const result: *IndexHeader = @alignCast(@ptrCast(bytes.ptr));
+        const result: *IndexHeader = @ptrCast(@alignCast(bytes.ptr));
         result.* = .{
             .bit_index = new_bit_index,
         };
diff --git a/lib/std/crypto/codecs/asn1/der/Encoder.zig b/lib/std/crypto/codecs/asn1/der/Encoder.zig
index da861e3d7d5a06f9352856949e1c6f06804b2fa2..82b7e62910abbd82fb8ec674a9afe25182e30b02 100644
--- a/lib/std/crypto/codecs/asn1/der/Encoder.zig
+++ b/lib/std/crypto/codecs/asn1/der/Encoder.zig
@@ -37,7 +37,7 @@ fn anyTag(self: *Encoder, tag_: Tag, val: anytype) !void {
                 // > The encoding of a set value or sequence value shall not include an encoding for any
                 // > component value which is equal to its default value.
                 const is_default = if (f.is_comptime) false else if (f.default_value_ptr) |v| brk: {
-                    const default_val: *const f.type = @alignCast(@ptrCast(v));
+                    const default_val: *const f.type = @ptrCast(@alignCast(v));
                     break :brk std.mem.eql(u8, std.mem.asBytes(default_val), std.mem.asBytes(&field_val));
                 } else false;
 
diff --git a/lib/std/crypto/timing_safe.zig b/lib/std/crypto/timing_safe.zig
index 2dbd2f519200a9a1241ee5250a105a3c5921c2f2..85767eb0067ebac99cf7e721d70ca2782e97b76e 100644
--- a/lib/std/crypto/timing_safe.zig
+++ b/lib/std/crypto/timing_safe.zig
@@ -147,7 +147,7 @@ fn markSecret(ptr: anytype, comptime action: enum { classify, declassify }) void
             @compileError("A pointer value is always assumed leak information via side channels");
         },
         else => {
-            const mem8: *const [@sizeOf(@TypeOf(ptr.*))]u8 = @constCast(@ptrCast(ptr));
+            const mem8: *const [@sizeOf(@TypeOf(ptr.*))]u8 = @ptrCast(@constCast(ptr));
             if (action == .classify) {
                 std.valgrind.memcheck.makeMemUndefined(mem8);
             } else {
diff --git a/lib/std/debug.zig b/lib/std/debug.zig
index 655852c65e83ed2f446e675f53293df5dc4b81bc..797938f26fca529b08010bb41ce7619068b35d8d 100644
--- a/lib/std/debug.zig
+++ b/lib/std/debug.zig
@@ -569,7 +569,7 @@ pub fn assertReadable(slice: []const volatile u8) void {
 /// Invokes detectable illegal behavior when the provided array is not aligned
 /// to the provided amount.
 pub fn assertAligned(ptr: anytype, comptime alignment: std.mem.Alignment) void {
-    const aligned_ptr: *align(alignment.toByteUnits()) anyopaque = @alignCast(@ptrCast(ptr));
+    const aligned_ptr: *align(alignment.toByteUnits()) anyopaque = @ptrCast(@alignCast(ptr));
     _ = aligned_ptr;
 }
 
diff --git a/lib/std/debug/SelfInfo.zig b/lib/std/debug/SelfInfo.zig
index 3e60e86ed33ec9268e6fdc52244b7d506bbff439..3f1514a957e1096fa59121e599beb76a6a638225 100644
--- a/lib/std/debug/SelfInfo.zig
+++ b/lib/std/debug/SelfInfo.zig
@@ -836,7 +836,7 @@ pub const WindowsModule = struct {
 
         pub fn deinit(self: @This()) void {
             const process_handle = windows.GetCurrentProcess();
-            assert(windows.ntdll.NtUnmapViewOfSection(process_handle, @constCast(@ptrCast(self.section_view.ptr))) == .SUCCESS);
+            assert(windows.ntdll.NtUnmapViewOfSection(process_handle, @ptrCast(@constCast(self.section_view.ptr))) == .SUCCESS);
             windows.CloseHandle(self.section_handle);
             self.file.close();
         }
diff --git a/lib/std/hash_map.zig b/lib/std/hash_map.zig
index fb9b9f269df1e2650da8ff3011d1ee9cf55da7e8..f6d3fbabd7e66b87e870fe00c26a38694b2a4cea 100644
--- a/lib/std/hash_map.zig
+++ b/lib/std/hash_map.zig
@@ -1511,7 +1511,7 @@ pub fn HashMapUnmanaged(
 
             const total_size = std.mem.alignForward(usize, vals_end, max_align);
 
-            const slice = @as([*]align(max_align) u8, @alignCast(@ptrCast(self.header())))[0..total_size];
+            const slice = @as([*]align(max_align) u8, @ptrCast(@alignCast(self.header())))[0..total_size];
             allocator.free(slice);
 
             self.metadata = null;
diff --git a/lib/std/heap.zig b/lib/std/heap.zig
index a39cf5e1cb92f8ea81a5af1315b4116f0083f25c..a2eac1245656e912c33b75caf7e93f1684f0c61b 100644
--- a/lib/std/heap.zig
+++ b/lib/std/heap.zig
@@ -151,7 +151,7 @@ const CAllocator = struct {
     };
 
     fn getHeader(ptr: [*]u8) *[*]u8 {
-        return @alignCast(@ptrCast(ptr - @sizeOf(usize)));
+        return @ptrCast(@alignCast(ptr - @sizeOf(usize)));
     }
 
     fn alignedAlloc(len: usize, alignment: Alignment) ?[*]u8 {
diff --git a/lib/std/heap/SmpAllocator.zig b/lib/std/heap/SmpAllocator.zig
index 63f1e38a2aa6bfc654fe48ea3da888f71062738f..f9637c70a29f0ae7a25388143403a59cb13edf69 100644
--- a/lib/std/heap/SmpAllocator.zig
+++ b/lib/std/heap/SmpAllocator.zig
@@ -205,7 +205,7 @@ fn free(context: *anyopaque, memory: []u8, alignment: mem.Alignment, ra: usize)
         return PageAllocator.unmap(@alignCast(memory));
     }
 
-    const node: *usize = @alignCast(@ptrCast(memory.ptr));
+    const node: *usize = @ptrCast(@alignCast(memory.ptr));
 
     const t = Thread.lock();
     defer t.unlock();
diff --git a/lib/std/heap/debug_allocator.zig b/lib/std/heap/debug_allocator.zig
index df4bb76f0ff2249806d5f07d5a9b54bb69cf2233..97b884ec642051d2d2e3d3b9a5a79c29dedacc09 100644
--- a/lib/std/heap/debug_allocator.zig
+++ b/lib/std/heap/debug_allocator.zig
@@ -291,7 +291,7 @@ pub fn DebugAllocator(comptime config: Config) type {
 
             fn usedBits(bucket: *BucketHeader, index: usize) *usize {
                 const ptr: [*]u8 = @ptrCast(bucket);
-                const bits: [*]usize = @alignCast(@ptrCast(ptr + @sizeOf(BucketHeader)));
+                const bits: [*]usize = @ptrCast(@alignCast(ptr + @sizeOf(BucketHeader)));
                 return &bits[index];
             }
 
diff --git a/lib/std/http/Server.zig b/lib/std/http/Server.zig
index 7ec5d5c11f43371c5ea36742be40751df955b563..8997828f62525a1befec22bd6f8a56ed91cb51d6 100644
--- a/lib/std/http/Server.zig
+++ b/lib/std/http/Server.zig
@@ -624,7 +624,7 @@ pub const Request = struct {
     };
 
     fn read_cl(context: *const anyopaque, buffer: []u8) ReadError!usize {
-        const request: *Request = @constCast(@alignCast(@ptrCast(context)));
+        const request: *Request = @ptrCast(@alignCast(@constCast(context)));
         const s = request.server;
 
         const remaining_content_length = &request.reader_state.remaining_content_length;
@@ -652,7 +652,7 @@ pub const Request = struct {
     }
 
     fn read_chunked(context: *const anyopaque, buffer: []u8) ReadError!usize {
-        const request: *Request = @constCast(@alignCast(@ptrCast(context)));
+        const request: *Request = @ptrCast(@alignCast(@constCast(context)));
         const s = request.server;
 
         const cp = &request.reader_state.chunk_parser;
@@ -894,7 +894,7 @@ pub const Response = struct {
     }
 
     fn write_cl(context: *const anyopaque, bytes: []const u8) WriteError!usize {
-        const r: *Response = @constCast(@alignCast(@ptrCast(context)));
+        const r: *Response = @ptrCast(@alignCast(@constCast(context)));
 
         var trash: u64 = std.math.maxInt(u64);
         const len = switch (r.transfer_encoding) {
@@ -944,7 +944,7 @@ pub const Response = struct {
     }
 
     fn write_chunked(context: *const anyopaque, bytes: []const u8) WriteError!usize {
-        const r: *Response = @constCast(@alignCast(@ptrCast(context)));
+        const r: *Response = @ptrCast(@alignCast(@constCast(context)));
         assert(r.transfer_encoding == .chunked);
 
         if (r.elide_body)
diff --git a/lib/std/os/uefi/tables.zig b/lib/std/os/uefi/tables.zig
index f8541dc321bb4553474e6415abb308a6aa598fc1..ad163dbdbfc4282b8f6616001a9eb1e15e7ce10e 100644
--- a/lib/std/os/uefi/tables.zig
+++ b/lib/std/os/uefi/tables.zig
@@ -154,7 +154,7 @@ pub const MemoryMapSlice = struct {
 
     pub fn getUnchecked(self: MemoryMapSlice, index: usize) *MemoryDescriptor {
         const offset: usize = index * self.info.descriptor_size;
-        return @alignCast(@ptrCast(self.ptr[offset..]));
+        return @ptrCast(@alignCast(self.ptr[offset..]));
     }
 };
 
diff --git a/lib/std/os/uefi/tables/runtime_services.zig b/lib/std/os/uefi/tables/runtime_services.zig
index 63bc9ad531ea5b72657b9c7b95d1583d80e90e27..1881aab7f79ec1b675b818ab1134069dbddf7f59 100644
--- a/lib/std/os/uefi/tables/runtime_services.zig
+++ b/lib/std/os/uefi/tables/runtime_services.zig
@@ -353,7 +353,7 @@ pub const RuntimeServices = extern struct {
             reset_type,
             reset_status,
             if (data) |d| d.len else 0,
-            if (data) |d| @alignCast(@ptrCast(d.ptr)) else null,
+            if (data) |d| @ptrCast(@alignCast(d.ptr)) else null,
         );
     }
 
diff --git a/lib/std/os/windows.zig b/lib/std/os/windows.zig
index 829a8c37cc3e8202c78ccaa4ce3be5eb00e1bef6..83702393c04190c06c8260818f259e886ce9b23b 100644
--- a/lib/std/os/windows.zig
+++ b/lib/std/os/windows.zig
@@ -202,7 +202,7 @@ pub fn CreatePipe(rd: *HANDLE, wr: *HANDLE, sattr: *const SECURITY_ATTRIBUTES) C
         const name = UNICODE_STRING{
             .Length = len,
             .MaximumLength = len,
-            .Buffer = @constCast(@ptrCast(str)),
+            .Buffer = @ptrCast(@constCast(str)),
         };
         const attrs = OBJECT_ATTRIBUTES{
             .ObjectName = @constCast(&name),
diff --git a/lib/std/pie.zig b/lib/std/pie.zig
index 74cc02a635231f0840d39760ff8ea738578994e9..09b875ca15ee98e51cdbde8928275ba4fc185410 100644
--- a/lib/std/pie.zig
+++ b/lib/std/pie.zig
@@ -259,7 +259,7 @@ pub fn relocate(phdrs: []const elf.Phdr) void {
 
     const rel = sorted_dynv[elf.DT_REL];
     if (rel != 0) {
-        const rels: []const elf.Rel = @alignCast(@ptrCast(
+        const rels: []const elf.Rel = @ptrCast(@alignCast(
             @as([*]align(@alignOf(elf.Rel)) const u8, @ptrFromInt(base_addr + rel))[0..sorted_dynv[elf.DT_RELSZ]],
         ));
         for (rels) |r| {
@@ -270,7 +270,7 @@ pub fn relocate(phdrs: []const elf.Phdr) void {
 
     const rela = sorted_dynv[elf.DT_RELA];
     if (rela != 0) {
-        const relas: []const elf.Rela = @alignCast(@ptrCast(
+        const relas: []const elf.Rela = @ptrCast(@alignCast(
             @as([*]align(@alignOf(elf.Rela)) const u8, @ptrFromInt(base_addr + rela))[0..sorted_dynv[elf.DT_RELASZ]],
         ));
         for (relas) |r| {
diff --git a/lib/std/zig/c_translation.zig b/lib/std/zig/c_translation.zig
index c8cd980f57998f1421cfe3a7b5256fca5852b288..be0019c596bd8d01aeaa31a667feb07ea55dc602 100644
--- a/lib/std/zig/c_translation.zig
+++ b/lib/std/zig/c_translation.zig
@@ -71,7 +71,7 @@ fn castInt(comptime DestType: type, target: anytype) DestType {
 }
 
 fn castPtr(comptime DestType: type, target: anytype) DestType {
-    return @constCast(@volatileCast(@alignCast(@ptrCast(target))));
+    return @ptrCast(@alignCast(@constCast(@volatileCast(target))));
 }
 
 fn castToPtr(comptime DestType: type, comptime SourceType: type, target: anytype) DestType {
diff --git a/lib/ubsan_rt.zig b/lib/ubsan_rt.zig
index cfb9ea2d99f6ca87c60a466a11b85b4f0e2cecc7..63f1d466cb55515fef4ef9a494e71d26b4541cec 100644
--- a/lib/ubsan_rt.zig
+++ b/lib/ubsan_rt.zig
@@ -58,8 +58,8 @@ const Value = extern struct {
         }
 
         return switch (size) {
-            64 => @as(*const u64, @alignCast(@ptrCast(value.handle))).*,
-            128 => @as(*const u128, @alignCast(@ptrCast(value.handle))).*,
+            64 => @as(*const u64, @ptrCast(@alignCast(value.handle))).*,
+            128 => @as(*const u128, @ptrCast(@alignCast(value.handle))).*,
             else => @trap(),
         };
     }
@@ -74,8 +74,8 @@ const Value = extern struct {
             return (handle << extra_bits) >> extra_bits;
         }
         return switch (size) {
-            64 => @as(*const i64, @alignCast(@ptrCast(value.handle))).*,
-            128 => @as(*const i128, @alignCast(@ptrCast(value.handle))).*,
+            64 => @as(*const i64, @ptrCast(@alignCast(value.handle))).*,
+            128 => @as(*const i128, @ptrCast(@alignCast(value.handle))).*,
             else => @trap(),
         };
     }
@@ -92,9 +92,9 @@ const Value = extern struct {
             }, @bitCast(@intFromPtr(value.handle)));
         }
         return @floatCast(switch (size) {
-            64 => @as(*const f64, @alignCast(@ptrCast(value.handle))).*,
-            80 => @as(*const f80, @alignCast(@ptrCast(value.handle))).*,
-            128 => @as(*const f128, @alignCast(@ptrCast(value.handle))).*,
+            64 => @as(*const f64, @ptrCast(@alignCast(value.handle))).*,
+            80 => @as(*const f80, @ptrCast(@alignCast(value.handle))).*,
+            128 => @as(*const f128, @ptrCast(@alignCast(value.handle))).*,
             else => @trap(),
         });
     }
diff --git a/src/InternPool.zig b/src/InternPool.zig
index ed922db74248466ffab511caba41dfa0d335d710..f59bacc1b065d3495132b4d0f19bad6a125d57b2 100644
--- a/src/InternPool.zig
+++ b/src/InternPool.zig
@@ -1365,7 +1365,7 @@ const Local = struct {
                 capacity: u32,
             };
             fn header(list: ListSelf) *Header {
-                return @alignCast(@ptrCast(list.bytes - bytes_offset));
+                return @ptrCast(@alignCast(list.bytes - bytes_offset));
             }
             pub fn view(list: ListSelf) View {
                 const capacity = list.header().capacity;
@@ -1574,7 +1574,7 @@ const Shard = struct {
                 }
             };
             fn header(map: @This()) *Header {
-                return @alignCast(@ptrCast(@as([*]u8, @ptrCast(map.entries)) - entries_offset));
+                return @ptrCast(@alignCast(@as([*]u8, @ptrCast(map.entries)) - entries_offset));
             }
 
             const Entry = extern struct {
diff --git a/src/Package/Fetch.zig b/src/Package/Fetch.zig
index 836435a86bd50a6a83a6c4a0a4eaa9c7351d329a..03593326c4859a1ae4f91efaf4949a6c8eeff4c8 100644
--- a/src/Package/Fetch.zig
+++ b/src/Package/Fetch.zig
@@ -898,7 +898,7 @@ const Resource = union(enum) {
     }
 
     fn read(context: *const anyopaque, buffer: []u8) anyerror!usize {
-        const resource: *Resource = @constCast(@ptrCast(@alignCast(context)));
+        const resource: *Resource = @ptrCast(@alignCast(@constCast(context)));
         switch (resource.*) {
             .file => |*f| return f.read(buffer),
             .http_request => |*r| return r.read(buffer),
diff --git a/src/translate_c.zig b/src/translate_c.zig
index f1f3ad865946c4d045f236af530e3e1861639588..f7457810f2d29b689a1851650840c94967d0b411 100644
--- a/src/translate_c.zig
+++ b/src/translate_c.zig
@@ -4008,11 +4008,11 @@ fn transCreateCompoundAssign(
 }
 
 fn removeCVQualifiers(c: *Context, dst_type_node: Node, expr: Node) Error!Node {
-    const const_casted = try Tag.const_cast.create(c.arena, expr);
-    const volatile_casted = try Tag.volatile_cast.create(c.arena, const_casted);
+    const volatile_casted = try Tag.volatile_cast.create(c.arena, expr);
+    const const_casted = try Tag.const_cast.create(c.arena, volatile_casted);
     return Tag.as.create(c.arena, .{
         .lhs = dst_type_node,
-        .rhs = try Tag.ptr_cast.create(c.arena, volatile_casted),
+        .rhs = try Tag.ptr_cast.create(c.arena, const_casted),
     });
 }
 
diff --git a/test/behavior/array.zig b/test/behavior/array.zig
index 07eb632b1ef640b8b87f68aa2cf21029e6193a36..1eb4c12cbf3fff0a5c7172c1ec51f66b01961de7 100644
--- a/test/behavior/array.zig
+++ b/test/behavior/array.zig
@@ -1091,7 +1091,7 @@ test "initialize pointer to anyopaque with reference to empty array initializer"
     const ptr: *const anyopaque = &.{};
     // The above acts like an untyped initializer, since the `.{}` has no result type.
     // So, `ptr` points in memory to an empty tuple (`@TypeOf(.{})`).
-    const casted: *const @TypeOf(.{}) = @alignCast(@ptrCast(ptr));
+    const casted: *const @TypeOf(.{}) = @ptrCast(@alignCast(ptr));
     const loaded = casted.*;
     // `val` should be a `@TypeOf(.{})`, as expected.
     // We can't check the value, but it's zero-bit, so the type matching is good enough.
diff --git a/test/behavior/comptime_memory.zig b/test/behavior/comptime_memory.zig
index 9e0c378f1b6cde8362ab09a33739ae25d6c7eade..6f772c6cfbd3bebbbb348bd99ac2b8a8ca5cabee 100644
--- a/test/behavior/comptime_memory.zig
+++ b/test/behavior/comptime_memory.zig
@@ -477,7 +477,7 @@ fn GenericIntApplier(
         }
 
         fn typeErasedApplyFn(context: *const anyopaque, arg: u32) void {
-            const ptr: *const Context = @alignCast(@ptrCast(context));
+            const ptr: *const Context = @ptrCast(@alignCast(context));
             applyFn(ptr.*, arg);
         }
     };
diff --git a/test/behavior/extern.zig b/test/behavior/extern.zig
index 62248fc81aa24c98c2d9c6ccbef44d4ab25f7d33..9efb1c2137705b04267877dd81bbbb118b8951a4 100644
--- a/test/behavior/extern.zig
+++ b/test/behavior/extern.zig
@@ -8,7 +8,7 @@ test "anyopaque extern symbol" {
     if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
 
     const a = @extern(*anyopaque, .{ .name = "a_mystery_symbol" });
-    const b: *i32 = @alignCast(@ptrCast(a));
+    const b: *i32 = @ptrCast(@alignCast(a));
     try expect(b.* == 1234);
 }
 
diff --git a/test/cases/compile_errors/nested_ptr_cast_bad_operand.zig b/test/cases/compile_errors/nested_ptr_cast_bad_operand.zig
index ca594aa37a0031b4aad1a85066829655f5e19616..050ad41e74c47d67b3a86dbdc20ca9914f462bdc 100644
--- a/test/cases/compile_errors/nested_ptr_cast_bad_operand.zig
+++ b/test/cases/compile_errors/nested_ptr_cast_bad_operand.zig
@@ -6,7 +6,7 @@ export fn b() void {
     _ = @constCast(@volatileCast(123));
 }
 export fn c() void {
-    const x: ?*f32 = @constCast(@ptrCast(@addrSpaceCast(@volatileCast(p))));
+    const x: ?*f32 = @ptrCast(@addrSpaceCast(@constCast(@volatileCast(p))));
     _ = x;
 }
 
diff --git a/test/translate_c.zig b/test/translate_c.zig
index b83e87060c6f8c5b4bf24ada8785bacec9d31208..6d1a8916f28756940ae44abae3e701e792fc0602 100644
--- a/test/translate_c.zig
+++ b/test/translate_c.zig
@@ -3234,12 +3234,12 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
         \\pub export fn bar(arg_a: [*c]const c_int) void {
         \\    var a = arg_a;
         \\    _ = &a;
-        \\    foo(@as([*c]c_int, @ptrCast(@volatileCast(@constCast(a)))));
+        \\    foo(@as([*c]c_int, @ptrCast(@constCast(@volatileCast(a)))));
         \\}
         \\pub export fn baz(arg_a: [*c]volatile c_int) void {
         \\    var a = arg_a;
         \\    _ = &a;
-        \\    foo(@as([*c]c_int, @ptrCast(@volatileCast(@constCast(a)))));
+        \\    foo(@as([*c]c_int, @ptrCast(@constCast(@volatileCast(a)))));
         \\}
     });