diff --git a/lib/std/compress.zig b/lib/std/compress.zig
index 1d671f1aa63cc66ed1ed7da2d182cb2bea090213..7fa25175d5ed83e5b6077d23e84c86839cc65e74 100644
--- a/lib/std/compress.zig
+++ b/lib/std/compress.zig
@@ -5,7 +5,6 @@ pub const gzip = @import("compress/gzip.zig");
 pub const zlib = @import("compress/zlib.zig");
 
 test {
-    if (@import("builtin").zig_backend != .stage1) return error.SkipZigTest;
     _ = deflate;
     _ = gzip;
     _ = zlib;
diff --git a/lib/std/compress/deflate/compressor.zig b/lib/std/compress/deflate/compressor.zig
index 58b19558381041ec7f3d5de18cecd08194c8c004..50836f2b9af64328ac91e46053d7fe42e07fd7ff 100644
--- a/lib/std/compress/deflate/compressor.zig
+++ b/lib/std/compress/deflate/compressor.zig
@@ -254,7 +254,10 @@ pub fn Compressor(comptime WriterType: anytype) type {
 
         // Inner writer wrapped in a HuffmanBitWriter
         hm_bw: hm_bw.HuffmanBitWriter(WriterType) = undefined,
-        bulk_hasher: fn ([]u8, []u32) u32,
+        bulk_hasher: if (@import("builtin").zig_backend == .stage1)
+            fn ([]u8, []u32) u32
+        else
+            *const fn ([]u8, []u32) u32,
 
         sync: bool, // requesting flush
         best_speed_enc: *fast.DeflateFast, // Encoder for best_speed
diff --git a/lib/std/compress/deflate/compressor_test.zig b/lib/std/compress/deflate/compressor_test.zig
index b35857c731e1cf3a6fe82c4e0cb890849499d422..db07a07064b831f42c11df02af9c49ef09ab3ec0 100644
--- a/lib/std/compress/deflate/compressor_test.zig
+++ b/lib/std/compress/deflate/compressor_test.zig
@@ -122,11 +122,8 @@ fn testToFromWithLevelAndLimit(level: deflate.Compression, input: []const u8, li
         try expect(compressed.items.len <= limit);
     }
 
-    var decomp = try decompressor(
-        testing.allocator,
-        io.fixedBufferStream(compressed.items).reader(),
-        null,
-    );
+    var fib = io.fixedBufferStream(compressed.items);
+    var decomp = try decompressor(testing.allocator, fib.reader(), null);
     defer decomp.deinit();
 
     var decompressed = try testing.allocator.alloc(u8, input.len);
@@ -136,7 +133,9 @@ fn testToFromWithLevelAndLimit(level: deflate.Compression, input: []const u8, li
     try expect(read == input.len);
     try expect(mem.eql(u8, input, decompressed));
 
-    try testSync(level, input);
+    if (builtin.zig_backend == .stage1) {
+        try testSync(level, input);
+    }
 }
 
 fn testToFromWithLimit(input: []const u8, limit: [11]u32) !void {
@@ -180,6 +179,7 @@ test "deflate/inflate" {
 }
 
 test "very long sparse chunk" {
+    if (@import("builtin").zig_backend != .stage1) return error.SkipZigTest;
     // A SparseReader returns a stream consisting of 0s ending with 65,536 (1<<16) 1s.
     // This tests missing hash references in a very large input.
     const SparseReader = struct {
@@ -377,6 +377,7 @@ test "compressor dictionary" {
 // Update the hash for best_speed only if d.index < d.maxInsertIndex
 // See https://golang.org/issue/2508
 test "Go non-regression test for 2508" {
+    if (@import("builtin").zig_backend != .stage1) return error.SkipZigTest;
     var comp = try compressor(
         testing.allocator,
         io.null_writer,
@@ -475,21 +476,16 @@ test "inflate reset" {
         try comp.close();
     }
 
-    var decomp = try decompressor(
-        testing.allocator,
-        io.fixedBufferStream(compressed_strings[0].items).reader(),
-        null,
-    );
+    var fib = io.fixedBufferStream(compressed_strings[0].items);
+    var decomp = try decompressor(testing.allocator, fib.reader(), null);
     defer decomp.deinit();
 
     var decompressed_0: []u8 = try decomp.reader()
         .readAllAlloc(testing.allocator, math.maxInt(usize));
     defer testing.allocator.free(decompressed_0);
 
-    try decomp.reset(
-        io.fixedBufferStream(compressed_strings[1].items).reader(),
-        null,
-    );
+    fib = io.fixedBufferStream(compressed_strings[1].items);
+    try decomp.reset(fib.reader(), null);
 
     var decompressed_1: []u8 = try decomp.reader()
         .readAllAlloc(testing.allocator, math.maxInt(usize));
@@ -530,21 +526,16 @@ test "inflate reset dictionary" {
         try comp.close();
     }
 
-    var decomp = try decompressor(
-        testing.allocator,
-        io.fixedBufferStream(compressed_strings[0].items).reader(),
-        dict,
-    );
+    var fib = io.fixedBufferStream(compressed_strings[0].items);
+    var decomp = try decompressor(testing.allocator, fib.reader(), dict);
     defer decomp.deinit();
 
     var decompressed_0: []u8 = try decomp.reader()
         .readAllAlloc(testing.allocator, math.maxInt(usize));
     defer testing.allocator.free(decompressed_0);
 
-    try decomp.reset(
-        io.fixedBufferStream(compressed_strings[1].items).reader(),
-        dict,
-    );
+    fib = io.fixedBufferStream(compressed_strings[1].items);
+    try decomp.reset(fib.reader(), dict);
 
     var decompressed_1: []u8 = try decomp.reader()
         .readAllAlloc(testing.allocator, math.maxInt(usize));
diff --git a/lib/std/compress/deflate/decompressor.zig b/lib/std/compress/deflate/decompressor.zig
index 937af90d9863a8106db9a21406c87ade5066f00b..a906bb1037ade5d1e728ff95b60d2dbb2ce4d8e9 100644
--- a/lib/std/compress/deflate/decompressor.zig
+++ b/lib/std/compress/deflate/decompressor.zig
@@ -334,7 +334,10 @@ pub fn Decompressor(comptime ReaderType: type) type {
 
         // Next step in the decompression,
         // and decompression state.
-        step: fn (*Self) Error!void,
+        step: if (@import("builtin").zig_backend == .stage1)
+            fn (*Self) Error!void
+        else
+            *const fn (*Self) Error!void,
         step_state: DecompressorState,
         final: bool,
         err: ?Error,
@@ -479,7 +482,13 @@ pub fn Decompressor(comptime ReaderType: type) type {
         }
 
         pub fn close(self: *Self) ?Error {
-            if (self.err == Error.EndOfStreamWithNoError) {
+            if (@import("builtin").zig_backend == .stage1) {
+                if (self.err == Error.EndOfStreamWithNoError) {
+                    return null;
+                }
+                return self.err;
+            }
+            if (self.err == @as(?Error, error.EndOfStreamWithNoError)) {
                 return null;
             }
             return self.err;
@@ -920,7 +929,8 @@ test "truncated input" {
     };
 
     for (tests) |t| {
-        var r = io.fixedBufferStream(t.input).reader();
+        var fib = io.fixedBufferStream(t.input);
+        const r = fib.reader();
         var z = try decompressor(testing.allocator, r, null);
         defer z.deinit();
         var zr = z.reader();
@@ -959,7 +969,8 @@ test "Go non-regression test for 9842" {
     };
 
     for (tests) |t| {
-        const reader = std.io.fixedBufferStream(t.input).reader();
+        var fib = std.io.fixedBufferStream(t.input);
+        const reader = fib.reader();
         var decomp = try decompressor(testing.allocator, reader, null);
         defer decomp.deinit();
 
@@ -1017,7 +1028,8 @@ test "inflate A Tale of Two Cities (1859) intro" {
         \\
     ;
 
-    const reader = std.io.fixedBufferStream(&compressed).reader();
+    var fib = std.io.fixedBufferStream(&compressed);
+    const reader = fib.reader();
     var decomp = try decompressor(testing.allocator, reader, null);
     defer decomp.deinit();
 
@@ -1082,7 +1094,8 @@ test "fuzzing" {
 
 fn decompress(input: []const u8) !void {
     const allocator = testing.allocator;
-    const reader = std.io.fixedBufferStream(input).reader();
+    var fib = std.io.fixedBufferStream(input);
+    const reader = fib.reader();
     var decomp = try decompressor(allocator, reader, null);
     defer decomp.deinit();
     var output = try decomp.reader().readAllAlloc(allocator, math.maxInt(usize));
diff --git a/lib/std/compress/deflate/deflate_fast_test.zig b/lib/std/compress/deflate/deflate_fast_test.zig
index 6a8e9fa421eeac26d1afe0f1f1e2551d3b714822..b3a255e5984a72a530eb73652e6bf9c2aa3a6176 100644
--- a/lib/std/compress/deflate/deflate_fast_test.zig
+++ b/lib/std/compress/deflate/deflate_fast_test.zig
@@ -78,11 +78,8 @@ test "best speed" {
                 var decompressed = try testing.allocator.alloc(u8, want.items.len);
                 defer testing.allocator.free(decompressed);
 
-                var decomp = try inflate.decompressor(
-                    testing.allocator,
-                    io.fixedBufferStream(compressed.items).reader(),
-                    null,
-                );
+                var fib = io.fixedBufferStream(compressed.items);
+                var decomp = try inflate.decompressor(testing.allocator, fib.reader(), null);
                 defer decomp.deinit();
 
                 var read = try decomp.reader().readAll(decompressed);
@@ -122,13 +119,13 @@ test "best speed max match offset" {
                 //	zeros1 is between 0 and 30 zeros.
                 // The difference between the two abc's will be offset, which
                 // is max_match_offset plus or minus a small adjustment.
-                var src_len: usize = @intCast(usize, offset + abc.len + @intCast(i32, extra));
+                var src_len: usize = @intCast(usize, offset + @as(i32, abc.len) + @intCast(i32, extra));
                 var src = try testing.allocator.alloc(u8, src_len);
                 defer testing.allocator.free(src);
 
                 mem.copy(u8, src, abc);
                 if (!do_match_before) {
-                    var src_offset: usize = @intCast(usize, offset - xyz.len);
+                    var src_offset: usize = @intCast(usize, offset - @as(i32, xyz.len));
                     mem.copy(u8, src[src_offset..], xyz);
                 }
                 var src_offset: usize = @intCast(usize, offset);
@@ -149,11 +146,8 @@ test "best speed max match offset" {
                 var decompressed = try testing.allocator.alloc(u8, src.len);
                 defer testing.allocator.free(decompressed);
 
-                var decomp = try inflate.decompressor(
-                    testing.allocator,
-                    io.fixedBufferStream(compressed.items).reader(),
-                    null,
-                );
+                var fib = io.fixedBufferStream(compressed.items);
+                var decomp = try inflate.decompressor(testing.allocator, fib.reader(), null);
                 defer decomp.deinit();
                 var read = try decomp.reader().readAll(decompressed);
                 _ = decomp.close();
diff --git a/lib/std/x.zig b/lib/std/x.zig
index bafcdd54262e73dd464e7d77a22aeb8e4c527121..64caf324ed2f33a5fab8d1cc82507a3f89b26513 100644
--- a/lib/std/x.zig
+++ b/lib/std/x.zig
@@ -13,7 +13,6 @@ pub const net = struct {
 };
 
 test {
-    if (@import("builtin").zig_backend != .stage1) return error.SkipZigTest;
     inline for (.{ os, net }) |module| {
         std.testing.refAllDecls(module);
     }
diff --git a/lib/std/x/os/io.zig b/lib/std/x/os/io.zig
index 35e7c3e1edb1adade94d43c3205abb7dd5abf548..e61d212e52c1feaf840e22367464f86252d892bf 100644
--- a/lib/std/x/os/io.zig
+++ b/lib/std/x/os/io.zig
@@ -117,6 +117,7 @@ pub const Reactor = struct {
 };
 
 test "reactor/linux: drive async tcp client/listener pair" {
+    if (@import("builtin").zig_backend != .stage1) return error.SkipZigTest;
     if (native_os.tag != .linux) return error.SkipZigTest;
 
     const ip = std.x.net.ip;
diff --git a/lib/std/x/os/net.zig b/lib/std/x/os/net.zig
index d4a17f867944e422de4f32bb197f44829abfa084..a7cc8fbc4a47af6c05b0182ab9dfb8a817de16f2 100644
--- a/lib/std/x/os/net.zig
+++ b/lib/std/x/os/net.zig
@@ -381,7 +381,7 @@ pub const IPv6 = extern struct {
             });
         }
 
-        const zero_span = span: {
+        const zero_span: struct { from: usize, to: usize } = span: {
             var i: usize = 0;
             while (i < self.octets.len) : (i += 2) {
                 if (self.octets[i] == 0 and self.octets[i + 1] == 0) break;
diff --git a/src/Sema.zig b/src/Sema.zig
index d9019987556dfc12bac5a69c242eee852220c23c..7dbf3d921fb6ff0ac0c9280efb93aea71071ea31 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -19702,7 +19702,8 @@ fn coerce(
                     // pointer to tuple to slice
                     if (inst_ty.isSinglePointer() and
                         inst_ty.childType().isTuple() and
-                        !dest_info.mutable and dest_info.size == .Slice)
+                        (!dest_info.mutable or inst_ty.ptrIsMutable() or inst_ty.childType().tupleFields().types.len == 0) and
+                        dest_info.size == .Slice)
                     {
                         return sema.coerceTupleToSlicePtrs(block, dest_ty, dest_ty_src, inst, inst_src);
                     }
diff --git a/src/value.zig b/src/value.zig
index 21fe52e7064a343831ab98b21ca5172c3a1e7faf..9c3c8bbfccd018bff8cce1c4fabb0936db8a099f 100644
--- a/src/value.zig
+++ b/src/value.zig
@@ -1062,6 +1062,7 @@ pub const Value = extern union {
         sema_kit: ?Module.WipAnalysis,
     ) Module.CompileError!BigIntConst {
         switch (val.tag()) {
+            .null_value,
             .zero,
             .bool_false,
             .the_only_possible_value, // i0, u0
diff --git a/test/behavior/cast.zig b/test/behavior/cast.zig
index 4ff2c78d471e6007912cb12ffd2ef37e02cc60fc..383b72e046182db6c4a92cf30e56cd6db7a787db 100644
--- a/test/behavior/cast.zig
+++ b/test/behavior/cast.zig
@@ -1426,6 +1426,7 @@ test "coerce undefined single-item pointer of array to error union of slice" {
 }
 
 test "pointer to empty struct literal to mutable slice" {
+    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
     var x: []i32 = &.{};
     try expect(x.len == 0);
 }