Commit 9c16b2370d

@@ -10,9 +10,11 @@ test "test calling @clz on both vector and scalar inputs" {
     if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
 
     var x: u32 = 0x1;
+    _ = &x;
     var y: @Vector(4, u32) = [_]u32{ 0x1, 0x1, 0x1, 0x1 };
-    var a = @clz(x);
-    var b = @clz(y);
+    _ = &y;
+    const a = @clz(x);
+    const b = @clz(y);
     try std.testing.expectEqual(@as(u6, 31), a);
     try std.testing.expectEqual([_]u6{ 31, 31, 31, 31 }, b);
 }

@@ -9,6 +9,7 @@ test "breaking from a loop in an if statement" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     var cond = true;
+    _ = &cond;
     const opt = while (cond) {
         if (retOpt()) |opt| {
             break opt;

@@ -2,6 +2,7 @@ const builtin = @import("builtin");
 
 fn foo() !void {
     var a = true;
+    _ = &a;
     if (a) return error.Foo;
     return error.Bar;
 }

@@ -21,5 +21,6 @@ fn storeArrayOfArrayOfStructs() u8 {
             S{ .x = 15 },
         },
     };
+    _ = &cases;
     return cases[0][0].x;
 }

@@ -4,7 +4,7 @@ const builtin = @import("builtin");
 test {
     const T = @TypeOf(.{ @as(i32, 0), @as(u32, 0) });
     var a: T = .{ 0, 0 };
-    _ = a;
+    _ = &a;
 }
 
 test {
@@ -13,7 +13,7 @@ test {
         comptime y: u32 = 0,
     };
     var a: S = .{};
-    _ = a;
+    _ = &a;
     var b = S{};
-    _ = b;
+    _ = &b;
 }

@@ -6,8 +6,9 @@ test "aggregate initializers should allow initializing comptime fields, verifyin
     if (true) return error.SkipZigTest; // TODO
 
     var x: u32 = 15;
+    _ = &x;
     const T = @TypeOf(.{ @as(i32, -1234), @as(u32, 5678), x });
-    var a: T = .{ -1234, 5678, x + 1 };
+    const a: T = .{ -1234, 5678, x + 1 };
 
     try expect(a[0] == -1234);
     try expect(a[1] == 5678);

@@ -18,7 +18,7 @@ test "bytes" {
     };
 
     var u_2 = U{ .s = s_1 };
-    _ = u_2;
+    _ = &u_2;
 }
 
 test "aggregate" {
@@ -40,5 +40,5 @@ test "aggregate" {
     };
 
     var u_2 = U{ .s = s_1 };
-    _ = u_2;
+    _ = &u_2;
 }

@@ -21,5 +21,5 @@ test "var inferred array of slices" {
             .{ .v = false },
         },
     };
-    _ = decls;
+    _ = &decls;
 }

@@ -11,5 +11,6 @@ test {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
 
     var t: T = .{ .next = null };
+    _ = &t;
     try std.testing.expect(t.next == null);
 }

@@ -5,6 +5,7 @@ test {
         .foo = &1,
         .bar = &2,
     };
