diff --git a/lib/std/heap/general_purpose_allocator.zig b/lib/std/heap/general_purpose_allocator.zig
index 2e2fc6d010..04cce1dffd 100644
--- a/lib/std/heap/general_purpose_allocator.zig
+++ b/lib/std/heap/general_purpose_allocator.zig
@@ -623,9 +623,9 @@ fn eql_addr(a: usize, b: usize) bool {
 const test_config = Config{};
 
 test "small allocations - free in same order" {
-    var gpda = GeneralPurposeAllocator(test_config){};
-    defer std.testing.expect(!gpda.deinit());
-    const allocator = &gpda.allocator;
+    var gpa = GeneralPurposeAllocator(test_config){};
+    defer std.testing.expect(!gpa.deinit());
+    const allocator = &gpa.allocator;
 
     var list = std.ArrayList(*u64).init(std.testing.allocator);
     defer list.deinit();
@@ -642,9 +642,9 @@ test "small allocations - free in same order" {
 }
 
 test "small allocations - free in reverse order" {
-    var gpda = GeneralPurposeAllocator(test_config){};
-    defer std.testing.expect(!gpda.deinit());
-    const allocator = &gpda.allocator;
+    var gpa = GeneralPurposeAllocator(test_config){};
+    defer std.testing.expect(!gpa.deinit());
+    const allocator = &gpa.allocator;
 
     var list = std.ArrayList(*u64).init(std.testing.allocator);
     defer list.deinit();
@@ -661,9 +661,9 @@ test "small allocations - free in reverse order" {
 }
 
 test "large allocations" {
-    var gpda = GeneralPurposeAllocator(test_config){};
-    defer std.testing.expect(!gpda.deinit());
-    const allocator = &gpda.allocator;
+    var gpa = GeneralPurposeAllocator(test_config){};
+    defer std.testing.expect(!gpa.deinit());
+    const allocator = &gpa.allocator;
 
     const ptr1 = try allocator.alloc(u64, 42768);
     const ptr2 = try allocator.alloc(u64, 52768);
@@ -674,9 +674,9 @@ test "large allocations" {
 }
 
 test "realloc" {
-    var gpda = GeneralPurposeAllocator(test_config){};
-    defer std.testing.expect(!gpda.deinit());
-    const allocator = &gpda.allocator;
+    var gpa = GeneralPurposeAllocator(test_config){};
+    defer std.testing.expect(!gpa.deinit());
+    const allocator = &gpa.allocator;
 
     var slice = try allocator.alignedAlloc(u8, @alignOf(u32), 1);
     defer allocator.free(slice);
@@ -696,9 +696,9 @@ test "realloc" {
 }
 
 test "shrink" {
-    var gpda = GeneralPurposeAllocator(test_config){};
-    defer std.testing.expect(!gpda.deinit());
-    const allocator = &gpda.allocator;
+    var gpa = GeneralPurposeAllocator(test_config){};
+    defer std.testing.expect(!gpa.deinit());
+    const allocator = &gpa.allocator;
 
     var slice = try allocator.alloc(u8, 20);
     defer allocator.free(slice);
@@ -719,14 +719,14 @@ test "shrink" {
 }
 
 test "large object - grow" {
-    var gpda = GeneralPurposeAllocator(test_config){};
-    defer std.testing.expect(!gpda.deinit());
-    const allocator = &gpda.allocator;
+    var gpa = GeneralPurposeAllocator(test_config){};
+    defer std.testing.expect(!gpa.deinit());
+    const allocator = &gpa.allocator;
 
     var slice1 = try allocator.alloc(u8, page_size * 2 - 20);
     defer allocator.free(slice1);
 
-    var old = slice1;
+    const old = slice1;
     slice1 = try allocator.realloc(slice1, page_size * 2 - 10);
     std.testing.expect(slice1.ptr == old.ptr);
 
@@ -737,9 +737,9 @@ test "large object - grow" {
 }
 
 test "realloc small object to large object" {
-    var gpda = GeneralPurposeAllocator(test_config){};
-    defer std.testing.expect(!gpda.deinit());
-    const allocator = &gpda.allocator;
+    var gpa = GeneralPurposeAllocator(test_config){};
+    defer std.testing.expect(!gpa.deinit());
+    const allocator = &gpa.allocator;
 
     var slice = try allocator.alloc(u8, 70);
     defer allocator.free(slice);
@@ -754,9 +754,9 @@ test "realloc small object to large object" {
 }
 
 test "shrink large object to large object" {
-    var gpda = GeneralPurposeAllocator(test_config){};
-    defer std.testing.expect(!gpda.deinit());
-    const allocator = &gpda.allocator;
+    var gpa = GeneralPurposeAllocator(test_config){};
+    defer std.testing.expect(!gpa.deinit());
+    const allocator = &gpa.allocator;
 
     var slice = try allocator.alloc(u8, page_size * 2 + 50);
     defer allocator.free(slice);
@@ -777,9 +777,9 @@ test "shrink large object to large object" {
 }
 
 test "shrink large object to large object with larger alignment" {
-    var gpda = GeneralPurposeAllocator(test_config){};
-    defer std.testing.expect(!gpda.deinit());
-    const allocator = &gpda.allocator;
+    var gpa = GeneralPurposeAllocator(test_config){};
+    defer std.testing.expect(!gpa.deinit());
+    const allocator = &gpa.allocator;
 
     var debug_buffer: [1000]u8 = undefined;
     const debug_allocator = &std.heap.FixedBufferAllocator.init(&debug_buffer).allocator;
@@ -805,9 +805,9 @@ test "shrink large object to large object with larger alignment" {
 }
 
 test "realloc large object to small object" {
-    var gpda = GeneralPurposeAllocator(test_config){};
-    defer std.testing.expect(!gpda.deinit());
-    const allocator = &gpda.allocator;
+    var gpa = GeneralPurposeAllocator(test_config){};
+    defer std.testing.expect(!gpa.deinit());
+    const allocator = &gpa.allocator;
 
     var slice = try allocator.alloc(u8, page_size * 2 + 50);
     defer allocator.free(slice);
@@ -820,18 +820,18 @@ test "realloc large object to small object" {
 }
 
 test "non-page-allocator backing allocator" {
-    var gpda = GeneralPurposeAllocator(.{}){ .backing_allocator = std.testing.allocator };
-    defer std.testing.expect(!gpda.deinit());
-    const allocator = &gpda.allocator;
+    var gpa = GeneralPurposeAllocator(.{}){ .backing_allocator = std.testing.allocator };
+    defer std.testing.expect(!gpa.deinit());
+    const allocator = &gpa.allocator;
 
     const ptr = try allocator.create(i32);
     defer allocator.destroy(ptr);
 }
 
 test "realloc large object to larger alignment" {
-    var gpda = GeneralPurposeAllocator(test_config){};
-    defer std.testing.expect(!gpda.deinit());
-    const allocator = &gpda.allocator;
+    var gpa = GeneralPurposeAllocator(test_config){};
+    defer std.testing.expect(!gpa.deinit());
+    const allocator = &gpa.allocator;
 
     var debug_buffer: [1000]u8 = undefined;
     const debug_allocator = &std.heap.FixedBufferAllocator.init(&debug_buffer).allocator;
@@ -865,9 +865,9 @@ test "realloc large object to larger alignment" {
 
 test "large object shrinks to small but allocation fails during shrink" {
     var failing_allocator = std.testing.FailingAllocator.init(std.heap.page_allocator, 3);
-    var gpda = GeneralPurposeAllocator(.{}){ .backing_allocator = &failing_allocator.allocator };
-    defer std.testing.expect(!gpda.deinit());
-    const allocator = &gpda.allocator;
+    var gpa = GeneralPurposeAllocator(.{}){ .backing_allocator = &failing_allocator.allocator };
+    defer std.testing.expect(!gpa.deinit());
+    const allocator = &gpa.allocator;
 
     var slice = try allocator.alloc(u8, page_size * 2 + 50);
     defer allocator.free(slice);
@@ -882,9 +882,9 @@ test "large object shrinks to small but allocation fails during shrink" {
 }
 
 test "objects of size 1024 and 2048" {
-    var gpda = GeneralPurposeAllocator(test_config){};
-    defer std.testing.expect(!gpda.deinit());
-    const allocator = &gpda.allocator;
+    var gpa = GeneralPurposeAllocator(test_config){};
+    defer std.testing.expect(!gpa.deinit());
+    const allocator = &gpa.allocator;
 
     const slice = try allocator.alloc(u8, 1025);
     const slice2 = try allocator.alloc(u8, 3000);
@@ -894,27 +894,27 @@ test "objects of size 1024 and 2048" {
 }
 
 test "setting a memory cap" {
-    var gpda = GeneralPurposeAllocator(.{ .enable_memory_limit = true }){};
-    defer std.testing.expect(!gpda.deinit());
-    const allocator = &gpda.allocator;
+    var gpa = GeneralPurposeAllocator(.{ .enable_memory_limit = true }){};
+    defer std.testing.expect(!gpa.deinit());
+    const allocator = &gpa.allocator;
 
-    gpda.setRequestedMemoryLimit(1010);
+    gpa.setRequestedMemoryLimit(1010);
 
     const small = try allocator.create(i32);
-    std.testing.expect(gpda.total_requested_bytes == 4);
+    std.testing.expect(gpa.total_requested_bytes == 4);
 
     const big = try allocator.alloc(u8, 1000);
-    std.testing.expect(gpda.total_requested_bytes == 1004);
+    std.testing.expect(gpa.total_requested_bytes == 1004);
 
     std.testing.expectError(error.OutOfMemory, allocator.create(u64));
 
     allocator.destroy(small);
-    std.testing.expect(gpda.total_requested_bytes == 1000);
+    std.testing.expect(gpa.total_requested_bytes == 1000);
 
     allocator.free(big);
-    std.testing.expect(gpda.total_requested_bytes == 0);
+    std.testing.expect(gpa.total_requested_bytes == 0);
 
     const exact = try allocator.alloc(u8, 1010);
-    std.testing.expect(gpda.total_requested_bytes == 1010);
+    std.testing.expect(gpa.total_requested_bytes == 1010);
     allocator.free(exact);
 }