compiler: correct unnecessary uses of 'var'

17 files changed, 55 insertions, 55 deletions

diff --git a/src/link/C.zig b/src/link/C.zig
index 40dfc0771d..f97f19f85b 100644
--- a/src/link/C.zig
+++ b/src/link/C.zig
@@ -103,7 +103,7 @@ pub fn openPath(gpa: Allocator, sub_path: []const u8, options: link.Options) !*C
     });
     errdefer file.close();
 
-    var c_file = try gpa.create(C);
+    const c_file = try gpa.create(C);
     errdefer gpa.destroy(c_file);
 
     c_file.* = .{
diff --git a/src/link/Coff.zig b/src/link/Coff.zig
index 0d26e24b2d..16736ab1af 100644
--- a/src/link/Coff.zig
+++ b/src/link/Coff.zig
@@ -563,7 +563,7 @@ fn allocateAtom(self: *Coff, atom_index: Atom.Index, new_atom_size: u32, alignme
 
     // First we look for an appropriately sized free list node.
     // The list is unordered. We'll just take the first thing that works.
-    var vaddr = blk: {
+    const vaddr = blk: {
         var i: usize = 0;
         while (i < free_list.items.len) {
             const big_atom_index = free_list.items[i];
@@ -815,7 +815,7 @@ fn writeAtom(self: *Coff, atom_index: Atom.Index, code: []u8) !void {
 }
 
 fn debugMem(allocator: Allocator, handle: std.ChildProcess.Id, pvaddr: std.os.windows.LPVOID, code: []const u8) !void {
-    var buffer = try allocator.alloc(u8, code.len);
+    const buffer = try allocator.alloc(u8, code.len);
     defer allocator.free(buffer);
     const memread = try std.os.windows.ReadProcessMemory(handle, pvaddr, buffer);
     log.debug("to write: {x}", .{std.fmt.fmtSliceHexLower(code)});
@@ -1071,7 +1071,7 @@ pub fn updateFunc(self: *Coff, mod: *Module, func_index: InternPool.Index, air:
         &code_buffer,
         .none,
     );
-    var code = switch (res) {
+    const code = switch (res) {
         .ok => code_buffer.items,
         .fail => |em| {
             decl.analysis = .codegen_failure;
@@ -1132,7 +1132,7 @@ fn lowerConst(self: *Coff, name: []const u8, tv: TypedValue, required_alignment:
     const res = try codegen.generateSymbol(&self.base, src_loc, tv, &code_buffer, .none, .{
         .parent_atom_index = self.getAtom(atom_index).getSymbolIndex().?,
     });
-    var code = switch (res) {
+    const code = switch (res) {
         .ok => code_buffer.items,
         .fail => |em| return .{ .fail = em },
     };
@@ -1196,7 +1196,7 @@ pub fn updateDecl(
     }, &code_buffer, .none, .{
         .parent_atom_index = atom.getSymbolIndex().?,
     });
-    var code = switch (res) {
+    const code = switch (res) {
         .ok => code_buffer.items,
         .fail => |em| {
             decl.analysis = .codegen_failure;
diff --git a/src/link/Dwarf.zig b/src/link/Dwarf.zig
index 385f09c2fc..8c889fa30d 100644
--- a/src/link/Dwarf.zig
+++ b/src/link/Dwarf.zig
@@ -303,7 +303,7 @@ pub const DeclState = struct {
                                 // DW.AT.name, DW.FORM.string
                                 try dbg_info_buffer.writer().print("{d}\x00", .{field_index});
                                 // DW.AT.type, DW.FORM.ref4
-                                var index = dbg_info_buffer.items.len;
+                                const index = dbg_info_buffer.items.len;
                                 try dbg_info_buffer.resize(index + 4);
                                 try self.addTypeRelocGlobal(atom_index, field_ty.toType(), @intCast(index));
                                 // DW.AT.data_member_location, DW.FORM.udata
@@ -329,7 +329,7 @@ pub const DeclState = struct {
                                     // DW.AT.name, DW.FORM.string
                                     try dbg_info_buffer.writer().print("{d}\x00", .{field_index});
                                     // DW.AT.type, DW.FORM.ref4
-                                    var index = dbg_info_buffer.items.len;
+                                    const index = dbg_info_buffer.items.len;
                                     try dbg_info_buffer.resize(index + 4);
                                     try self.addTypeRelocGlobal(atom_index, field_ty.toType(), @intCast(index));
                                     // DW.AT.data_member_location, DW.FORM.udata
@@ -350,7 +350,7 @@ pub const DeclState = struct {
                                     dbg_info_buffer.appendSliceAssumeCapacity(field_name);
                                     dbg_info_buffer.appendAssumeCapacity(0);
                                     // DW.AT.type, DW.FORM.ref4
-                                    var index = dbg_info_buffer.items.len;
+                                    const index = dbg_info_buffer.items.len;
                                     try dbg_info_buffer.resize(index + 4);
                                     try self.addTypeRelocGlobal(atom_index, field_ty.toType(), @intCast(index));
                                     // DW.AT.data_member_location, DW.FORM.udata
diff --git a/src/link/Elf.zig b/src/link/Elf.zig
index 3883f76268..e64ad222ad 100644
--- a/src/link/Elf.zig
+++ b/src/link/Elf.zig
@@ -967,7 +967,7 @@ pub fn flushModule(self: *Elf, comp: *Compilation, prog_node: *std.Progress.Node
     // --verbose-link
     if (self.base.options.verbose_link) try self.dumpArgv(comp);
 
-    var csu = try CsuObjects.init(arena, self.base.options, comp);
+    const csu = try CsuObjects.init(arena, self.base.options, comp);
     const compiler_rt_path: ?[]const u8 = blk: {
         if (comp.compiler_rt_lib) |x| break :blk x.full_object_path;
         if (comp.compiler_rt_obj) |x| break :blk x.full_object_path;
@@ -1493,7 +1493,7 @@ fn dumpArgv(self: *Elf, comp: *Compilation) !void {
     } else null;
     const gc_sections = self.base.options.gc_sections orelse false;
 
-    var csu = try CsuObjects.init(arena, self.base.options, comp);
+    const csu = try CsuObjects.init(arena, self.base.options, comp);
     const compiler_rt_path: ?[]const u8 = blk: {
         if (comp.compiler_rt_lib) |x| break :blk x.full_object_path;
         if (comp.compiler_rt_obj) |x| break :blk x.full_object_path;
@@ -2599,7 +2599,7 @@ fn linkWithLLD(self: *Elf, comp: *Compilation, prog_node: *std.Progress.Node) !v
         try argv.append(full_out_path);
 
         // csu prelude
-        var csu = try CsuObjects.init(arena, self.base.options, comp);
+        const csu = try CsuObjects.init(arena, self.base.options, comp);
         if (csu.crt0) |v| try argv.append(v);
         if (csu.crti) |v| try argv.append(v);
         if (csu.crtbegin) |v| try argv.append(v);
@@ -3852,7 +3852,7 @@ fn sortPhdrs(self: *Elf) error{OutOfMemory}!void {
         backlinks[entry.phndx] = @as(u16, @intCast(i));
     }
 
-    var slice = try self.phdrs.toOwnedSlice(gpa);
+    const slice = try self.phdrs.toOwnedSlice(gpa);
     defer gpa.free(slice);
 
     try self.phdrs.ensureTotalCapacityPrecise(gpa, slice.len);
@@ -3957,7 +3957,7 @@ fn sortShdrs(self: *Elf) !void {
         backlinks[entry.shndx] = @as(u16, @intCast(i));
     }
 
-    var slice = try self.shdrs.toOwnedSlice(gpa);
+    const slice = try self.shdrs.toOwnedSlice(gpa);
     defer gpa.free(slice);
 
     try self.shdrs.ensureTotalCapacityPrecise(gpa, slice.len);
diff --git a/src/link/Elf/eh_frame.zig b/src/link/Elf/eh_frame.zig
index 73857d03d2..1d24285b30 100644
--- a/src/link/Elf/eh_frame.zig
+++ b/src/link/Elf/eh_frame.zig
@@ -217,7 +217,7 @@ pub const Iterator = struct {
         var stream = std.io.fixedBufferStream(it.data[it.pos..]);
         const reader = stream.reader();
 
-        var size = try reader.readInt(u32, .little);
+        const size = try reader.readInt(u32, .little);
         if (size == 0xFFFFFFFF) @panic("TODO");
 
         const id = try reader.readInt(u32, .little);
diff --git a/src/link/MachO.zig b/src/link/MachO.zig
index f0938a3c19..67c9aaac05 100644
--- a/src/link/MachO.zig
+++ b/src/link/MachO.zig
@@ -2252,7 +2252,7 @@ pub fn updateFunc(self: *MachO, mod: *Module, func_index: InternPool.Index, air:
     else
         try codegen.generateFunction(&self.base, decl.srcLoc(mod), func_index, air, liveness, &code_buffer, .none);
 
-    var code = switch (res) {
+    const code = switch (res) {
         .ok => code_buffer.items,
         .fail => |em| {
             decl.analysis = .codegen_failure;
@@ -2332,7 +2332,7 @@ fn lowerConst(
     const res = try codegen.generateSymbol(&self.base, src_loc, tv, &code_buffer, .none, .{
         .parent_atom_index = self.getAtom(atom_index).getSymbolIndex().?,
     });
-    var code = switch (res) {
+    const code = switch (res) {
         .ok => code_buffer.items,
         .fail => |em| return .{ .fail = em },
     };
@@ -2418,7 +2418,7 @@ pub fn updateDecl(self: *MachO, mod: *Module, decl_index: Module.Decl.Index) !vo
             .parent_atom_index = sym_index,
         });
 
-    var code = switch (res) {
+    const code = switch (res) {
         .ok => code_buffer.items,
         .fail => |em| {
             decl.analysis = .codegen_failure;
@@ -2587,7 +2587,7 @@ fn updateThreadlocalVariable(self: *MachO, module: *Module, decl_index: Module.D
             .parent_atom_index = init_sym_index,
         });
 
-    var code = switch (res) {
+    const code = switch (res) {
         .ok => code_buffer.items,
         .fail => |em| {
             decl.analysis = .codegen_failure;
@@ -3427,7 +3427,7 @@ fn allocateAtom(self: *MachO, atom_index: Atom.Index, new_atom_size: u64, alignm
 
     // First we look for an appropriately sized free list node.
     // The list is unordered. We'll just take the first thing that works.
-    var vaddr = blk: {
+    const vaddr = blk: {
         var i: usize = 0;
         while (i < free_list.items.len) {
             const big_atom_index = free_list.items[i];
@@ -3971,7 +3971,7 @@ fn writeDyldInfoData(self: *MachO) !void {
     link_seg.filesize = needed_size;
     assert(mem.isAlignedGeneric(u64, link_seg.fileoff + link_seg.filesize, @alignOf(u64)));
 
-    var buffer = try gpa.alloc(u8, needed_size);
+    const buffer = try gpa.alloc(u8, needed_size);
     defer gpa.free(buffer);
     @memset(buffer, 0);
 
@@ -5228,7 +5228,7 @@ fn reportMissingLibraryError(
 ) error{OutOfMemory}!void {
     const gpa = self.base.allocator;
     try self.misc_errors.ensureUnusedCapacity(gpa, 1);
-    var notes = try gpa.alloc(File.ErrorMsg, checked_paths.len);
+    const notes = try gpa.alloc(File.ErrorMsg, checked_paths.len);
     errdefer gpa.free(notes);
     for (checked_paths, notes) |path, *note| {
         note.* = .{ .msg = try std.fmt.allocPrint(gpa, "tried {s}", .{path}) };
diff --git a/src/link/MachO/Archive.zig b/src/link/MachO/Archive.zig
index 6bdc6d916d..ba3915f51b 100644
--- a/src/link/MachO/Archive.zig
+++ b/src/link/MachO/Archive.zig
@@ -98,7 +98,7 @@ pub fn parse(self: *Archive, allocator: Allocator, reader: anytype) !void {
     _ = try reader.readBytesNoEof(SARMAG);
     self.header = try reader.readStruct(ar_hdr);
     const name_or_length = try self.header.nameOrLength();
-    var embedded_name = try parseName(allocator, name_or_length, reader);
+    const embedded_name = try parseName(allocator, name_or_length, reader);
     log.debug("parsing archive '{s}' at '{s}'", .{ embedded_name, self.name });
     defer allocator.free(embedded_name);
 
@@ -124,7 +124,7 @@ fn parseName(allocator: Allocator, name_or_length: ar_hdr.NameOrLength, reader:
 
 fn parseTableOfContents(self: *Archive, allocator: Allocator, reader: anytype) !void {
     const symtab_size = try reader.readInt(u32, .little);
-    var symtab = try allocator.alloc(u8, symtab_size);
+    const symtab = try allocator.alloc(u8, symtab_size);
     defer allocator.free(symtab);
 
     reader.readNoEof(symtab) catch {
@@ -133,7 +133,7 @@ fn parseTableOfContents(self: *Archive, allocator: Allocator, reader: anytype) !
     };
 
     const strtab_size = try reader.readInt(u32, .little);
-    var strtab = try allocator.alloc(u8, strtab_size);
+    const strtab = try allocator.alloc(u8, strtab_size);
     defer allocator.free(strtab);
 
     reader.readNoEof(strtab) catch {
diff --git a/src/link/MachO/Dylib.zig b/src/link/MachO/Dylib.zig
index 91411dc572..65d503b1ae 100644
--- a/src/link/MachO/Dylib.zig
+++ b/src/link/MachO/Dylib.zig
@@ -167,7 +167,7 @@ pub fn parseFromBinary(
             .REEXPORT_DYLIB => {
                 if (should_lookup_reexports) {
                     // Parse install_name to dependent dylib.
-                    var id = try Id.fromLoadCommand(
+                    const id = try Id.fromLoadCommand(
                         allocator,
                         cmd.cast(macho.dylib_command).?,
                         cmd.getDylibPathName(),
@@ -410,7 +410,7 @@ pub fn parseFromStub(
 
                                 log.debug("  (found re-export '{s}')", .{lib});
 
-                                var dep_id = try Id.default(allocator, lib);
+                                const dep_id = try Id.default(allocator, lib);
                                 try dependent_libs.writeItem(.{ .id = dep_id, .parent = dylib_id });
                             }
                         }
@@ -527,7 +527,7 @@ pub fn parseFromStub(
 
                     log.debug("  (found re-export '{s}')", .{lib});
 
-                    var dep_id = try Id.default(allocator, lib);
+                    const dep_id = try Id.default(allocator, lib);
                     try dependent_libs.writeItem(.{ .id = dep_id, .parent = dylib_id });
                 }
             }
diff --git a/src/link/MachO/Trie.zig b/src/link/MachO/Trie.zig
index d86338f84b..98add0315c 100644
--- a/src/link/MachO/Trie.zig
+++ b/src/link/MachO/Trie.zig
@@ -150,7 +150,7 @@ pub fn deinit(self: *Trie, allocator: Allocator) void {
 }
 
 test "Trie node count" {
-    var gpa = testing.allocator;
+    const gpa = testing.allocator;
     var trie: Trie = .{};
     defer trie.deinit(gpa);
     try trie.init(gpa);
@@ -196,7 +196,7 @@ test "Trie node count" {
 }
 
 test "Trie basic" {
-    var gpa = testing.allocator;
+    const gpa = testing.allocator;
     var trie: Trie = .{};
     defer trie.deinit(gpa);
     try trie.init(gpa);
@@ -254,7 +254,7 @@ fn expectEqualHexStrings(expected: []const u8, given: []const u8) !void {
     const given_fmt = try std.fmt.allocPrint(testing.allocator, "{x}", .{std.fmt.fmtSliceHexLower(given)});
     defer testing.allocator.free(given_fmt);
     const idx = mem.indexOfDiff(u8, expected_fmt, given_fmt).?;
-    var padding = try testing.allocator.alloc(u8, idx + 5);
+    const padding = try testing.allocator.alloc(u8, idx + 5);
     defer testing.allocator.free(padding);
     @memset(padding, ' ');
     std.debug.print("\nEXP: {s}\nGIV: {s}\n{s}^ -- first differing byte\n", .{ expected_fmt, given_fmt, padding });
@@ -292,7 +292,7 @@ test "write Trie to a byte stream" {
         0x3, 0x0, 0x80, 0x20, 0x0, // terminal node
     };
 
-    var buffer = try gpa.alloc(u8, trie.size);
+    const buffer = try gpa.alloc(u8, trie.size);
     defer gpa.free(buffer);
     var stream = std.io.fixedBufferStream(buffer);
     {
@@ -331,7 +331,7 @@ test "parse Trie from byte stream" {
 
     try trie.finalize(gpa);
 
-    var out_buffer = try gpa.alloc(u8, trie.size);
+    const out_buffer = try gpa.alloc(u8, trie.size);
     defer gpa.free(out_buffer);
     var out_stream = std.io.fixedBufferStream(out_buffer);
     _ = try trie.write(out_stream.writer());
@@ -362,7 +362,7 @@ test "ordering bug" {
         0x00, 0x12, 0x03, 0x00, 0xD8, 0x0A, 0x00,
     };
 
-    var buffer = try gpa.alloc(u8, trie.size);
+    const buffer = try gpa.alloc(u8, trie.size);
     defer gpa.free(buffer);
     var stream = std.io.fixedBufferStream(buffer);
     // Writing finalized trie again should yield the same result.
@@ -426,7 +426,7 @@ pub const Node = struct {
             // To: A -> C -> B
             const mid = try allocator.create(Node);
             mid.* = .{ .base = self.base };
-            var to_label = try allocator.dupe(u8, edge.label[match..]);
+            const to_label = try allocator.dupe(u8, edge.label[match..]);
             allocator.free(edge.label);
             const to_node = edge.to;
             edge.to = mid;
@@ -573,7 +573,7 @@ pub const Node = struct {
     /// Updates offset of this node in the output byte stream.
     fn finalize(self: *Node, offset_in_trie: u64) !FinalizeResult {
         var stream = std.io.countingWriter(std.io.null_writer);
-        var writer = stream.writer();
+        const writer = stream.writer();
 
         var node_size: u64 = 0;
         if (self.terminal_info) |info| {
diff --git a/src/link/MachO/UnwindInfo.zig b/src/link/MachO/UnwindInfo.zig
index c588b65ea3..be6c9dbb34 100644
--- a/src/link/MachO/UnwindInfo.zig
+++ b/src/link/MachO/UnwindInfo.zig
@@ -417,7 +417,7 @@ pub fn collect(info: *UnwindInfo, macho_file: *MachO) !void {
             gop.value_ptr.count += 1;
         }
 
-        var slice = common_encodings_counts.values();
+        const slice = common_encodings_counts.values();
         mem.sort(CommonEncWithCount, slice, {}, CommonEncWithCount.greaterThan);
 
         var i: u7 = 0;
diff --git a/src/link/MachO/eh_frame.zig b/src/link/MachO/eh_frame.zig
index 189d9b25cd..0f021a569c 100644
--- a/src/link/MachO/eh_frame.zig
+++ b/src/link/MachO/eh_frame.zig
@@ -586,7 +586,7 @@ pub const Iterator = struct {
         var stream = std.io.fixedBufferStream(it.data[it.pos..]);
         const reader = stream.reader();
 
-        var size = try reader.readInt(u32, .little);
+        const size = try reader.readInt(u32, .little);
         if (size == 0xFFFFFFFF) {
             log.debug("MachO doesn't support 64bit DWARF CFI __eh_frame records", .{});
             return error.BadDwarfCfi;
diff --git a/src/link/MachO/load_commands.zig b/src/link/MachO/load_commands.zig
index 669e806728..f064415739 100644
--- a/src/link/MachO/load_commands.zig
+++ b/src/link/MachO/load_commands.zig
@@ -112,7 +112,7 @@ pub fn calcMinHeaderPad(gpa: Allocator, options: *const link.Options, ctx: CalcL
     log.debug("minimum requested headerpad size 0x{x}", .{padding + @sizeOf(macho.mach_header_64)});
 
     if (options.headerpad_max_install_names) {
-        var min_headerpad_size: u32 = try calcLCsSize(gpa, options, ctx, true);
+        const min_headerpad_size: u32 = try calcLCsSize(gpa, options, ctx, true);
         log.debug("headerpad_max_install_names minimum headerpad size 0x{x}", .{
             min_headerpad_size + @sizeOf(macho.mach_header_64),
         });
diff --git a/src/link/MachO/zld.zig b/src/link/MachO/zld.zig
index 79433b3b1b..e627b91f11 100644
--- a/src/link/MachO/zld.zig
+++ b/src/link/MachO/zld.zig
@@ -503,7 +503,7 @@ pub fn linkWithZld(
             const size = math.cast(usize, linkedit.fileoff - start) orelse return error.Overflow;
             if (size > 0) {
                 log.debug("zeroing out zerofill area of length {x} at {x}", .{ size, start });
-                var padding = try gpa.alloc(u8, size);
+                const padding = try gpa.alloc(u8, size);
                 defer gpa.free(padding);
                 @memset(padding, 0);
                 try macho_file.base.file.?.pwriteAll(padding, start);
diff --git a/src/link/Plan9.zig b/src/link/Plan9.zig
index d8b6f39f76..4221aa7dee 100644
--- a/src/link/Plan9.zig
+++ b/src/link/Plan9.zig
@@ -300,7 +300,7 @@ pub fn createEmpty(gpa: Allocator, options: link.Options) !*Plan9 {
         else => return error.UnsupportedP9Architecture,
     };
 
-    var arena_allocator = std.heap.ArenaAllocator.init(gpa);
+    const arena_allocator = std.heap.ArenaAllocator.init(gpa);
 
     const self = try gpa.create(Plan9);
     self.* = .{
@@ -467,7 +467,7 @@ pub fn lowerUnnamedConst(self: *Plan9, tv: TypedValue, decl_index: Module.Decl.I
 
     const sym_index = try self.allocateSymbolIndex();
     const new_atom_idx = try self.createAtom();
-    var info: Atom = .{
+    const info: Atom = .{
         .type = .d,
         .offset = null,
         .sym_index = sym_index,
@@ -496,7 +496,7 @@ pub fn lowerUnnamedConst(self: *Plan9, tv: TypedValue, decl_index: Module.Decl.I
         },
     };
     // duped_code is freed when the unnamed const is freed
-    var duped_code = try self.base.allocator.dupe(u8, code);
+    const duped_code = try self.base.allocator.dupe(u8, code);
     errdefer self.base.allocator.free(duped_code);
     const new_atom = self.getAtomPtr(new_atom_idx);
     new_atom.* = info;
@@ -1024,7 +1024,7 @@ pub fn freeDecl(self: *Plan9, decl_index: Module.Decl.Index) void {
     const decl = mod.declPtr(decl_index);
     const is_fn = decl.val.isFuncBody(mod);
     if (is_fn) {
-        var symidx_and_submap = self.fn_decl_table.get(decl.getFileScope(mod)).?;
+        const symidx_and_submap = self.fn_decl_table.get(decl.getFileScope(mod)).?;
         var submap = symidx_and_submap.functions;
         if (submap.fetchSwapRemove(decl_index)) |removed_entry| {
             self.base.allocator.free(removed_entry.value.code);
@@ -1204,7 +1204,7 @@ fn updateLazySymbolAtom(self: *Plan9, sym: File.LazySymbol, atom_index: Atom.Ind
         },
     };
     // duped_code is freed when the atom is freed
-    var duped_code = try self.base.allocator.dupe(u8, code);
+    const duped_code = try self.base.allocator.dupe(u8, code);
     errdefer self.base.allocator.free(duped_code);
     self.getAtomPtr(atom_index).code = .{
         .code_ptr = duped_code.ptr,
@@ -1489,7 +1489,7 @@ pub fn lowerAnonDecl(self: *Plan9, decl_val: InternPool.Index, src_loc: Module.S
     // to put it in some location.
     // ...
     const gpa = self.base.allocator;
-    var gop = try self.anon_decls.getOrPut(gpa, decl_val);
+    const gop = try self.anon_decls.getOrPut(gpa, decl_val);
     const mod = self.base.options.module.?;
     if (!gop.found_existing) {
         const ty = mod.intern_pool.typeOf(decl_val).toType();
diff --git a/src/link/Wasm.zig b/src/link/Wasm.zig
index 2677184c12..da8753ac29 100644
--- a/src/link/Wasm.zig
+++ b/src/link/Wasm.zig
@@ -860,7 +860,7 @@ fn resolveSymbolsInArchives(wasm: *Wasm) !void {
             // Parse object and and resolve symbols again before we check remaining
             // undefined symbols.
             const object_file_index = @as(u16, @intCast(wasm.objects.items.len));
-            var object = try archive.parseObject(wasm.base.allocator, offset.items[0]);
+            const object = try archive.parseObject(wasm.base.allocator, offset.items[0]);
             try wasm.objects.append(wasm.base.allocator, object);
             try wasm.resolveSymbolsInObject(object_file_index);
 
@@ -1344,7 +1344,7 @@ pub fn deinit(wasm: *Wasm) void {
 /// Will re-use slots when a symbol was freed at an earlier stage.
 pub fn allocateSymbol(wasm: *Wasm) !u32 {
     try wasm.symbols.ensureUnusedCapacity(wasm.base.allocator, 1);
-    var symbol: Symbol = .{
+    const symbol: Symbol = .{
         .name = std.math.maxInt(u32), // will be set after updateDecl as well as during atom creation for decls
         .flags = @intFromEnum(Symbol.Flag.WASM_SYM_BINDING_LOCAL),
         .tag = .undefined, // will be set after updateDecl
@@ -1655,7 +1655,7 @@ pub fn getGlobalSymbol(wasm: *Wasm, name: []const u8, lib_name: ?[]const u8) !u3
     symbol.setUndefined(true);
 
     const sym_index = if (wasm.symbols_free_list.popOrNull()) |index| index else blk: {
-        var index = @as(u32, @intCast(wasm.symbols.items.len));
+        const index: u32 = @intCast(wasm.symbols.items.len);
         try wasm.symbols.ensureUnusedCapacity(wasm.base.allocator, 1);
         wasm.symbols.items.len += 1;
         break :blk index;
@@ -2632,7 +2632,7 @@ fn setupImports(wasm: *Wasm) !void {
 
         // We copy the import to a new import to ensure the names contain references
         // to the internal string table, rather than of the object file.
-        var new_imp: types.Import = .{
+        const new_imp: types.Import = .{
             .module_name = try wasm.string_table.put(wasm.base.allocator, object.string_table.get(import.module_name)),
             .name = try wasm.string_table.put(wasm.base.allocator, object.string_table.get(import.name)),
             .kind = import.kind,
@@ -3800,7 +3800,7 @@ fn writeToFile(
         const table_loc = wasm.findGlobalSymbol("__indirect_function_table").?;
         const table_sym = table_loc.getSymbol(wasm);
 
-        var flags: u32 = if (table_sym.index == 0) 0x0 else 0x02; // passive with implicit 0-index table or set table index manually
+        const flags: u32 = if (table_sym.index == 0) 0x0 else 0x02; // passive with implicit 0-index table or set table index manually
         try leb.writeULEB128(binary_writer, flags);
         if (flags == 0x02) {
             try leb.writeULEB128(binary_writer, table_sym.index);
diff --git a/src/link/Wasm/Object.zig b/src/link/Wasm/Object.zig
index 359ff20d94..4f5dae8c09 100644
--- a/src/link/Wasm/Object.zig
+++ b/src/link/Wasm/Object.zig
@@ -252,7 +252,7 @@ fn checkLegacyIndirectFunctionTable(object: *Object) !?Symbol {
         return error.MissingTableSymbols;
     }
 
-    var table_import: types.Import = for (object.imports) |imp| {
+    const table_import: types.Import = for (object.imports) |imp| {
         if (imp.kind == .table) {
             break imp;
         }
@@ -512,7 +512,7 @@ fn Parser(comptime ReaderType: type) type {
                         try assertEnd(reader);
                     },
                     .code => {
-                        var start = reader.context.bytes_left;
+                        const start = reader.context.bytes_left;
                         var index: u32 = 0;
                         const count = try readLeb(u32, reader);
                         while (index < count) : (index += 1) {
@@ -532,7 +532,7 @@ fn Parser(comptime ReaderType: type) type {
                         }
                     },
                     .data => {
-                        var start = reader.context.bytes_left;
+                        const start = reader.context.bytes_left;
                         var index: u32 = 0;
                         const count = try readLeb(u32, reader);
                         while (index < count) : (index += 1) {
diff --git a/src/link/tapi/yaml.zig b/src/link/tapi/yaml.zig
index 5e3602f620..7afa229401 100644
--- a/src/link/tapi/yaml.zig
+++ b/src/link/tapi/yaml.zig
@@ -491,7 +491,7 @@ pub fn stringify(allocator: Allocator, input: anytype, writer: anytype) !void {
     var arena = ArenaAllocator.init(allocator);
     defer arena.deinit();
 
-    var maybe_value = try Value.encode(arena.allocator(), input);
+    const maybe_value = try Value.encode(arena.allocator(), input);
 
     if (maybe_value) |value| {
         // TODO should we output as an explicit doc?