+    _ = &st;
 
     inline for (@typeInfo(@TypeOf(st)).Struct.fields) |field| {
         _ = field;

@@ -19,6 +19,7 @@ test {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
 
     var baz: u32 = 24;
+    _ = &baz;
     try takeFoo(&.{
         .a = .{
             .b = baz,

@@ -4,5 +4,6 @@ const expect = std.testing.expect;
 const S = struct { a: usize };
 test "lazy abi size used in comparison" {
     var rhs: i32 = 100;
+    _ = &rhs;
     try expect(@sizeOf(S) < rhs);
 }

@@ -22,6 +22,7 @@ const CPU = packed struct {
     }
     fn tick(self: *CPU) !void {
         var queued_interrupts = self.ram.get(0xFFFF) & self.ram.get(0xFF0F);
+        _ = &queued_interrupts;
         if (self.interrupts and queued_interrupts != 0) {
             self.interrupts = false;
         }

@@ -4,26 +4,31 @@ const builtin = @import("builtin");
 test "issue12891" {
     const f = 10.0;
     var i: usize = 0;
+    _ = &i;
     try std.testing.expect(i < f);
 }
 test "nan" {
     const f = comptime std.math.nan(f64);
     var i: usize = 0;
+    _ = &i;
     try std.testing.expect(!(f < i));
 }
 test "inf" {
     const f = comptime std.math.inf(f64);
     var i: usize = 0;
+    _ = &i;
     try std.testing.expect(f > i);
 }
 test "-inf < 0" {
     const f = comptime -std.math.inf(f64);
     var i: usize = 0;
+    _ = &i;
     try std.testing.expect(f < i);
 }
 test "inf >= 1" {
     const f = comptime std.math.inf(f64);
     var i: usize = 1;
+    _ = &i;
     try std.testing.expect(f >= i);
 }
 test "isNan(nan * 1)" {

@@ -12,6 +12,7 @@ test {
     f(&.{c});
 
     var v: u8 = 42;
+    _ = &v;
     f(&[_:null]?u8{v});
     f(&.{v});
 }

@@ -16,5 +16,5 @@ test "simple test" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
 
     var c: CustomDraw = undefined;
-    _ = c;
+    _ = &c;
 }

@@ -18,6 +18,7 @@ test "runtime union init, most-aligned field != largest" {
     if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
 
     var x: u8 = 1;
+    _ = &x;
     try foo(.{ .x = x });
 
     const val: U = @unionInit(U, "x", x);

@@ -13,5 +13,6 @@ test {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     var foo = Bar.Baz.fizz;
+    _ = &foo;
     try expect(foo == .fizz);
 }

@@ -8,7 +8,7 @@ test {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     var a: Crasher = undefined;
-    var crasher_ptr = &a;
+    const crasher_ptr = &a;
     var crasher_local = crasher_ptr.*;
     const crasher_local_ptr = &crasher_local;
     crasher_local_ptr.lets_crash = 1;

@@ -18,9 +18,11 @@ test {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
 
     var a: u32 = 16;
+    _ = &a;
     var reason = .{ .c_import = .{ .a = a } };
     var block = Block{
         .reason = &reason,
     };
+    _ = █
     try expect(block.reason.?.c_import.a == 16);
 }

@@ -1,4 +1,5 @@
 comptime {
     var image: [1]u8 = undefined;
+    _ = ℑ
     _ = @shlExact(@as(u16, image[0]), 8);
 }

@@ -9,5 +9,6 @@ test {
     if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
 
     var a: u8 = 0;
+    _ = &a;
     try std.io.null_writer.print("\n{} {}\n", .{ a, S{} });
 }

@@ -20,6 +20,7 @@ test "union that needs padding bytes inside an array" {
         A{ .B = B{ .D = 1 } },
         A{ .B = B{ .D = 1 } },
     };
+    _ = &as;
 
     const a = as[0].B;
     try std.testing.expect(a.D == 1);

@@ -12,5 +12,6 @@ test "const error union field alignment" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     var union_or_err: anyerror!Union = Union{ .Color = 1234 };
+    _ = &union_or_err;
     try std.testing.expect((union_or_err catch unreachable).Color == 1234);
 }

@@ -8,6 +8,7 @@ const B = *const fn (A) void;
 test "allow these dependencies" {
     var a: A = undefined;
     var b: B = undefined;
+    _ = .{ &a, &b };
     if (false) {
         a;
         b;

@@ -45,6 +45,6 @@ test "initialization" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
-    var t = a.init();
+    const t = a.init();
     try std.testing.expect(t.foo.len == 0);
 }

@@ -2,5 +2,5 @@ test {
     var a = if (true) {
         return;
     } else true;
-    _ = a;
+    _ = &a;
 }

@@ -3,4 +3,5 @@ test "pointer deref next to assignment" {
     var a:i32=2;
     var b=&a;
     b.*=3;
+    _=&b;
 }

@@ -12,5 +12,5 @@ test "fixed" {
     var ctr = Container{
         .params = NoteParams{},
     };
-    _ = ctr;
+    _ = &ctr;
 }

@@ -11,6 +11,7 @@ test "fixed" {
             .max_distance_from_start_index = 456,
         },
     };
+    _ = &s;
     try std.testing.expect(s.a == 1);
     try std.testing.expect(s.b.size == 123);
     try std.testing.expect(s.b.max_distance_from_start_index == 456);

@@ -6,6 +6,7 @@ fn getError() !void {
 
 fn getError2() !void {
     var a: u8 = 'c';
+    _ = &a;
     try if (a == 'a') getError() else if (a == 'b') getError() else getError();
 }
 

@@ -25,5 +25,6 @@ test "foo" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     var allocator = ContextAllocator{ .n = 10 };
+    _ = &allocator;
     try expect(allocator.n == 10);
 }

@@ -22,6 +22,7 @@ fn foo(a: bool, b: bool) !void {
     var prefix_op = PrefixOp{
         .AddrOf = Value{ .align_expr = 1234 },
     };
+    _ = &prefix_op;
     if (a) {} else {
         switch (prefix_op) {
             PrefixOp.AddrOf => |addr_of_info| {

@@ -51,7 +51,8 @@ pub const JournalHeader = packed struct {
             return @as(u128, @bitCast(target[0..hash_chain_root_size].*));
         } else {
             var array = target[0..hash_chain_root_size].*;
-            return @as(u128, @bitCast(array));
+            _ = &array;
+            return @bitCast(array);
         }
     }
 

@@ -14,5 +14,6 @@ const Element = struct {
 test "false dependency loop in struct definition" {
     const listType = ElementList;
     var x: listType = 42;
+    _ = &x;
     try expect(x == 42);
 }

@@ -6,13 +6,15 @@ test "sentinel-terminated 0-length slices" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
 
-    var u32s: [4]u32 = [_]u32{ 0, 1, 2, 3 };
+    const u32s: [4]u32 = [_]u32{ 0, 1, 2, 3 };
 
     var index: u8 = 2;
-    var slice = u32s[index..index :2];
-    var array_ptr = u32s[2..2 :2];
+    _ = &index;
+    const slice = u32s[index..index :2];
+    const array_ptr = u32s[2..2 :2];
     const comptime_known_array_value = u32s[2..2 :2].*;
     var runtime_array_value = u32s[2..2 :2].*;
+    _ = &runtime_array_value;
 
     try expect(slice[0] == 2);
     try expect(array_ptr[0] == 2);

@@ -5,7 +5,7 @@ const expect = std.testing.expect;
 test "miscompilation with bool return type" {
     var x: usize = 1;
     var y: bool = getFalse();
-    _ = y;
+    _ = .{ &x, &y };
 
     try expect(x == 1);
 }

@@ -7,7 +7,8 @@ test "@ptrCast from const to nullable" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     const c: u8 = 4;
-    var x: ?*const u8 = @as(?*const u8, @ptrCast(&c));
+    var x: ?*const u8 = @ptrCast(&c);
+    _ = &x;
     try expect(x.?.* == 4);
 }
 
@@ -19,6 +20,7 @@ test "@ptrCast from var in empty struct to nullable" {
     const container = struct {
         var c: u8 = 4;
     };
-    var x: ?*const u8 = @as(?*const u8, @ptrCast(&container.c));
+    var x: ?*const u8 = @ptrCast(&container.c);
+    _ = &x;
     try expect(x.?.* == 4);
 }

@@ -85,6 +85,7 @@ test {
     var param: ParamType = .{
         .one_of = .{ .name = "name" },
     };
+    _ = &param;
     var arg: CallArg = .{
         .value = .{
             .literal_enum_value = .{
@@ -92,6 +93,7 @@ test {
             },
         },
     };
+    _ = &arg;
 
     const result = try genExpression(arg.value);
     switch (result) {

@@ -60,6 +60,7 @@ test {
         .g = false,
         .h = false,
     };
+    _ = &flags;
     var x = X{
         .x = flags,
     };

@@ -16,26 +16,32 @@ test "@abs integers" {
 fn testAbsIntegers() !void {
     {
         var x: i32 = -1000;
+        _ = &x;
         try expect(@abs(x) == 1000);
     }
     {
         var x: i32 = 0;
+        _ = &x;
         try expect(@abs(x) == 0);
     }
     {
         var x: i32 = 1000;
+        _ = &x;
         try expect(@abs(x) == 1000);
     }
     {
         var x: i64 = std.math.minInt(i64);
+        _ = &x;
         try expect(@abs(x) == @as(u64, -std.math.minInt(i64)));
     }
     {
         var x: i5 = -1;
+        _ = &x;
         try expect(@abs(x) == 1);
     }
     {
         var x: i5 = -5;
+        _ = &x;
         try expect(@abs(x) == 5);
     }
     comptime {
@@ -56,22 +62,27 @@ test "@abs unsigned integers" {
 fn testAbsUnsignedIntegers() !void {
     {
         var x: u32 = 1000;
+        _ = &x;
         try expect(@abs(x) == 1000);
     }
     {
         var x: u32 = 0;
+        _ = &x;
         try expect(@abs(x) == 0);
     }
     {
         var x: u32 = 1000;
+        _ = &x;
         try expect(@abs(x) == 1000);
     }
     {
         var x: u5 = 1;
+        _ = &x;
         try expect(@abs(x) == 1);
     }
     {
         var x: u5 = 5;
+        _ = &x;
         try expect(@abs(x) == 5);
     }
     comptime {
@@ -102,27 +113,33 @@ test "@abs floats" {
 fn testAbsFloats(comptime T: type) !void {
     {
         var x: T = -2.62;
+        _ = &x;
         try expect(@abs(x) == 2.62);
     }
     {
         var x: T = 2.62;
+        _ = &x;
         try expect(@abs(x) == 2.62);
     }
     {
         var x: T = 0.0;
+        _ = &x;
         try expect(@abs(x) == 0.0);
     }
     {
         var x: T = -std.math.pi;
+        _ = &x;
         try expect(@abs(x) == std.math.pi);
     }
 
     {
         var x: T = -std.math.inf(T);
+        _ = &x;
         try expect(@abs(x) == std.math.inf(T));
     }
     {
         var x: T = std.math.inf(T);
+        _ = &x;
         try expect(@abs(x) == std.math.inf(T));
     }
     comptime {
@@ -164,31 +181,37 @@ fn testAbsIntVectors(comptime len: comptime_int) !void {
     {
         var x: I32 = @splat(-10);
         var y: U32 = @splat(10);
+        _ = .{ &x, &y };
         try expect(std.mem.eql(u32, &@as([len]u32, y), &@as([len]u32, @abs(x))));
     }
     {
         var x: I32 = @splat(10);
         var y: U32 = @splat(10);
+        _ = .{ &x, &y };
         try expect(std.mem.eql(u32, &@as([len]u32, y), &@as([len]u32, @abs(x))));
     }
     {
         var x: I32 = @splat(0);
         var y: U32 = @splat(0);
+        _ = .{ &x, &y };
         try expect(std.mem.eql(u32, &@as([len]u32, y), &@as([len]u32, @abs(x))));
     }
     {
         var x: I64 = @splat(-10);
         var y: U64 = @splat(10);
+        _ = .{ &x, &y };
         try expect(std.mem.eql(u64, &@as([len]u64, y), &@as([len]u64, @abs(x))));
     }
     {
         var x: I64 = @splat(std.math.minInt(i64));
         var y: U64 = @splat(-std.math.minInt(i64));
+        _ = .{ &x, &y };
         try expect(std.mem.eql(u64, &@as([len]u64, y), &@as([len]u64, @abs(x))));
     }
     {
         var x = std.simd.repeat(len, @Vector(4, i32){ -2, 5, std.math.minInt(i32), -7 });
         var y = std.simd.repeat(len, @Vector(4, u32){ 2, 5, -std.math.minInt(i32), 7 });
+        _ = .{ &x, &y };
         try expect(std.mem.eql(u32, &@as([len]u32, y), &@as([len]u32, @abs(x))));
     }
 }
@@ -225,26 +248,31 @@ fn testAbsUnsignedIntVectors(comptime len: comptime_int) !void {
     {
         var x: U32 = @splat(10);
         var y: U32 = @splat(10);
+        _ = .{ &x, &y };
         try expect(std.mem.eql(u32, &@as([len]u32, y), &@as([len]u32, @abs(x))));
     }
     {
         var x: U32 = @splat(10);
         var y: U32 = @splat(10);
+        _ = .{ &x, &y };
         try expect(std.mem.eql(u32, &@as([len]u32, y), &@as([len]u32, @abs(x))));
     }
     {
         var x: U32 = @splat(0);
         var y: U32 = @splat(0);
+        _ = .{ &x, &y };
         try expect(std.mem.eql(u32, &@as([len]u32, y), &@as([len]u32, @abs(x))));
     }
     {
         var x: U64 = @splat(10);
         var y: U64 = @splat(10);
+        _ = .{ &x, &y };
         try expect(std.mem.eql(u64, &@as([len]u64, y), &@as([len]u64, @abs(x))));
     }
     {
         var x = std.simd.repeat(len, @Vector(3, u32){ 2, 5, 7 });
         var y = std.simd.repeat(len, @Vector(3, u32){ 2, 5, 7 });
+        _ = .{ &x, &y };
         try expect(std.mem.eql(u32, &@as([len]u32, y), &@as([len]u32, @abs(x))));
     }
 }
@@ -346,26 +374,31 @@ fn testAbsFloatVectors(comptime T: type, comptime len: comptime_int) !void {
     {
         var x: V = @splat(-7.5);
         var y: V = @splat(7.5);
+        _ = .{ &x, &y };
         try expect(std.mem.eql(T, &@as([len]T, y), &@as([len]T, @abs(x))));
     }
     {
         var x: V = @splat(7.5);
         var y: V = @splat(7.5);
+        _ = .{ &x, &y };
         try expect(std.mem.eql(T, &@as([len]T, y), &@as([len]T, @abs(x))));
     }
     {
         var x: V = @splat(0.0);
         var y: V = @splat(0.0);
+        _ = .{ &x, &y };
         try expect(std.mem.eql(T, &@as([len]T, y), &@as([len]T, @abs(x))));
     }
     {
         var x: V = @splat(-std.math.pi);
         var y: V = @splat(std.math.pi);
+        _ = .{ &x, &y };
         try expect(std.mem.eql(T, &@as([len]T, y), &@as([len]T, @abs(x))));
     }
     {
         var x: V = @splat(std.math.pi);
         var y: V = @splat(std.math.pi);
+        _ = .{ &x, &y };
         try expect(std.mem.eql(T, &@as([len]T, y), &@as([len]T, @abs(x))));
     }
 }

@@ -29,6 +29,7 @@ test "slicing array of length 1 can not assume runtime index is always zero" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     var runtime_index: usize = 1;
+    _ = &runtime_index;
     const slice = @as(*align(4) [1]u8, &foo)[runtime_index..];
     try expect(@TypeOf(slice) == []u8);
     try expect(slice.len == 0);
@@ -438,6 +439,7 @@ test "runtime-known array index has best alignment possible" {
     // because pointer is align 2 and u32 align % 2 == 0 we can assume align 2
     var smaller align(2) = [_]u32{ 1, 2, 3, 4 };
     var runtime_zero: usize = 0;
+    _ = &runtime_zero;
     comptime assert(@TypeOf(smaller[runtime_zero..]) == []align(2) u32);
     comptime assert(@TypeOf(smaller[runtime_zero..].ptr) == [*]align(2) u32);
     try testIndex(smaller[runtime_zero..].ptr, 0, *align(2) u32);
@@ -464,6 +466,7 @@ test "alignment of function with c calling convention" {
     const a = @alignOf(@TypeOf(nothing));
 
     var runtime_nothing = &nothing;
+    _ = &runtime_nothing;
     const casted1: *align(a) const u8 = @ptrCast(runtime_nothing);
     const casted2: *const fn () callconv(.C) void = @ptrCast(casted1);
     casted2();
@@ -486,6 +489,7 @@ test "read 128-bit field from default aligned struct in stack memory" {
         .nevermind = 1,
         .badguy = 12,
     };
+    _ = &default_aligned;
     try expect(12 == default_aligned.badguy);
 }
 
@@ -579,10 +583,10 @@ test "comptime alloc alignment" {
     if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
 
     comptime var bytes1 = [_]u8{0};
-    _ = bytes1;
+    _ = &bytes1;
 
     comptime var bytes2 align(256) = [_]u8{0};
-    var bytes2_addr = @intFromPtr(&bytes2);
+    const bytes2_addr = @intFromPtr(&bytes2);
     try expect(bytes2_addr & 0xff == 0);
 }
 
@@ -591,6 +595,7 @@ test "@alignCast null" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     var ptr: ?*anyopaque = null;
+    _ = &ptr;
     const aligned: ?*anyopaque = @alignCast(ptr);
     try expect(aligned == null);
 }
@@ -637,6 +642,7 @@ test "alignment of zero-bit types is respected" {
     var s32: S align(32) = .{};
 
     var zero: usize = 0;
+    _ = &zero;
 
     try expect(@intFromPtr(&s) % @alignOf(usize) == 0);
     try expect(@intFromPtr(&s.arr) % @alignOf(usize) == 0);

@@ -31,6 +31,7 @@ test "correct alignment for elements and slices of aligned array" {
     var buf: [1024]u8 align(64) = undefined;
     var start: usize = 1;
     var end: usize = undefined;
+    _ = .{ &start, &end };
     try expect(@alignOf(@TypeOf(buf[start..end])) == @alignOf(*u8));
     try expect(@alignOf(@TypeOf(&buf[start..end])) == @alignOf(*u8));
     try expect(@alignOf(@TypeOf(&buf[start])) == @alignOf(*u8));

@@ -138,6 +138,7 @@ test "array literal with specified size" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     var array = [2]u8{ 1, 2 };
+    _ = &array;
     try expect(array[0] == 1);
     try expect(array[1] == 2);
 }
@@ -146,7 +147,7 @@ test "array len field" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     var arr = [4]u8{ 0, 0, 0, 0 };
-    var ptr = &arr;
+    const ptr = &arr;
     try expect(arr.len == 4);
     try comptime expect(arr.len == 4);
     try expect(ptr.len == 4);
@@ -163,7 +164,8 @@ test "array with sentinels" {
             {
                 var zero_sized: [0:0xde]u8 = [_:0xde]u8{};
                 try expect(zero_sized[0] == 0xde);
-                var reinterpreted = @as(*[1]u8, @ptrCast(&zero_sized));
+                var reinterpreted: *[1]u8 = @ptrCast(&zero_sized);
+                _ = &reinterpreted;
                 try expect(reinterpreted[0] == 0xde);
             }
             var arr: [3:0x55]u8 = undefined;
@@ -225,6 +227,7 @@ test "implicit comptime in array type size" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     var arr: [plusOne(10)]bool = undefined;
+    _ = &arr;
     try expect(arr.len == 11);
 }
 
@@ -281,6 +284,7 @@ test "anonymous list literal syntax" {
     const S = struct {
         fn doTheTest() !void {
             var array: [4]u8 = .{ 1, 2, 3, 4 };
+            _ = &array;
             try expect(array[0] == 1);
             try expect(array[1] == 2);
             try expect(array[2] == 3);
@@ -365,6 +369,7 @@ test "runtime initialize array elem and then implicit cast to slice" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     var two: i32 = 2;
+    _ = &two;
     const x: []const i32 = &[_]i32{two};
     try expect(x[0] == 2);
 }
@@ -472,6 +477,7 @@ test "anonymous literal in array" {
                 .{ .a = 3 },
                 .{ .b = 3 },
             };
+            _ = &array;
             try expect(array[0].a == 3);
             try expect(array[0].b == 4);
             try expect(array[1].a == 2);
@@ -489,8 +495,10 @@ test "access the null element of a null terminated array" {
     const S = struct {
         fn doTheTest() !void {
             var array: [4:0]u8 = .{ 'a', 'o', 'e', 'u' };
+            _ = &array;
             try expect(array[4] == 0);
             var len: usize = 4;
+            _ = &len;
             try expect(array[len] == 0);
         }
     };
@@ -510,6 +518,7 @@ test "type deduction for array subscript expression" {
             try expect(@as(u8, 0xAA) == array[if (v0) 1 else 0]);
             var v1 = false;
             try expect(@as(u8, 0x55) == array[if (v1) 1 else 0]);
+            _ = .{ &array, &v0, &v1 };
         }
     };
     try S.doTheTest();
@@ -529,7 +538,7 @@ test "sentinel element count towards the ABI size calculation" {
                 fill_post: u8 = 0xAA,
             };
             var x = T{};
-            var as_slice = mem.asBytes(&x);
+            const as_slice = mem.asBytes(&x);
             try expect(@as(usize, 3) == as_slice.len);
             try expect(@as(u8, 0x55) == as_slice[0]);
             try expect(@as(u8, 0xAA) == as_slice[2]);
@@ -559,6 +568,7 @@ test "zero-sized array with recursive type definition" {
     };
 
     var t: S = .{ .list = .{ .s = undefined } };
+    _ = &t;
     try expect(@as(usize, 0) == t.list.x);
 }
 
@@ -576,15 +586,17 @@ test "type coercion of anon struct literal to array" {
 
         fn doTheTest() !void {
             var x1: u8 = 42;
+            _ = &x1;
             const t1 = .{ x1, 56, 54 };
-            var arr1: [3]u8 = t1;
+            const arr1: [3]u8 = t1;
             try expect(arr1[0] == 42);
             try expect(arr1[1] == 56);
             try expect(arr1[2] == 54);
 
             var x2: U = .{ .a = 42 };
+            _ = &x2;
             const t2 = .{ x2, .{ .b = true }, .{ .c = "hello" } };
-            var arr2: [3]U = t2;
+            const arr2: [3]U = t2;
             try expect(arr2[0].a == 42);
             try expect(arr2[1].b == true);
             try expect(mem.eql(u8, arr2[2].c, "hello"));
@@ -608,15 +620,17 @@ test "type coercion of pointer to anon struct literal to pointer to array" {
 
         fn doTheTest() !void {
             var x1: u8 = 42;
+            _ = &x1;
             const t1 = &.{ x1, 56, 54 };
-            var arr1: *const [3]u8 = t1;
+            const arr1: *const [3]u8 = t1;
             try expect(arr1[0] == 42);
             try expect(arr1[1] == 56);
             try expect(arr1[2] == 54);
 
             var x2: U = .{ .a = 42 };
+            _ = &x2;
             const t2 = &.{ x2, .{ .b = true }, .{ .c = "hello" } };
-            var arr2: *const [3]U = t2;
+            const arr2: *const [3]U = t2;
             try expect(arr2[0].a == 42);
             try expect(arr2[1].b == true);
             try expect(mem.eql(u8, arr2[2].c, "hello"));
@@ -656,6 +670,7 @@ test "array init of container level array variable" {
         }
         noinline fn bar(x: usize, y: usize) void {
             var tmp: [2]usize = .{ x, y };
+            _ = &tmp;
             pair = tmp;
         }
     };
@@ -668,6 +683,7 @@ test "array init of container level array variable" {
 
 test "runtime initialized sentinel-terminated array literal" {
     var c: u16 = 300;
+    _ = &c;
     const f = &[_:0x9999]u16{c};
     const g = @as(*const [4]u8, @ptrCast(f));
     try std.testing.expect(g[2] == 0x99);
@@ -681,6 +697,7 @@ test "array of array agregate init" {
 
     var a = [1]u32{11} ** 10;
     var b = [1][10]u32{a} ** 2;
+    _ = .{ &a, &b };
     try std.testing.expect(b[1][1] == 11);
 }
 
@@ -778,6 +795,7 @@ test "runtime side-effects in comptime-known array init" {
 test "slice initialized through reference to anonymous array init provides result types" {
     var my_u32: u32 = 123;
     var my_u64: u64 = 456;
+    _ = .{ &my_u32, &my_u64 };
     const foo: []const u16 = &.{
         @intCast(my_u32),
         @intCast(my_u64),
@@ -790,6 +808,7 @@ test "slice initialized through reference to anonymous array init provides resul
 test "pointer to array initialized through reference to anonymous array init provides result types" {
     var my_u32: u32 = 123;
     var my_u64: u64 = 456;
+    _ = .{ &my_u32, &my_u64 };
     const foo: *const [4]u16 = &.{
         @intCast(my_u32),
         @intCast(my_u64),

@@ -180,6 +180,7 @@ test "asm modifiers (AArch64)" {
     if (builtin.zig_backend == .stage2_c and builtin.os.tag == .windows) return error.SkipZigTest; // MSVC doesn't support inline assembly
 
     var x: u32 = 15;
+    _ = &x;
     const double = asm ("add %[ret:w], %[in:w], %[in:w]"
         : [ret] "=r" (-> u32),
         : [in] "r" (x),

@@ -137,11 +137,13 @@ test "@frameSize" {
         fn doTheTest() !void {
             {
                 var ptr = @as(fn (i32) callconv(.Async) void, @ptrCast(other));
+                _ = &ptr;
                 const size = @frameSize(ptr);
                 try expect(size == @sizeOf(@Frame(other)));
             }
             {
                 var ptr = @as(fn () callconv(.Async) void, @ptrCast(first));
+                _ = &ptr;
                 const size = @frameSize(ptr);
                 try expect(size == @sizeOf(@Frame(first)));
             }
@@ -153,7 +155,7 @@ test "@frameSize" {
         fn other(param: i32) void {
             _ = param;
             var local: i32 = undefined;
-            _ = local;
+            _ = &local;
             suspend {}
         }
     };
@@ -239,7 +241,7 @@ test "coroutine await" {
 
     await_seq('a');
     var p = async await_amain();
-    _ = p;
+    _ = &p;
     await_seq('f');
     resume await_a_promise;
     await_seq('i');
@@ -279,7 +281,7 @@ test "coroutine await early return" {
 
     early_seq('a');
     var p = async early_amain();
-    _ = p;
+    _ = &p;
     early_seq('f');
     try expect(early_final_result == 1234);
     try expect(std.mem.eql(u8, &early_points, "abcdef"));
@@ -329,6 +331,7 @@ test "async fn pointer in a struct field" {
         bar: fn (*i32) callconv(.Async) void,
     };
     var foo = Foo{ .bar = simpleAsyncFn2 };
+    _ = &foo;
     var bytes: [64]u8 align(16) = undefined;
     const f = @asyncCall(&bytes, {}, foo.bar, .{&data});
     try comptime expect(@TypeOf(f) == anyframe->void);
@@ -367,6 +370,7 @@ test "@asyncCall with return type" {
         }
     };
     var foo = Foo{ .bar = Foo.middle };
+    _ = &foo;
     var bytes: [150]u8 align(16) = undefined;
     var aresult: i32 = 0;
     _ = @asyncCall(&bytes, &aresult, foo.bar, .{});
@@ -385,6 +389,7 @@ test "async fn with inferred error set" {
         fn doTheTest() !void {
             var frame: [1]@Frame(middle) = undefined;
             var fn_ptr = middle;
+            _ = &fn_ptr;
             var result: @typeInfo(@typeInfo(@TypeOf(fn_ptr)).Fn.return_type.?).ErrorUnion.error_set!void = undefined;
             _ = @asyncCall(std.mem.sliceAsBytes(frame[0..]), &result, fn_ptr, .{});
             resume global_frame;
@@ -827,7 +832,7 @@ test "alignment of local variables in async functions" {
     const S = struct {
         fn doTheTest() !void {
             var y: u8 = 123;
-            _ = y;
+            _ = &y;
             var x: u8 align(128) = 1;
             try expect(@intFromPtr(&x) % 128 == 0);
         }
@@ -843,7 +848,7 @@ test "no reason to resolve frame still works" {
 }
 fn simpleNothing() void {
     var x: i32 = 1234;
-    _ = x;
+    _ = &x;
 }
 
 test "async call a generic function" {
@@ -913,13 +918,14 @@ test "struct parameter to async function is copied to the frame" {
             if (x == 0) return;
             clobberStack(x - 1);
             var y: i32 = x;
-            _ = y;
+            _ = &y;
         }
 
         fn bar(f: *@Frame(foo)) void {
             var pt = Point{ .x = 1, .y = 2 };
+            _ = &pt;
             f.* = async foo(pt);
-            var result = await f;
+            const result = await f;
             expect(result == 1) catch @panic("test failure");
         }
 
@@ -1141,6 +1147,7 @@ test "@asyncCall using the result location inside the frame" {
         bar: fn (*i32) callconv(.Async) i32,
     };
     var foo = Foo{ .bar = S.simple2 };
+    _ = &foo;
     var bytes: [64]u8 align(16) = undefined;
     const f = @asyncCall(&bytes, {}, foo.bar, .{&data});
     try comptime expect(@TypeOf(f) == anyframe->i32);
@@ -1465,7 +1472,7 @@ test "spill target expr in a for loop, with a var decl in the loop body" {
                 // the for loop spills still happen even though there is a VarDecl in scope
                 // before the suspend.
                 var anything = true;
-                _ = anything;
+                _ = &anything;
                 suspend {
                     global_frame = @frame();
                 }
@@ -1538,6 +1545,7 @@ test "async function passed align(16) arg after align(8) arg" {
 
         fn foo() void {
             var a: u128 = 99;
+            _ = &a;
             bar(10, .{a}) catch unreachable;
         }
 
@@ -1590,6 +1598,7 @@ test "async function call resolves target fn frame, runtime func" {
             const stack_size = 1000;
             var stack_frame: [stack_size]u8 align(std.Target.stack_align) = undefined;
             var func: fn () callconv(.Async) anyerror!void = bar;
+            _ = &func;
             return await @asyncCall(&stack_frame, {}, func, .{});
         }
 
@@ -1614,6 +1623,7 @@ test "properly spill optional payload capture value" {
 
         fn foo() void {
             var opt: ?usize = 1234;
+            _ = &opt;
             if (opt) |x| {
                 bar();
                 global_int += x;
@@ -1863,6 +1873,7 @@ test "@asyncCall with pass-by-value arguments" {
     var buffer: [1024]u8 align(@alignOf(@Frame(S.f))) = undefined;
     // The function pointer must not be comptime-known.
     var t = S.f;
+    _ = &t;
     var frame_ptr = @asyncCall(&buffer, {}, t, .{
         F0,
         .{ .f0 = 1, .f1 = 2 },
@@ -1870,7 +1881,7 @@ test "@asyncCall with pass-by-value arguments" {
         [_]u8{ 1, 2, 3, 4, 5 },
         F2,
     });
-    _ = frame_ptr;
+    _ = &frame_ptr;
 }
 
 test "@asyncCall with arguments having non-standard alignment" {
@@ -1893,6 +1904,7 @@ test "@asyncCall with arguments having non-standard alignment" {
     var buffer: [1024]u8 align(@alignOf(@Frame(S.f))) = undefined;
     // The function pointer must not be comptime-known.
     var t = S.f;
+    _ = &t;
     var frame_ptr = @asyncCall(&buffer, {}, t, .{ F0, undefined, F1 });
-    _ = frame_ptr;
+    _ = &frame_ptr;
 }

@@ -14,7 +14,7 @@ test "coroutine await struct" {
 
     await_seq('a');
     var p = async await_amain();
-    _ = p;
+    _ = &p;
     await_seq('f');
     resume await_a_promise;
     await_seq('i');

@@ -118,6 +118,7 @@ fn thisIsAColdFn() void {
 
 test "unicode escape in character literal" {
     var a: u24 = '\u{01f4a9}';
+    _ = &a;
     try expect(a == 128169);
 }
 
@@ -362,6 +363,7 @@ test "variable is allowed to be a pointer to an opaque type" {
 }
 fn hereIsAnOpaqueType(ptr: *OpaqueA) *OpaqueA {
     var a = ptr;
+    _ = &a;
     return a;
 }
 
@@ -441,6 +443,7 @@ test "double implicit cast in same expression" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     var x = @as(i32, @as(u16, nine()));
+    _ = &x;
     try expect(x == 9);
 }
 fn nine() u8 {
@@ -570,6 +573,7 @@ test "comptime cast fn to ptr" {
 
 test "equality compare fn ptrs" {
     var a = &emptyFn;
+    _ = &a;
     try expect(a == a);
 }
 
@@ -611,6 +615,7 @@ test "global constant is loaded with a runtime-known index" {
     const S = struct {
         fn doTheTest() !void {
             var index: usize = 1;
+            _ = &index;
             const ptr = &pieces[index].field;
             try expect(ptr.* == 2);
         }
@@ -785,6 +790,7 @@ test "variable name containing underscores does not shadow int primitive" {
 
 test "if expression type coercion" {
     var cond: bool = true;
+    _ = &cond;
     const x: u16 = if (cond) 1 else 0;
     try expect(@as(u16, x) == 1);
 }
@@ -825,6 +831,7 @@ test "discarding the result of various expressions" {
 
 test "labeled block implicitly ends in a break" {
     var a = false;
+    _ = &a;
     blk: {
         if (a) break :blk;
     }
@@ -852,6 +859,7 @@ test "catch in block has correct result location" {
 test "labeled block with runtime branch forwards its result location type to break statements" {
     const E = enum { a, b };
     var a = false;
+    _ = &a;
     const e: E = blk: {
         if (a) {
             break :blk .a;
@@ -872,8 +880,7 @@ test "try in labeled block doesn't cast to wrong type" {
     };
     const s: ?*S = blk: {
         var a = try S.foo();
-
-        _ = a;
+        _ = &a;
         break :blk null;
     };
     _ = s;
@@ -894,6 +901,7 @@ test "weird array and tuple initializations" {
     const E = enum { a, b };
     const S = struct { e: E };
     var a = false;
+    _ = &a;
     const b = S{ .e = .a };
 
     _ = &[_]S{
@@ -1009,6 +1017,7 @@ test "switch inside @as gets correct type" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     var a: u32 = 0;
+    _ = &a;
     var b: [2]u32 = undefined;
     b[0] = @as(u32, switch (a) {
         1 => 1,
@@ -1110,7 +1119,8 @@ test "orelse coercion as function argument" {
         }
     };
     var optional: ?Loc = .{};
-    var foo = Container.init(optional orelse .{});
+    _ = &optional;
+    const foo = Container.init(optional orelse .{});
     try expect(foo.a.?.start == -1);
 }
 
@@ -1153,6 +1163,7 @@ test "arrays and vectors with big integers" {
 test "pointer to struct literal with runtime field is constant" {
     const S = struct { data: usize };
     var runtime_zero: usize = 0;
+    _ = &runtime_zero;
     const ptr = &S{ .data = runtime_zero };
     try expect(@typeInfo(@TypeOf(ptr)).Pointer.is_const);
 }
@@ -1163,6 +1174,7 @@ test "integer compare" {
             var z: T = 0;
             var p: T = 123;
             var n: T = -123;
+            _ = .{ &z, &p, &n };
             try expect(z == z and z != p and z != n);
             try expect(p == p and p != n and n == n);
             try expect(z > n and z < p and z >= n and z <= p);
@@ -1180,6 +1192,7 @@ test "integer compare" {
         fn doTheTestUnsigned(comptime T: type) !void {
             var z: T = 0;
             var p: T = 123;
+            _ = .{ &z, &p };
             try expect(z == z and z != p);
             try expect(p == p);
             try expect(z < p and z <= p);

@@ -99,9 +99,9 @@ fn testShardedTable(comptime Key: type, comptime mask_bit_count: comptime_int, c
 // #2225
 test "comptime shr of BigInt" {
     comptime {
-        var n0 = 0xdeadbeef0000000000000000;
+        const n0 = 0xdeadbeef0000000000000000;
         try expect(n0 >> 64 == 0xdeadbeef);
-        var n1 = 17908056155735594659;
+        const n1 = 17908056155735594659;
         try expect(n1 >> 64 == 0);
     }
 }

@@ -149,8 +149,9 @@ test "bitcast literal [4]u8 param to u32" {
 }
 
 test "bitcast generates a temporary value" {
-    var y = @as(u16, 0x55AA);
-    const x = @as(u16, @bitCast(@as([2]u8, @bitCast(y))));
+    var y: u16 = 0x55AA;
+    _ = &y;
+    const x: u16 = @bitCast(@as([2]u8, @bitCast(y)));
     try expect(y == x);
 }
 
@@ -171,7 +172,8 @@ test "@bitCast packed structs at runtime and comptime" {
     const S = struct {
         fn doTheTest() !void {
             var full = Full{ .number = 0x1234 };
-            var two_halves = @as(Divided, @bitCast(full));
+            _ = &full;
+            const two_halves: Divided = @bitCast(full);
             try expect(two_halves.half1 == 0x34);
             try expect(two_halves.quarter3 == 0x2);
             try expect(two_halves.quarter4 == 0x1);
@@ -195,7 +197,8 @@ test "@bitCast extern structs at runtime and comptime" {
     const S = struct {
         fn doTheTest() !void {
             var full = Full{ .number = 0x1234 };
-            var two_halves = @as(TwoHalves, @bitCast(full));
+            _ = &full;
+            const two_halves: TwoHalves = @bitCast(full);
             switch (native_endian) {
                 .big => {
                     try expect(two_halves.half1 == 0x12);
@@ -225,8 +228,9 @@ test "bitcast packed struct to integer and back" {
     const S = struct {
         fn doTheTest() !void {
             var move = LevelUpMove{ .move_id = 1, .level = 2 };
-            var v = @as(u16, @bitCast(move));
-            var back_to_a_move = @as(LevelUpMove, @bitCast(v));
+            _ = &move;
+            const v: u16 = @bitCast(move);
+            const back_to_a_move: LevelUpMove = @bitCast(v);
             try expect(back_to_a_move.move_id == 1);
             try expect(back_to_a_move.level == 2);
         }
@@ -312,7 +316,8 @@ test "@bitCast packed struct of floats" {
     const S = struct {
         fn doTheTest() !void {
             var foo = Foo{};
-            var v = @as(Foo2, @bitCast(foo));
+            _ = &foo;
+            const v: Foo2 = @bitCast(foo);
             try expect(v.a == foo.a);
             try expect(v.b == foo.b);
             try expect(v.c == foo.c);
@@ -354,10 +359,12 @@ test "comptime @bitCast packed struct to int and back" {
 
     // S -> Int
     var s: S = .{};
+    _ = &s;
     try expectEqual(@as(Int, @bitCast(s)), comptime @as(Int, @bitCast(S{})));
 
     // Int -> S
     var i: Int = 0;
+    _ = &i;
     const rt_cast = @as(S, @bitCast(i));
     const ct_cast = comptime @as(S, @bitCast(@as(Int, 0)));
     inline for (@typeInfo(S).Struct.fields) |field| {
@@ -376,6 +383,7 @@ test "comptime bitcast with fields following f80" {
     const FloatT = extern struct { f: f80, x: u128 align(16) };
     const x: FloatT = .{ .f = 0.5, .x = 123 };
     var x_as_uint: u256 = comptime @as(u256, @bitCast(x));
+    _ = &x_as_uint;
 
     try expect(x.f == @as(FloatT, @bitCast(x_as_uint)).f);
     try expect(x.x == @as(FloatT, @bitCast(x_as_uint)).x);
@@ -428,6 +436,7 @@ test "bitcast nan float does not modify signaling bit" {
     try expectEqual(snan_u16, bitCastWrapper16(snan_f16_const));
 
     var snan_f16_var = math.snan(f16);
+    _ = &snan_f16_var;
     try expectEqual(snan_u16, @as(u16, @bitCast(snan_f16_var)));
     try expectEqual(snan_u16, bitCastWrapper16(snan_f16_var));
 
@@ -437,6 +446,7 @@ test "bitcast nan float does not modify signaling bit" {
     try expectEqual(snan_u32, bitCastWrapper32(snan_f32_const));
 
     var snan_f32_var = math.snan(f32);
+    _ = &snan_f32_var;
     try expectEqual(snan_u32, @as(u32, @bitCast(snan_f32_var)));
     try expectEqual(snan_u32, bitCastWrapper32(snan_f32_var));
 
@@ -446,6 +456,7 @@ test "bitcast nan float does not modify signaling bit" {
     try expectEqual(snan_u64, bitCastWrapper64(snan_f64_const));
 
     var snan_f64_var = math.snan(f64);
+    _ = &snan_f64_var;
     try expectEqual(snan_u64, @as(u64, @bitCast(snan_f64_var)));
     try expectEqual(snan_u64, bitCastWrapper64(snan_f64_var));
 
@@ -455,6 +466,7 @@ test "bitcast nan float does not modify signaling bit" {
     try expectEqual(snan_u128, bitCastWrapper128(snan_f128_const));
 
     var snan_f128_var = math.snan(f128);
+    _ = &snan_f128_var;
     try expectEqual(snan_u128, @as(u128, @bitCast(snan_f128_var)));
     try expectEqual(snan_u128, bitCastWrapper128(snan_f128_var));
 }

@@ -86,11 +86,30 @@ fn testBitReverse() !void {
     try expect(@bitReverse(@as(i24, -6773785)) == @bitReverse(neg24));
     var neg32: i32 = -16773785;
     try expect(@bitReverse(@as(i32, -16773785)) == @bitReverse(neg32));
+
+    _ = .{
+        &num0,
+        &num5,
+        &num8,
+        &num16,
+        &num24,
+        &num32,
+        &num40,
+        &num48,
+        &num56,
+        &num64,
+        &num128,
+        &neg8,
+        &neg16,
+        &neg24,
+        &neg32,
+    };
 }
 
 fn vector8() !void {
     var v = @Vector(2, u8){ 0x12, 0x23 };
-    var result = @bitReverse(v);
+    _ = &v;
+    const result = @bitReverse(v);
     try expect(result[0] == 0x48);
     try expect(result[1] == 0xc4);
 }
@@ -109,7 +128,8 @@ test "bitReverse vectors u8" {
 
 fn vector16() !void {
     var v = @Vector(2, u16){ 0x1234, 0x2345 };
-    var result = @bitReverse(v);
+    _ = &v;
+    const result = @bitReverse(v);
     try expect(result[0] == 0x2c48);
     try expect(result[1] == 0xa2c4);
 }
@@ -128,7 +148,8 @@ test "bitReverse vectors u16" {
 
 fn vector24() !void {
     var v = @Vector(2, u24){ 0x123456, 0x234567 };
-    var result = @bitReverse(v);
+    _ = &v;
+    const result = @bitReverse(v);
     try expect(result[0] == 0x6a2c48);
     try expect(result[1] == 0xe6a2c4);
 }
@@ -147,7 +168,8 @@ test "bitReverse vectors u24" {
 
 fn vector0() !void {
     var v = @Vector(2, u0){ 0, 0 };
-    var result = @bitReverse(v);
+    _ = &v;
+    const result = @bitReverse(v);
     try expect(result[0] == 0);
     try expect(result[1] == 0);
 }

@@ -56,7 +56,8 @@ test "@byteSwap integers" {
 
 fn vector8() !void {
     var v = @Vector(2, u8){ 0x12, 0x13 };
-    var result = @byteSwap(v);
+    _ = &v;
+    const result = @byteSwap(v);
     try expect(result[0] == 0x12);
     try expect(result[1] == 0x13);
 }
@@ -75,7 +76,8 @@ test "@byteSwap vectors u8" {
 
 fn vector16() !void {
     var v = @Vector(2, u16){ 0x1234, 0x2345 };
-    var result = @byteSwap(v);
+    _ = &v;
+    const result = @byteSwap(v);
     try expect(result[0] == 0x3412);
     try expect(result[1] == 0x4523);
 }
@@ -94,7 +96,8 @@ test "@byteSwap vectors u16" {
 
 fn vector24() !void {
     var v = @Vector(2, u24){ 0x123456, 0x234567 };
-    var result = @byteSwap(v);
+    _ = &v;
+    const result = @byteSwap(v);
     try expect(result[0] == 0x563412);
     try expect(result[1] == 0x674523);
 }
@@ -113,7 +116,8 @@ test "@byteSwap vectors u24" {
 
 fn vector0() !void {
     var v = @Vector(2, u0){ 0, 0 };
-    var result = @byteSwap(v);
+    _ = &v;
+    const result = @byteSwap(v);
     try expect(result[0] == 0);
     try expect(result[1] == 0);
 }

@@ -47,6 +47,7 @@ test "basic invocations" {
     {
         // call of non comptime-known function
         var alias_foo = &foo;
+        _ = &alias_foo;
         try expect(@call(.no_async, alias_foo, .{}) == 1234);
         try expect(@call(.never_tail, alias_foo, .{}) == 1234);
         try expect(@call(.never_inline, alias_foo, .{}) == 1234);
@@ -66,6 +67,7 @@ test "tuple parameters" {
     }.add;
     var a: i32 = 12;
     var b: i32 = 34;
+    _ = .{ &a, &b };
     try expect(@call(.auto, add, .{ a, 34 }) == 46);
     try expect(@call(.auto, add, .{ 12, b }) == 46);
     try expect(@call(.auto, add, .{ a, b }) == 46);
@@ -101,6 +103,7 @@ test "result location of function call argument through runtime condition and st
         }
     };
     var runtime = true;
+    _ = &runtime;
     try namespace.foo(.{
         .e = if (!runtime) .a else .b,
     });
@@ -445,6 +448,7 @@ test "non-anytype generic parameters provide result type" {
 
     var rt_u16: u16 = 123;
     var rt_u32: u32 = 0x10000222;
+    _ = .{ &rt_u16, &rt_u32 };
 
     try S.f(u8, @intCast(rt_u16));
     try S.f(u8, @intCast(123));
@@ -470,6 +474,7 @@ test "argument to generic function has correct result type" {
 
         fn doTheTest() !void {
             var t = true;
+            _ = &t;
 
             // Since the enum literal passes through a runtime conditional here, these can only
             // compile if RLS provides the correct result type to the argument

@@ -58,6 +58,7 @@ test "@intCast to comptime_int" {
 test "implicit cast comptime numbers to any type when the value fits" {
     const a: u64 = 255;
     var b: u8 = a;
+    _ = &b;
     try expect(b == 255);
 }
 
@@ -273,7 +274,7 @@ test "implicit cast from *[N]T to [*c]T" {
 
 test "*usize to *void" {
     var i = @as(usize, 0);
-    var v = @as(*void, @ptrCast(&i));
+    const v: *void = @ptrCast(&i);
     v.* = {};
 }
 
@@ -391,7 +392,8 @@ test "peer type unsigned int to signed" {
     var w: u31 = 5;
     var x: u8 = 7;
     var y: i32 = -5;
-    var a = w + y + x;
+    _ = .{ &w, &x, &y };
+    const a = w + y + x;
     try comptime expect(@TypeOf(a) == i32);
     try expect(a == 7);
 }
@@ -401,8 +403,9 @@ test "expected [*c]const u8, found [*:0]const u8" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     var a: [*:0]const u8 = "hello";
-    var b: [*c]const u8 = a;
-    var c: [*:0]const u8 = b;
+    _ = &a;
+    const b: [*c]const u8 = a;
+    const c: [*:0]const u8 = b;
     try expect(std.mem.eql(u8, c[0..5], "hello"));
 }
 
@@ -609,14 +612,16 @@ test "@intCast on vector" {
         fn doTheTest() !void {
             // Upcast (implicit, equivalent to @intCast)
             var up0: @Vector(2, u8) = [_]u8{ 0x55, 0xaa };
-            var up1 = @as(@Vector(2, u16), up0);
-            var up2 = @as(@Vector(2, u32), up0);
-            var up3 = @as(@Vector(2, u64), up0);
+            _ = &up0;
+            const up1 = @as(@Vector(2, u16), up0);
+            const up2 = @as(@Vector(2, u32), up0);
+            const up3 = @as(@Vector(2, u64), up0);
             // Downcast (safety-checked)
             var down0 = up3;
-            var down1 = @as(@Vector(2, u32), @intCast(down0));
-            var down2 = @as(@Vector(2, u16), @intCast(down0));
-            var down3 = @as(@Vector(2, u8), @intCast(down0));
+            _ = &down0;
+            const down1 = @as(@Vector(2, u32), @intCast(down0));
+            const down2 = @as(@Vector(2, u16), @intCast(down0));
+            const down3 = @as(@Vector(2, u8), @intCast(down0));
 
             try expect(mem.eql(u16, &@as([2]u16, up1), &[2]u16{ 0x55, 0xaa }));
             try expect(mem.eql(u32, &@as([2]u32, up2), &[2]u32{ 0x55, 0xaa }));
@@ -629,7 +634,8 @@ test "@intCast on vector" {
 
         fn doTheTestFloat() !void {
             var vec: @Vector(2, f32) = @splat(1234.0);
-            var wider: @Vector(2, f64) = vec;
+            _ = &vec;
+            const wider: @Vector(2, f64) = vec;
             try expect(wider[0] == 1234.0);
             try expect(wider[1] == 1234.0);
         }
@@ -648,7 +654,8 @@ test "@floatCast cast down" {
 
     {
         var double: f64 = 0.001534;
-        var single = @as(f32, @floatCast(double));
+        _ = &double;
+        const single = @as(f32, @floatCast(double));
         try expect(single == 0.001534);
     }
     {
@@ -672,6 +679,7 @@ test "peer type resolution: unreachable, error set, unreachable" {
         Unexpected,
     };
     var err = Error.SystemResources;
+    _ = &err;
     const transformed_err = switch (err) {
         error.FileDescriptorAlreadyPresentInSet => unreachable,
         error.OperationCausesCircularLoop => unreachable,
@@ -821,10 +829,11 @@ test "peer cast *[0]T to E![]const T" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     var buffer: [5]u8 = "abcde".*;
-    var buf: anyerror![]const u8 = buffer[0..];
+    const buf: anyerror![]const u8 = buffer[0..];
     var b = false;
-    var y = if (b) &[0]u8{} else buf;
-    var z = if (!b) buf else &[0]u8{};
+    _ = &b;
+    const y = if (b) &[0]u8{} else buf;
+    const z = if (!b) buf else &[0]u8{};
     try expect(mem.eql(u8, "abcde", y catch unreachable));
     try expect(mem.eql(u8, "abcde", z catch unreachable));
 }
@@ -835,9 +844,10 @@ test "peer cast *[0]T to []const T" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     var buffer: [5]u8 = "abcde".*;
-    var buf: []const u8 = buffer[0..];
+    const buf: []const u8 = buffer[0..];
     var b = false;
-    var y = if (b) &[0]u8{} else buf;
+    _ = &b;
+    const y = if (b) &[0]u8{} else buf;
     try expect(mem.eql(u8, "abcde", y));
 }
 
@@ -846,6 +856,7 @@ test "peer cast *[N]T to [*]T" {
 
     var array = [4:99]i32{ 1, 2, 3, 4 };
     var dest: [*]i32 = undefined;
+    _ = &dest;
     try expect(@TypeOf(&array, dest) == [*]i32);
     try expect(@TypeOf(dest, &array) == [*]i32);
 }
@@ -879,8 +890,8 @@ test "peer cast [:x]T to []T" {
     const S = struct {
         fn doTheTest() !void {
             var array = [4:0]i32{ 1, 2, 3, 4 };
-            var slice: [:0]i32 = &array;
-            var dest: []i32 = slice;
+            const slice: [:0]i32 = &array;
+            const dest: []i32 = slice;
             try expect(mem.eql(i32, dest, &[_]i32{ 1, 2, 3, 4 }));
         }
     };
@@ -895,7 +906,8 @@ test "peer cast [N:x]T to [N]T" {
     const S = struct {
         fn doTheTest() !void {
             var array = [4:0]i32{ 1, 2, 3, 4 };
-            var dest: [4]i32 = array;
+            _ = &array;
+            const dest: [4]i32 = array;
             try expect(mem.eql(i32, &dest, &[_]i32{ 1, 2, 3, 4 }));
         }
     };
@@ -910,7 +922,7 @@ test "peer cast *[N:x]T to *[N]T" {
     const S = struct {
         fn doTheTest() !void {
             var array = [4:0]i32{ 1, 2, 3, 4 };
-            var dest: *[4]i32 = &array;
+            const dest: *[4]i32 = &array;
             try expect(mem.eql(i32, dest, &[_]i32{ 1, 2, 3, 4 }));
         }
     };
@@ -925,7 +937,7 @@ test "peer cast [*:x]T to [*]T" {
     const S = struct {
         fn doTheTest() !void {
             var array = [4:99]i32{ 1, 2, 3, 4 };
-            var dest: [*]i32 = &array;
+            const dest: [*]i32 = &array;
             try expect(dest[0] == 1);
             try expect(dest[1] == 2);
             try expect(dest[2] == 3);
@@ -945,8 +957,8 @@ test "peer cast [:x]T to [*:x]T" {
     const S = struct {
         fn doTheTest() !void {
             var array = [4:0]i32{ 1, 2, 3, 4 };
-            var slice: [:0]i32 = &array;
-            var dest: [*:0]i32 = slice;
+            const slice: [:0]i32 = &array;
+            const dest: [*:0]i32 = slice;
             try expect(dest[0] == 1);
             try expect(dest[1] == 2);
             try expect(dest[2] == 3);
@@ -998,6 +1010,7 @@ test "peer type resolution implicit cast to variable type" {
 
 test "variable initialization uses result locations properly with regards to the type" {
     var b = true;
+    _ = &b;
     const x: i32 = if (b) 1 else 2;
     try expect(x == 1);
 }
@@ -1025,7 +1038,7 @@ test "peer type resolve string lit with sentinel-terminated mutable slice" {
 
     var array: [4:0]u8 = undefined;
     array[4] = 0; // TODO remove this when #4372 is solved
-    var slice: [:0]u8 = array[0..4 :0];
+    const slice: [:0]u8 = array[0..4 :0];
     try comptime expect(@TypeOf(slice, "hi") == [:0]const u8);
     try comptime expect(@TypeOf("hi", slice) == [:0]const u8);
 }
@@ -1042,6 +1055,7 @@ test "peer type resolve array pointer and unknown pointer" {
     var array: [4]u8 = undefined;
     var const_ptr: [*]const u8 = undefined;
     var ptr: [*]u8 = undefined;
+    _ = .{ &const_ptr, &ptr };
 
     try comptime expect(@TypeOf(&array, ptr) == [*]u8);
     try comptime expect(@TypeOf(ptr, &array) == [*]u8);
@@ -1090,6 +1104,7 @@ test "implicit cast from [*]T to ?*anyopaque" {
 
     var a = [_]u8{ 3, 2, 1 };
     var runtime_zero: usize = 0;
+    _ = &runtime_zero;
     incrementVoidPtrArray(a[runtime_zero..].ptr, 3);
     try expect(std.mem.eql(u8, &a, &[_]u8{ 4, 3, 2 }));
 }
@@ -1151,11 +1166,11 @@ test "implicit ptr to *anyopaque" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     var a: u32 = 1;
-    var ptr: *align(@alignOf(u32)) anyopaque = &a;
-    var b: *u32 = @as(*u32, @ptrCast(ptr));
+    const ptr: *align(@alignOf(u32)) anyopaque = &a;
+    const b: *u32 = @as(*u32, @ptrCast(ptr));
     try expect(b.* == 1);
-    var ptr2: ?*align(@alignOf(u32)) anyopaque = &a;
-    var c: *u32 = @as(*u32, @ptrCast(ptr2.?));
+    const ptr2: ?*align(@alignOf(u32)) anyopaque = &a;
+    const c: *u32 = @as(*u32, @ptrCast(ptr2.?));
     try expect(c.* == 1);
 }
 
@@ -1264,6 +1279,7 @@ test "implicit cast *[0]T to E![]const u8" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     var x = @as(anyerror![]const u8, &[0]u8{});
+    _ = &x;
     try expect((x catch unreachable).len == 0);
 }
 
@@ -1274,6 +1290,7 @@ test "cast from array reference to fn: comptime fn ptr" {
 }
 test "cast from array reference to fn: runtime fn ptr" {
     var f = @as(*align(1) const fn () callconv(.C) void, @ptrCast(&global_array));
+    _ = &f;
     try expect(@intFromPtr(f) == @intFromPtr(&global_array));
 }
 
@@ -1285,7 +1302,8 @@ test "*const [N]null u8 to ?[]const u8" {
     const S = struct {
         fn doTheTest() !void {
             var a = "Hello";
-            var b: ?[]const u8 = a;
+            _ = &a;
+            const b: ?[]const u8 = a;
             try expect(mem.eql(u8, b.?, "Hello"));
         }
     };
@@ -1318,12 +1336,13 @@ test "assignment to optional pointer result loc" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     var foo: struct { ptr: ?*anyopaque } = .{ .ptr = &global_struct };
+    _ = &foo;
     try expect(foo.ptr.? == @as(*anyopaque, @ptrCast(&global_struct)));
 }
 
 test "cast between *[N]void and []void" {
     var a: [4]void = undefined;
-    var b: []void = &a;
+    const b: []void = &a;
     try expect(b.len == 4);
 }
 
@@ -1351,6 +1370,7 @@ test "cast f16 to wider types" {
     const S = struct {
         fn doTheTest() !void {
             var x: f16 = 1234.0;
+            _ = &x;
             try expect(@as(f32, 1234.0) == x);
             try expect(@as(f64, 1234.0) == x);
             try expect(@as(f128, 1234.0) == x);
@@ -1370,6 +1390,7 @@ test "cast f128 to narrower types" {
     const S = struct {
         fn doTheTest() !void {
             var x: f128 = 1234.0;
+            _ = &x;
             try expect(@as(f16, 1234.0) == @as(f16, @floatCast(x)));
             try expect(@as(f32, 1234.0) == @as(f32, @floatCast(x)));
             try expect(@as(f64, 1234.0) == @as(f64, @floatCast(x)));
@@ -1404,6 +1425,7 @@ test "cast i8 fn call peers to i32 result" {
     const S = struct {
         fn doTheTest() !void {
             var cond = true;
+            _ = &cond;
             const value: i32 = if (cond) smallBoi() else bigBoi();
             try expect(value == 123);
         }
@@ -1424,7 +1446,8 @@ test "cast compatible optional types" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     var a: ?[:0]const u8 = null;
-    var b: ?[]const u8 = a;
+    _ = &a;
+    const b: ?[]const u8 = a;
     try expect(b == null);
 }
 
@@ -1434,6 +1457,7 @@ test "coerce undefined single-item pointer of array to error union of slice" {
 
     const a = @as([*]u8, undefined)[0..0];
     var b: error{a}![]const u8 = a;
+    _ = &b;
     const s = try b;
     try expect(s.len == 0);
 }
@@ -1442,6 +1466,7 @@ test "pointer to empty struct literal to mutable slice" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     var x: []i32 = &.{};
+    _ = &x;
     try expect(x.len == 0);
 }
 
@@ -1466,7 +1491,7 @@ test "coerce between pointers of compatible differently-named floats" {
         else => @compileError("unreachable"),
     };
     var f1: F = 12.34;
-    var f2: *c_longdouble = &f1;
+    const f2: *c_longdouble = &f1;
     f2.* += 1;
     try expect(f1 == @as(F, 12.34) + 1);
 }
@@ -1507,8 +1532,9 @@ test "implicit cast from [:0]T to [*c]T" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
 
     var a: [:0]const u8 = "foo";
-    var b: [*c]const u8 = a;
-    var c = std.mem.span(b);
+    _ = &a;
+    const b: [*c]const u8 = a;
+    const c = std.mem.span(b);
     try expect(c.len == a.len);
     try expect(c.ptr == a.ptr);
 }
@@ -1544,6 +1570,7 @@ test "single item pointer to pointer to array to slice" {
 
 test "peer type resolution forms error union" {
     var foo: i32 = 123;
+    _ = &foo;
     const result = if (foo < 0) switch (-foo) {
         0 => unreachable,
         42 => error.AccessDenied,
@@ -1561,7 +1588,7 @@ test "@constCast without a result location" {
 
 test "@volatileCast without a result location" {
     var x: i32 = 1234;
-    var y: *volatile i32 = &x;
+    const y: *volatile i32 = &x;
     const z = @volatileCast(y);
     try expect(@TypeOf(z) == *i32);
     try expect(z.* == 1234);
@@ -1585,10 +1612,12 @@ test "peer type resolution: const sentinel slice and mutable non-sentinel slice"
         fn doTheTest(comptime T: type, comptime s: T) !void {
             var a: [:s]const T = @as(*const [2:s]T, @ptrFromInt(0x1000));
             var b: []T = @as(*[3]T, @ptrFromInt(0x2000));
+            _ = .{ &a, &b };
             comptime assert(@TypeOf(a, b) == []const T);
             comptime assert(@TypeOf(b, a) == []const T);
 
             var t = true;
+            _ = &t;
             const r1 = if (t) a else b;
             const r2 = if (t) b else a;
 
@@ -1611,10 +1640,12 @@ test "peer type resolution: float and comptime-known fixed-width integer" {
 
     const i: u8 = 100;
     var f: f32 = 1.234;
+    _ = &f;
     comptime assert(@TypeOf(i, f) == f32);
     comptime assert(@TypeOf(f, i) == f32);
 
     var t = true;
+    _ = &t;
     const r1 = if (t) i else f;
     const r2 = if (t) f else i;
 
@@ -1631,10 +1662,12 @@ test "peer type resolution: same array type with sentinel" {
 
     var a: [2:0]u32 = .{ 0, 1 };
     var b: [2:0]u32 = .{ 2, 3 };
+    _ = .{ &a, &b };
     comptime assert(@TypeOf(a, b) == [2:0]u32);
     comptime assert(@TypeOf(b, a) == [2:0]u32);
 
     var t = true;
+    _ = &t;
     const r1 = if (t) a else b;
     const r2 = if (t) b else a;
 
@@ -1651,10 +1684,12 @@ test "peer type resolution: array with sentinel and array without sentinel" {
 
     var a: [2:0]u32 = .{ 0, 1 };
     var b: [2]u32 = .{ 2, 3 };
+    _ = .{ &a, &b };
     comptime assert(@TypeOf(a, b) == [2]u32);
     comptime assert(@TypeOf(b, a) == [2]u32);
 
     var t = true;
+    _ = &t;
     const r1 = if (t) a else b;
     const r2 = if (t) b else a;
 
@@ -1671,10 +1706,12 @@ test "peer type resolution: array and vector with same child type" {
 
     var arr: [2]u32 = .{ 0, 1 };
     var vec: @Vector(2, u32) = .{ 2, 3 };
+    _ = .{ &arr, &vec };
     comptime assert(@TypeOf(arr, vec) == @Vector(2, u32));
     comptime assert(@TypeOf(vec, arr) == @Vector(2, u32));
 
     var t = true;
+    _ = &t;
     const r1 = if (t) arr else vec;
     const r2 = if (t) vec else arr;
 
@@ -1694,10 +1731,12 @@ test "peer type resolution: array with smaller child type and vector with larger
 
     var arr: [2]u8 = .{ 0, 1 };
     var vec: @Vector(2, u64) = .{ 2, 3 };
+    _ = .{ &arr, &vec };
     comptime assert(@TypeOf(arr, vec) == @Vector(2, u64));
     comptime assert(@TypeOf(vec, arr) == @Vector(2, u64));
 
     var t = true;
+    _ = &t;
     const r1 = if (t) arr else vec;
     const r2 = if (t) vec else arr;
 
@@ -1715,10 +1754,12 @@ test "peer type resolution: error union and optional of same type" {
     const E = error{Foo};
     var a: E!*u8 = error.Foo;
     var b: ?*u8 = null;
+    _ = .{ &a, &b };
     comptime assert(@TypeOf(a, b) == E!?*u8);
     comptime assert(@TypeOf(b, a) == E!?*u8);
 
     var t = true;
+    _ = &t;
     const r1 = if (t) a else b;
     const r2 = if (t) b else a;
 
@@ -1734,11 +1775,13 @@ test "peer type resolution: C pointer and @TypeOf(null)" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     var a: [*c]c_int = 0x1000;
+    _ = &a;
     const b = null;
     comptime assert(@TypeOf(a, b) == [*c]c_int);
     comptime assert(@TypeOf(b, a) == [*c]c_int);
 
     var t = true;
+    _ = &t;
     const r1 = if (t) a else b;
     const r2 = if (t) b else a;
 
@@ -1755,8 +1798,9 @@ test "peer type resolution: three-way resolution combines error set and optional
 
     const E = error{Foo};
     var a: E = error.Foo;
-    var b: *const [5:0]u8 = @as(*const [5:0]u8, @ptrFromInt(0x1000));
+    var b: *const [5:0]u8 = @ptrFromInt(0x1000);
     var c: ?[*:0]u8 = null;
+    _ = .{ &a, &b, &c };
     comptime assert(@TypeOf(a, b, c) == E!?[*:0]const u8);
     comptime assert(@TypeOf(a, c, b) == E!?[*:0]const u8);
     comptime assert(@TypeOf(b, a, c) == E!?[*:0]const u8);
@@ -1765,6 +1809,7 @@ test "peer type resolution: three-way resolution combines error set and optional
     comptime assert(@TypeOf(c, b, a) == E!?[*:0]const u8);
 
     var x: u8 = 0;
+    _ = &x;
     const r1 = switch (x) {
         0 => a,
         1 => b,
@@ -1797,10 +1842,12 @@ test "peer type resolution: vector and optional vector" {
 
     var a: ?@Vector(3, u32) = .{ 0, 1, 2 };
     var b: @Vector(3, u32) = .{ 3, 4, 5 };
+    _ = .{ &a, &b };
     comptime assert(@TypeOf(a, b) == ?@Vector(3, u32));
     comptime assert(@TypeOf(b, a) == ?@Vector(3, u32));
 
     var t = true;
+    _ = &t;
     const r1 = if (t) a else b;
     const r2 = if (t) b else a;
 
@@ -1816,11 +1863,13 @@ test "peer type resolution: optional fixed-width int and comptime_int" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     var a: ?i32 = 42;
+    _ = &a;
     const b: comptime_int = 50;
     comptime assert(@TypeOf(a, b) == ?i32);
     comptime assert(@TypeOf(b, a) == ?i32);
 
     var t = true;
+    _ = &t;
     const r1 = if (t) a else b;
     const r2 = if (t) b else a;
 
@@ -1836,12 +1885,14 @@ test "peer type resolution: array and tuple" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     var arr: [3]i32 = .{ 1, 2, 3 };
+    _ = &arr;
     const tup = .{ 4, 5, 6 };
 
     comptime assert(@TypeOf(arr, tup) == [3]i32);
     comptime assert(@TypeOf(tup, arr) == [3]i32);
 
     var t = true;
+    _ = &t;
     const r1 = if (t) arr else tup;
     const r2 = if (t) tup else arr;
 
@@ -1858,12 +1909,14 @@ test "peer type resolution: vector and tuple" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     var vec: @Vector(3, i32) = .{ 1, 2, 3 };
+    _ = &vec;
     const tup = .{ 4, 5, 6 };
 
     comptime assert(@TypeOf(vec, tup) == @Vector(3, i32));
     comptime assert(@TypeOf(tup, vec) == @Vector(3, i32));
 
     var t = true;
+    _ = &t;
     const r1 = if (t) vec else tup;
     const r2 = if (t) tup else vec;
 
@@ -1881,6 +1934,7 @@ test "peer type resolution: vector and array and tuple" {
 
     var vec: @Vector(2, i8) = .{ 10, 20 };
     var arr: [2]i8 = .{ 30, 40 };
+    _ = .{ &vec, &arr };
     const tup = .{ 50, 60 };
 
     comptime assert(@TypeOf(vec, arr, tup) == @Vector(2, i8));
@@ -1891,6 +1945,7 @@ test "peer type resolution: vector and array and tuple" {
     comptime assert(@TypeOf(tup, arr, vec) == @Vector(2, i8));
 
     var x: u8 = 0;
+    _ = &x;
     const r1 = switch (x) {
         0 => vec,
         1 => arr,
@@ -1921,11 +1976,13 @@ test "peer type resolution: empty tuple pointer and slice" {
 
     var a: [:0]const u8 = "Hello";
     var b = &.{};
+    _ = .{ &a, &b };
 
     comptime assert(@TypeOf(a, b) == []const u8);
     comptime assert(@TypeOf(b, a) == []const u8);
 
     var t = true;
+    _ = &t;
     const r1 = if (t) a else b;
     const r2 = if (t) b else a;
 
@@ -1940,11 +1997,13 @@ test "peer type resolution: tuple pointer and slice" {
 
     var a: [:0]const u8 = "Hello";
     var b = &.{ @as(u8, 'x'), @as(u8, 'y'), @as(u8, 'z') };
+    _ = .{ &a, &b };
 
     comptime assert(@TypeOf(a, b) == []const u8);
     comptime assert(@TypeOf(b, a) == []const u8);
 
     var t = true;
+    _ = &t;
     const r1 = if (t) a else b;
     const r2 = if (t) b else a;
 
@@ -1959,11 +2018,13 @@ test "peer type resolution: tuple pointer and optional slice" {
 
     var a: ?[:0]const u8 = null;
     var b = &.{ @as(u8, 'x'), @as(u8, 'y'), @as(u8, 'z') };
+    _ = .{ &a, &b };
 
     comptime assert(@TypeOf(a, b) == ?[]const u8);
     comptime assert(@TypeOf(b, a) == ?[]const u8);
 
     var t = true;
+    _ = &t;
     const r1 = if (t) a else b;
     const r2 = if (t) b else a;
 
@@ -1986,6 +2047,7 @@ test "peer type resolution: many compatible pointers" {
         @as([*]u8, &buf),
         @as(*const [5]u8, "foo-4"),
     };
+    _ = &vals;
 
     // Check every possible permutation of types in @TypeOf
     @setEvalBranchQuota(5000);
@@ -2015,6 +2077,7 @@ test "peer type resolution: many compatible pointers" {
     comptime assert(perms == 5 * 4 * 3 * 2 * 1);
 
     var x: u8 = 0;
+    _ = &x;
     inline for (0..5) |i| {
         const r = switch (x) {
             0 => vals[i],
@@ -2057,6 +2120,7 @@ test "peer type resolution: tuples with comptime fields" {
     }
 
     var t = true;
+    _ = &t;
     const r1 = if (t) a else b;
     const r2 = if (t) b else a;
 
@@ -2074,13 +2138,15 @@ test "peer type resolution: C pointer and many pointer" {
 
     var buf = "hello".*;
 
-    var a: [*c]u8 = &buf;
+    const a: [*c]u8 = &buf;
     var b: [*:0]const u8 = "world";
+    _ = &b;
 
     comptime assert(@TypeOf(a, b) == [*c]const u8);
     comptime assert(@TypeOf(b, a) == [*c]const u8);
 
     var t = true;
+    _ = &t;
     const r1 = if (t) a else b;
     const r2 = if (t) b else a;
 
@@ -2097,9 +2163,9 @@ test "peer type resolution: pointer attributes are combined correctly" {
     var buf_b align(4) = "bar".*;
     var buf_c align(4) = "baz".*;
 
-    var a: [*:0]align(4) const u8 = &buf_a;
-    var b: *align(2) volatile [3:0]u8 = &buf_b;
-    var c: [*:0]align(4) u8 = &buf_c;
+    const a: [*:0]align(4) const u8 = &buf_a;
+    const b: *align(2) volatile [3:0]u8 = &buf_b;
+    const c: [*:0]align(4) u8 = &buf_c;
 
     comptime assert(@TypeOf(a, b, c) == [*:0]align(2) const volatile u8);
     comptime assert(@TypeOf(a, c, b) == [*:0]align(2) const volatile u8);
@@ -2109,6 +2175,7 @@ test "peer type resolution: pointer attributes are combined correctly" {
     comptime assert(@TypeOf(c, b, a) == [*:0]align(2) const volatile u8);
 
     var x: u8 = 0;
+    _ = &x;
     const r1 = switch (x) {
         0 => a,
         1 => b,
@@ -2254,6 +2321,7 @@ test "@floatCast on vector" {
     const S = struct {
         fn doTheTest() !void {
             var a: @Vector(3, f64) = .{ 1.5, 2.5, 3.5 };
+            _ = &a;
             const b: @Vector(3, f32) = @floatCast(a);
             try expectEqual(@Vector(3, f32){ 1.5, 2.5, 3.5 }, b);
         }
@@ -2274,6 +2342,7 @@ test "@ptrFromInt on vector" {
     const S = struct {
         fn doTheTest() !void {
             var a: @Vector(3, usize) = .{ 0x1000, 0x2000, 0x3000 };
+            _ = &a;
             const b: @Vector(3, *anyopaque) = @ptrFromInt(a);
             try expectEqual(@Vector(3, *anyopaque){
                 @ptrFromInt(0x1000),
@@ -2302,6 +2371,7 @@ test "@intFromPtr on vector" {
                 @ptrFromInt(0x2000),
                 @ptrFromInt(0x3000),
             };
+            _ = &a;
             const b: @Vector(3, usize) = @intFromPtr(a);
             try expectEqual(@Vector(3, usize){ 0x1000, 0x2000, 0x3000 }, b);
         }
@@ -2322,6 +2392,7 @@ test "@floatFromInt on vector" {
     const S = struct {
         fn doTheTest() !void {
             var a: @Vector(3, u32) = .{ 10, 20, 30 };
+            _ = &a;
             const b: @Vector(3, f32) = @floatFromInt(a);
             try expectEqual(@Vector(3, f32){ 10.0, 20.0, 30.0 }, b);
         }
@@ -2342,6 +2413,7 @@ test "@intFromFloat on vector" {
     const S = struct {
         fn doTheTest() !void {
             var a: @Vector(3, f32) = .{ 10.3, 20.5, 30.7 };
+            _ = &a;
             const b: @Vector(3, u32) = @intFromFloat(a);
             try expectEqual(@Vector(3, u32){ 10, 20, 30 }, b);
         }
@@ -2362,6 +2434,7 @@ test "@intFromBool on vector" {
     const S = struct {
         fn doTheTest() !void {
             var a: @Vector(3, bool) = .{ false, true, false };
+            _ = &a;
             const b: @Vector(3, u1) = @intFromBool(a);
             try expectEqual(@Vector(3, u1){ 0, 1, 0 }, b);
         }
@@ -2385,7 +2458,8 @@ test "15-bit int to float" {
     if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
 
     var a: u15 = 42;
-    var b: f32 = @floatFromInt(a);
+    _ = &a;
+    const b: f32 = @floatFromInt(a);
     try expect(b == 42.0);
 }
 
@@ -2417,6 +2491,7 @@ test "result information is preserved through many nested structures" {
             const T = *const ?E!struct { x: ?*const E!?u8 };
 
             var val: T = &.{ .x = &@truncate(0x1234) };
+            _ = &val;
 
             const struct_val = val.*.? catch unreachable;
             const int_val = (struct_val.x.?.* catch unreachable).?;
@@ -2439,6 +2514,7 @@ test "@intCast vector of signed integer" {
     if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
 
     var x: @Vector(4, i32) = .{ 1, 2, 3, 4 };
+    _ = &x;
     const y: @Vector(4, i8) = @intCast(x);
 
     try expect(y[0] == 1);

@@ -12,7 +12,8 @@ test "@intCast i32 to u7" {
 
     var x: u128 = maxInt(u128);
     var y: i32 = 120;
-    var z = x >> @as(u7, @intCast(y));
+    _ = .{ &x, &y };
+    const z = x >> @as(u7, @intCast(y));
     try expect(z == 0xff);
 }
 
@@ -23,20 +24,24 @@ test "coerce i8 to i32 and @intCast back" {
 
     var x: i8 = -5;
     var y: i32 = -5;
+    _ = .{ &x, &y };
     try expect(y == x);
 
     var x2: i32 = -5;
     var y2: i8 = -5;
+    _ = .{ &x2, &y2 };
     try expect(y2 == @as(i8, @intCast(x2)));
 }
 
 test "coerce non byte-sized integers accross 32bits boundary" {
     {
         var v: u21 = 6417;
+        _ = &v;
         const a: u32 = v;
         const b: u64 = v;
         const c: u64 = a;
         var w: u64 = 0x1234567812345678;
+        _ = &w;
         const d: u21 = @truncate(w);
         const e: u60 = d;
         try expectEqual(@as(u32, 6417), a);
@@ -48,10 +53,12 @@ test "coerce non byte-sized integers accross 32bits boundary" {
 
     {
         var v: u10 = 234;
+        _ = &v;
         const a: u32 = v;
         const b: u64 = v;
         const c: u64 = a;
         var w: u64 = 0x1234567812345678;
+        _ = &w;
         const d: u10 = @truncate(w);
         const e: u60 = d;
         try expectEqual(@as(u32, 234), a);
@@ -62,10 +69,12 @@ test "coerce non byte-sized integers accross 32bits boundary" {
     }
     {
         var v: u7 = 11;
+        _ = &v;
         const a: u32 = v;
         const b: u64 = v;
         const c: u64 = a;
         var w: u64 = 0x1234567812345678;
+        _ = &w;
         const d: u7 = @truncate(w);
         const e: u60 = d;
         try expectEqual(@as(u32, 11), a);
@@ -77,10 +86,12 @@ test "coerce non byte-sized integers accross 32bits boundary" {
 
     {
         var v: i21 = -6417;
+        _ = &v;
         const a: i32 = v;
         const b: i64 = v;
         const c: i64 = a;
         var w: i64 = -12345;
+        _ = &w;
         const d: i21 = @intCast(w);
         const e: i60 = d;
         try expectEqual(@as(i32, -6417), a);
@@ -92,10 +103,12 @@ test "coerce non byte-sized integers accross 32bits boundary" {
 
     {
         var v: i10 = -234;
+        _ = &v;
         const a: i32 = v;
         const b: i64 = v;
         const c: i64 = a;
         var w: i64 = -456;
+        _ = &w;
         const d: i10 = @intCast(w);
         const e: i60 = d;
         try expectEqual(@as(i32, -234), a);
@@ -106,10 +119,12 @@ test "coerce non byte-sized integers accross 32bits boundary" {
     }
     {
         var v: i7 = -11;
+        _ = &v;
         const a: i32 = v;
         const b: i64 = v;
         const c: i64 = a;
         var w: i64 = -42;
+        _ = &w;
         const d: i7 = @intCast(w);
         const e: i60 = d;
         try expectEqual(@as(i32, -11), a);
@@ -152,7 +167,7 @@ test "load non byte-sized optional value" {
     if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
 
     // note: this bug is triggered by the == operator, expectEqual will hide it
-    var opt: ?Piece = try Piece.charToPiece('p');
+    const opt: ?Piece = try Piece.charToPiece('p');
     try expect(opt.?.type == .PAWN);
     try expect(opt.?.color == .BLACK);
 

@@ -280,7 +280,7 @@ test "dance on linker values" {
         if (ptr_size > @sizeOf(Bits))
             try doTypePunBitsTest(&weird_ptr[1]);
 
-        var arr_bytes = @as(*[2][ptr_size]u8, @ptrCast(&arr));
+        const arr_bytes: *[2][ptr_size]u8 = @ptrCast(&arr);
 
         var rebuilt_bytes: [ptr_size]u8 = undefined;
         var i: usize = 0;

@@ -7,6 +7,7 @@ test "simple destructure" {
         fn doTheTest() !void {
             var x: u32 = undefined;
             x, const y, var z: u64 = .{ 1, @as(u16, 2), 3 };
+            _ = &z;
 
             comptime assert(@TypeOf(y) == u16);
 
@@ -25,6 +26,7 @@ test "destructure with comptime syntax" {
         fn doTheTest() void {
             comptime var x: f32 = undefined;
             comptime x, const y, var z = .{ 0.5, 123, 456 }; // z is a comptime var
+            _ = &z;
 
             comptime assert(@TypeOf(y) == comptime_int);
             comptime assert(@TypeOf(z) == comptime_int);
@@ -112,6 +114,7 @@ test "destructure of comptime-known tuple is comptime-known" {
 test "destructure of comptime-known tuple where some destinations are runtime-known is comptime-known" {
     var z: u32 = undefined;
     var x: u8, const y, z = .{ 1, 2, 3 };
+    _ = &x;
 
     comptime assert(@TypeOf(y) == comptime_int);
     comptime assert(y == 2);
@@ -122,6 +125,7 @@ test "destructure of comptime-known tuple where some destinations are runtime-kn
 
 test "destructure of tuple with comptime fields results in some comptime-known values" {
     var runtime: u32 = 42;
+    _ = &runtime;
     const a, const b, const c, const d = .{ 123, runtime, 456, runtime };
 
     // a, c are comptime-known

@@ -5,12 +5,14 @@ const expect = std.testing.expect;
 test "switch on empty enum" {
     const E = enum {};
     var e: E = undefined;
+    _ = &e;
     switch (e) {}
 }
 
 test "switch on empty enum with a specified tag type" {
     const E = enum(u8) {};
     var e: E = undefined;
+    _ = &e;
     switch (e) {}
 }
 
@@ -19,6 +21,7 @@ test "switch on empty auto numbered tagged union" {
 
     const U = union(enum(u8)) {};
     var u: U = undefined;
+    _ = &u;
     switch (u) {}
 }
 
@@ -28,6 +31,7 @@ test "switch on empty tagged union" {
     const E = enum {};
     const U = union(E) {};
     var u: U = undefined;
+    _ = &u;
     switch (u) {}
 }
 

@@ -579,6 +579,7 @@ test "enum literal cast to enum" {
 
     var color1: Color = .Auto;
     var color2 = Color.Auto;
+    _ = .{ &color1, &color2 };
     try expect(color1 == color2);
 }
 
@@ -663,7 +664,8 @@ test "empty non-exhaustive enum" {
         const E = enum(u8) { _ };
 
         fn doTheTest(y: u8) !void {
-            var e = @as(E, @enumFromInt(y));
+            var e: E = @enumFromInt(y);
+            _ = &e;
             try expect(switch (e) {
                 _ => true,
             });
@@ -858,6 +860,7 @@ test "comparison operator on enum with one member is comptime-known" {
 const State = enum { Start };
 test "switch on enum with one member is comptime-known" {
     var state = State.Start;
+    _ = &state;
     switch (state) {
         State.Start => return,
     }
@@ -917,7 +920,8 @@ test "enum literal casting to tagged union" {
 
     var t = true;
     var x: Arch = .x86_64;
-    var y = if (t) x else .x86_64;
+    _ = .{ &t, &x };
+    const y = if (t) x else .x86_64;
     switch (y) {
         .x86_64 => {},
         else => @panic("fail"),
@@ -1031,6 +1035,7 @@ test "tag name with assigned enum values" {
         B = 0,
     };
     var b = LocalFoo.B;
+    _ = &b;
     try expect(mem.eql(u8, @tagName(b), "B"));
 }
 
@@ -1055,6 +1060,7 @@ test "tag name with signed enum values" {
         delta = 65,
     };
     var b = LocalFoo.bravo;
+    _ = &b;
     try expect(mem.eql(u8, @tagName(b), "bravo"));
 }
 
@@ -1135,13 +1141,13 @@ test "tag name functions are unique" {
         const E = enum { a, b };
         var b = E.a;
         var a = @tagName(b);
-        _ = a;
+        _ = .{ &a, &b };
     }
     {
         const E = enum { a, b, c, d, e, f };
         var b = E.a;
         var a = @tagName(b);
-        _ = a;
+        _ = .{ &a, &b };
     }
 }
 
@@ -1189,6 +1195,7 @@ test "Non-exhaustive enum with nonstandard int size behaves correctly" {
 test "runtime int to enum with one possible value" {
     const E = enum { one };
     var runtime: usize = 0;
+    _ = &runtime;
     if (@as(E, @enumFromInt(runtime)) != .one) {
         @compileError("test failed");
     }

@@ -102,8 +102,7 @@ test "widen cast integer payload of error union function call" {
 
     const S = struct {
         fn errorable() !u64 {
-            var x = @as(u64, try number());
-            return x;
+            return @as(u64, try number());
         }
 
         fn number() anyerror!u32 {
@@ -119,7 +118,7 @@ test "debug info for optional error set" {
 
     const SomeError = error{ Hello, Hello2 };
     var a_local_variable: ?SomeError = null;
-    _ = a_local_variable;
+    _ = &a_local_variable;
 }
 
 test "implicit cast to optional to error union to return result loc" {
@@ -160,6 +159,7 @@ fn entry() void {
 
 fn entryPtr() void {
     var ptr = &bar2;
+    _ = &ptr;
     fooPtr(ptr);
 }
 
@@ -226,9 +226,9 @@ const Set1 = error{ A, B };
 const Set2 = error{ A, C };
 
 fn testExplicitErrorSetCast(set1: Set1) !void {
-    var x = @as(Set2, @errorCast(set1));
+    const x: Set2 = @errorCast(set1);
     try expect(@TypeOf(x) == Set2);
-    var y = @as(Set1, @errorCast(x));
+    const y: Set1 = @errorCast(x);
     try expect(@TypeOf(y) == Set1);
     try expect(y == error.A);
 }
@@ -408,17 +408,17 @@ test "nested error union function call in optional unwrap" {
         };
 
         fn errorable() !i32 {
-            var x: Foo = (try getFoo()) orelse return error.Other;
+            const x: Foo = (try getFoo()) orelse return error.Other;
             return x.a;
         }
 
         fn errorable2() !i32 {
-            var x: Foo = (try getFoo2()) orelse return error.Other;
+            const x: Foo = (try getFoo2()) orelse return error.Other;
             return x.a;
         }
 
         fn errorable3() !i32 {
-            var x: Foo = (try getFoo3()) orelse return error.Other;
+            const x: Foo = (try getFoo3()) orelse return error.Other;
             return x.a;
         }
 
@@ -673,6 +673,7 @@ test "peer type resolution of two different error unions" {
     const a: error{B}!void = {};
     const b: error{A}!void = {};
     var cond = true;
+    _ = &cond;
     const err = if (cond) a else b;
     try err;
 }
@@ -681,6 +682,7 @@ test "coerce error set to the current inferred error set" {
     const S = struct {
         fn foo() !void {
             var a = false;
+            _ = &a;
             if (a) {
                 const b: error{A}!void = error.A;
                 return b;
@@ -831,6 +833,7 @@ test "alignment of wrapping an error union payload" {
 
         fn foo() anyerror!I {
             var i: I = .{ .x = 1234 };
+            _ = &i;
             return i;
         }
     };
@@ -842,6 +845,7 @@ test "compare error union and error set" {
 
     var a: anyerror = error.Foo;
     var b: anyerror!u32 = error.Bar;
+    _ = &a;
 
     try expect(a != b);
     try expect(b != a);
@@ -863,6 +867,7 @@ fn non_errorable() void {
     // This test is needed because stage 2's fix for #1923 means that catch blocks interact
     // with the error return trace index.
     var x: error{Foo}!void = {};
+    _ = &x;
     return x catch {};
 }
 
@@ -902,6 +907,7 @@ test "optional error union return type" {
     const S = struct {
         fn foo() ?anyerror!u32 {
             var x: u32 = 1234;
+            _ = &x;
             return @as(anyerror!u32, x);
         }
     };

@@ -37,6 +37,7 @@ fn gimme1or2(comptime a: bool) i32 {
     const x: i32 = 1;
     const y: i32 = 2;
     comptime var z: i32 = if (a) x else y;
+    _ = &z;
     return z;
 }
 test "inline variable gets result of const if" {
@@ -74,6 +75,7 @@ test "constant expressions" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     var array: [array_size]u8 = undefined;
+    _ = &array;
     try expect(@sizeOf(@TypeOf(array)) == 20);
 }
 const array_size: u8 = 20;
@@ -129,7 +131,7 @@ test "pointer to type" {
     comptime {
         var T: type = i32;
         try expect(T == i32);
-        var ptr = &T;
+        const ptr = &T;
         try expect(@TypeOf(ptr) == *type);
         ptr.* = f32;
         try expect(T == f32);
@@ -372,6 +374,7 @@ fn doNothingWithType(comptime T: type) void {
 test "zero extend from u0 to u1" {
     var zero_u0: u0 = 0;
     var zero_u1: u1 = zero_u0;
+    _ = .{ &zero_u0, &zero_u1 };
     try expect(zero_u1 == 0);
 }
 
@@ -408,6 +411,7 @@ test "inline for with same type but different values" {
     var res: usize = 0;
     inline for ([_]type{ [2]u8, [1]u8, [2]u8 }) |T| {
         var a: T = undefined;
+        _ = &a;
         res += a.len;
     }
     try expect(res == 5);
@@ -460,9 +464,9 @@ test "comptime shl" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
 
-    var a: u128 = 3;
-    var b: u7 = 63;
-    var c: u128 = 3 << 63;
+    const a: u128 = 3;
+    const b: u7 = 63;
+    const c: u128 = 3 << 63;
     try expect((a << b) == c);
 }
 
@@ -489,6 +493,7 @@ test "comptime shlWithOverflow" {
 
     const ct_shifted = @shlWithOverflow(~@as(u64, 0), 16)[0];
     var a = ~@as(u64, 0);
+    _ = &a;
     const rt_shifted = @shlWithOverflow(a, 16)[0];
 
     try expect(ct_shifted == rt_shifted);
@@ -521,7 +526,8 @@ test "runtime 128 bit integer division" {
 
     var a: u128 = 152313999999999991610955792383;
     var b: u128 = 10000000000000000000;
-    var c = a / b;
+    _ = .{ &a, &b };
+    const c = a / b;
     try expect(c == 15231399999);
 }
 
@@ -555,6 +561,7 @@ test "inlined loop has array literal with elided runtime scope on first iteratio
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     var runtime = [1]i32{3};
+    _ = &runtime;
     comptime var i: usize = 0;
     inline while (i < 2) : (i += 1) {
         const result = if (i == 0) [1]i32{2} else runtime;
@@ -692,7 +699,7 @@ test "call method with comptime pass-by-non-copying-value self parameter" {
     };
 
     const s = S{ .a = 2 };
-    var b = s.b();
+    const b = s.b();
     try expect(b == 2);
 }
 
@@ -759,7 +766,8 @@ test "array concatenation peer resolves element types - value" {
 
     var a = [2]u3{ 1, 7 };
     var b = [3]u8{ 200, 225, 255 };
-    var c = a ++ b;
+    _ = .{ &a, &b };
+    const c = a ++ b;
     comptime assert(@TypeOf(c) == [5]u8);
     try expect(c[0] == 1);
     try expect(c[1] == 7);
@@ -775,7 +783,7 @@ test "array concatenation peer resolves element types - pointer" {
 
     var a = [2]u3{ 1, 7 };
     var b = [3]u8{ 200, 225, 255 };
-    var c = &a ++ &b;
+    const c = &a ++ &b;
     comptime assert(@TypeOf(c) == *[5]u8);
     try expect(c[0] == 1);
     try expect(c[1] == 7);
@@ -791,14 +799,15 @@ test "array concatenation sets the sentinel - value" {
 
     var a = [2]u3{ 1, 7 };
     var b = [3:69]u8{ 200, 225, 255 };
-    var c = a ++ b;
+    _ = .{ &a, &b };
+    const c = a ++ b;
     comptime assert(@TypeOf(c) == [5:69]u8);
     try expect(c[0] == 1);
     try expect(c[1] == 7);
     try expect(c[2] == 200);
     try expect(c[3] == 225);
     try expect(c[4] == 255);
-    var ptr: [*]const u8 = &c;
+    const ptr: [*]const u8 = &c;
     try expect(ptr[5] == 69);
 }
 
@@ -808,14 +817,14 @@ test "array concatenation sets the sentinel - pointer" {
 
     var a = [2]u3{ 1, 7 };
     var b = [3:69]u8{ 200, 225, 255 };
-    var c = &a ++ &b;
+    const c = &a ++ &b;
     comptime assert(@TypeOf(c) == *[5:69]u8);
     try expect(c[0] == 1);
     try expect(c[1] == 7);
     try expect(c[2] == 200);
     try expect(c[3] == 225);
     try expect(c[4] == 255);
-    var ptr: [*]const u8 = c;
+    const ptr: [*]const u8 = c;
     try expect(ptr[5] == 69);
 }
 
@@ -825,13 +834,14 @@ test "array multiplication sets the sentinel - value" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     var a = [2:7]u3{ 1, 6 };
-    var b = a ** 2;
+    _ = &a;
+    const b = a ** 2;
     comptime assert(@TypeOf(b) == [4:7]u3);
     try expect(b[0] == 1);
     try expect(b[1] == 6);
     try expect(b[2] == 1);
     try expect(b[3] == 6);
-    var ptr: [*]const u3 = &b;
+    const ptr: [*]const u3 = &b;
     try expect(ptr[4] == 7);
 }
 
@@ -841,13 +851,13 @@ test "array multiplication sets the sentinel - pointer" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     var a = [2:7]u3{ 1, 6 };
-    var b = &a ** 2;
+    const b = &a ** 2;
     comptime assert(@TypeOf(b) == *[4:7]u3);
     try expect(b[0] == 1);
     try expect(b[1] == 6);
     try expect(b[2] == 1);
     try expect(b[3] == 6);
-    var ptr: [*]const u3 = b;
+    const ptr: [*]const u3 = b;
     try expect(ptr[4] == 7);
 }
 
@@ -913,8 +923,8 @@ test "comptime pointer load through elem_ptr" {
                 .x = i,
             };
         }
-        var ptr = @as([*]S, @ptrCast(&array));
-        var x = ptr[0].x;
+        var ptr: [*]S = @ptrCast(&array);
+        const x = ptr[0].x;
         assert(x == 0);
         ptr += 1;
         assert(ptr[1].x == 2);
@@ -953,11 +963,12 @@ test "closure capture type of runtime-known parameter" {
     const S = struct {
         fn b(c: anytype) !void {
             const D = struct { c: @TypeOf(c) };
-            var d = D{ .c = c };
+            const d: D = .{ .c = c };
             try expect(d.c == 1234);
         }
     };
     var c: i32 = 1234;
+    _ = &c;
     try S.b(c);
 }
 
@@ -966,6 +977,7 @@ test "closure capture type of runtime-known var" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     var x: u32 = 1234;
+    _ = &x;
     const S = struct { val: @TypeOf(x + 100) };
     const s: S = .{ .val = x };
     try expect(s.val == 1234);
@@ -977,6 +989,7 @@ test "comptime break passing through runtime condition converted to runtime brea
     const S = struct {
         fn doTheTest() !void {
             var runtime: u8 = 'b';
+            _ = &runtime;
             inline for ([3]u8{ 'a', 'b', 'c' }) |byte| {
                 bar();
                 if (byte == runtime) {
@@ -1010,6 +1023,7 @@ test "comptime break to outer loop passing through runtime condition converted t
     const S = struct {
         fn doTheTest() !void {
             var runtime: u8 = 'b';
+            _ = &runtime;
             outer: inline for ([3]u8{ 'A', 'B', 'C' }) |outer_byte| {
                 inline for ([3]u8{ 'a', 'b', 'c' }) |byte| {
                     bar(outer_byte);
@@ -1387,6 +1401,7 @@ test "break from inline loop depends on runtime condition" {
 
 test "inline for inside a runtime condition" {
     var a = false;
+    _ = &a;
     if (a) {
         const arr = .{ 1, 2, 3 };
         inline for (arr) |val| {
@@ -1522,6 +1537,7 @@ test "non-optional and optional array elements concatenated" {
 
     const array = [1]u8{'A'} ++ [1]?u8{null};
     var index: usize = 0;
+    _ = &index;
     try expect(array[index].? == 'A');
 }
 
@@ -1556,6 +1572,7 @@ test "container level const and var have unique addresses" {
         var v: @This() = c;
     };
     var p = &S.c;
+    _ = &p;
     try std.testing.expect(p.x == S.c.x);
     S.v.x = 2;
     try std.testing.expect(p.x == S.c.x);
@@ -1625,7 +1642,8 @@ test "inline for loop of functions returning error unions" {
 test "if inside a switch" {
     var condition = true;
     var wave_type: u32 = 0;
-    var sample: i32 = switch (wave_type) {
+    _ = .{ &condition, &wave_type };
+    const sample: i32 = switch (wave_type) {
         0 => if (condition) 2 else 3,
         1 => 100,
         2 => 200,
@@ -1673,6 +1691,7 @@ test "@inComptime" {
 comptime {
     var foo = [3]u8{ 0x55, 0x55, 0x55 };
     var bar = [2]u8{ 1, 2 };
+    _ = .{ &foo, &bar };
     foo[0..2].* = bar;
     assert(foo[0] == 1);
     assert(foo[1] == 2);