update std lib and compiler sources to new for loop syntax

10 files changed, 59 insertions, 59 deletions

diff --git a/src/link/MachO/DebugSymbols.zig b/src/link/MachO/DebugSymbols.zig
index 0a5c8b0372..1f41fc1cb8 100644
--- a/src/link/MachO/DebugSymbols.zig
+++ b/src/link/MachO/DebugSymbols.zig
@@ -383,7 +383,7 @@ fn finalizeDwarfSegment(self: *DebugSymbols, macho_file: *MachO) void {
 fn writeSegmentHeaders(self: *DebugSymbols, macho_file: *MachO, writer: anytype) !void {
     // Write segment/section headers from the binary file first.
     const end = macho_file.linkedit_segment_cmd_index.?;
-    for (macho_file.segments.items[0..end]) |seg, i| {
+    for (macho_file.segments.items[0..end], 0..) |seg, i| {
         const indexes = macho_file.getSectionIndexes(@intCast(u8, i));
         var out_seg = seg;
         out_seg.fileoff = 0;
@@ -412,7 +412,7 @@ fn writeSegmentHeaders(self: *DebugSymbols, macho_file: *MachO, writer: anytype)
         }
     }
     // Next, commit DSYM's __LINKEDIT and __DWARF segments headers.
-    for (self.segments.items) |seg, i| {
+    for (self.segments.items, 0..) |seg, i| {
         const indexes = self.getSectionIndexes(@intCast(u8, i));
         try writer.writeStruct(seg);
         for (self.sections.items[indexes.start..indexes.end]) |header| {
@@ -477,7 +477,7 @@ fn writeSymtab(self: *DebugSymbols, macho_file: *MachO) !void {
     var locals = std.ArrayList(macho.nlist_64).init(gpa);
     defer locals.deinit();
 
-    for (macho_file.locals.items) |sym, sym_id| {
+    for (macho_file.locals.items, 0..) |sym, sym_id| {
         if (sym.n_strx == 0) continue; // no name, skip
         const sym_loc = MachO.SymbolWithLoc{ .sym_index = @intCast(u32, sym_id), .file = null };
         if (macho_file.symbolIsTemp(sym_loc)) continue; // local temp symbol, skip
@@ -547,7 +547,7 @@ fn writeStrtab(self: *DebugSymbols) !void {
 
 pub fn getSectionIndexes(self: *DebugSymbols, segment_index: u8) struct { start: u8, end: u8 } {
     var start: u8 = 0;
-    const nsects = for (self.segments.items) |seg, i| {
+    const nsects = for (self.segments.items, 0..) |seg, i| {
         if (i == segment_index) break @intCast(u8, seg.nsects);
         start += @intCast(u8, seg.nsects);
     } else 0;
diff --git a/src/link/MachO/Dylib.zig b/src/link/MachO/Dylib.zig
index a2c4bad942..863f1e805a 100644
--- a/src/link/MachO/Dylib.zig
+++ b/src/link/MachO/Dylib.zig
@@ -347,7 +347,7 @@ pub fn parseFromStub(
     });
     defer matcher.deinit();
 
-    for (lib_stub.inner) |elem, stub_index| {
+    for (lib_stub.inner, 0..) |elem, stub_index| {
         const is_match = switch (elem) {
             .v3 => |stub| matcher.matchesArch(stub.archs),
             .v4 => |stub| matcher.matchesTarget(stub.targets),
diff --git a/src/link/MachO/Object.zig b/src/link/MachO/Object.zig
index 4d24b2ed6a..fdcdb47224 100644
--- a/src/link/MachO/Object.zig
+++ b/src/link/MachO/Object.zig
@@ -201,7 +201,7 @@ pub fn parse(self: *Object, allocator: Allocator, cpu_arch: std.Target.Cpu.Arch)
     var sorted_all_syms = try std.ArrayList(SymbolAtIndex).initCapacity(allocator, self.in_symtab.?.len);
     defer sorted_all_syms.deinit();
 
-    for (self.in_symtab.?) |_, index| {
+    for (self.in_symtab.?, 0..) |_, index| {
         sorted_all_syms.appendAssumeCapacity(.{ .index = @intCast(u32, index) });
     }
 
@@ -211,7 +211,7 @@ pub fn parse(self: *Object, allocator: Allocator, cpu_arch: std.Target.Cpu.Arch)
     // is kind enough to specify the symbols in the correct order.
     sort.sort(SymbolAtIndex, sorted_all_syms.items, self, SymbolAtIndex.lessThan);
 
-    for (sorted_all_syms.items) |sym_id, i| {
+    for (sorted_all_syms.items, 0..) |sym_id, i| {
         const sym = sym_id.getSymbol(self);
 
         if (sym.sect() and self.source_section_index_lookup[sym.n_sect - 1] == -1) {
@@ -380,7 +380,7 @@ pub fn splitRegularSections(self: *Object, zld: *Zld, object_id: u32) !void {
     const gpa = zld.gpa;
 
     const sections = self.getSourceSections();
-    for (sections) |sect, id| {
+    for (sections, 0..) |sect, id| {
         if (sect.isDebug()) continue;
         const out_sect_id = (try zld.getOutputSection(sect)) orelse {
             log.debug("  unhandled section '{s},{s}'", .{ sect.segName(), sect.sectName() });
@@ -400,7 +400,7 @@ pub fn splitRegularSections(self: *Object, zld: *Zld, object_id: u32) !void {
     }
 
     if (self.in_symtab == null) {
-        for (sections) |sect, id| {
+        for (sections, 0..) |sect, id| {
             if (sect.isDebug()) continue;
             const out_sect_id = (try zld.getOutputSection(sect)) orelse continue;
             if (sect.size == 0) continue;
@@ -446,7 +446,7 @@ pub fn splitRegularSections(self: *Object, zld: *Zld, object_id: u32) !void {
     var sorted_sections = try gpa.alloc(SortedSection, sections.len);
     defer gpa.free(sorted_sections);
 
-    for (sections) |sect, id| {
+    for (sections, 0..) |sect, id| {
         sorted_sections[id] = .{ .header = sect, .id = @intCast(u8, id) };
     }
 
@@ -804,7 +804,7 @@ fn parseUnwindInfo(self: *Object, zld: *Zld, object_id: u32) !void {
     try self.parseRelocs(gpa, sect_id);
     const relocs = self.getRelocs(sect_id);
 
-    for (unwind_records) |record, record_id| {
+    for (unwind_records, 0..) |record, record_id| {
         const offset = record_id * @sizeOf(macho.compact_unwind_entry);
         const rel_pos = filterRelocs(
             relocs,
@@ -857,7 +857,7 @@ pub fn getSourceSectionByName(self: Object, segname: []const u8, sectname: []con
 
 pub fn getSourceSectionIndexByName(self: Object, segname: []const u8, sectname: []const u8) ?u8 {
     const sections = self.getSourceSections();
-    for (sections) |sect, i| {
+    for (sections, 0..) |sect, i| {
         if (mem.eql(u8, segname, sect.segName()) and mem.eql(u8, sectname, sect.sectName()))
             return @intCast(u8, i);
     } else return null;
diff --git a/src/link/MachO/UnwindInfo.zig b/src/link/MachO/UnwindInfo.zig
index 5e61834bbc..c64e617a35 100644
--- a/src/link/MachO/UnwindInfo.zig
+++ b/src/link/MachO/UnwindInfo.zig
@@ -126,7 +126,7 @@ const Page = struct {
             ctx.page.start + ctx.page.count,
         });
         try writer.print("  encodings (count = {d})\n", .{ctx.page.page_encodings_count});
-        for (ctx.page.page_encodings[0..ctx.page.page_encodings_count]) |record_id, i| {
+        for (ctx.page.page_encodings[0..ctx.page.page_encodings_count], 0..) |record_id, i| {
             const record = ctx.info.records.items[record_id];
             const enc = record.compactUnwindEncoding;
             try writer.print("    {d}: 0x{x:0>8}\n", .{ ctx.info.common_encodings_count + i, enc });
@@ -205,7 +205,7 @@ pub fn scanRelocs(zld: *Zld) !void {
     if (zld.getSectionByName("__TEXT", "__unwind_info") == null) return;
 
     const cpu_arch = zld.options.target.cpu.arch;
-    for (zld.objects.items) |*object, object_id| {
+    for (zld.objects.items, 0..) |*object, object_id| {
         const unwind_records = object.getUnwindRecords();
         for (object.exec_atoms.items) |atom_index| {
             const record_id = object.unwind_records_lookup.get(atom_index) orelse continue;
@@ -244,7 +244,7 @@ pub fn collect(info: *UnwindInfo, zld: *Zld) !void {
     defer atom_indexes.deinit();
 
     // TODO handle dead stripping
-    for (zld.objects.items) |*object, object_id| {
+    for (zld.objects.items, 0..) |*object, object_id| {
         log.debug("collecting unwind records in {s} ({d})", .{ object.name, object_id });
         const unwind_records = object.getUnwindRecords();
 
@@ -335,7 +335,7 @@ pub fn collect(info: *UnwindInfo, zld: *Zld) !void {
     try info.records_lookup.ensureTotalCapacity(info.gpa, @intCast(u32, atom_indexes.items.len));
 
     var maybe_prev: ?macho.compact_unwind_entry = null;
-    for (records.items) |record, i| {
+    for (records.items, 0..) |record, i| {
         const record_id = blk: {
             if (maybe_prev) |prev| {
                 const is_dwarf = UnwindEncoding.isDwarf(record.compactUnwindEncoding, cpu_arch);
@@ -483,7 +483,7 @@ pub fn collect(info: *UnwindInfo, zld: *Zld) !void {
 
     // Save indices of records requiring LSDA relocation
     try info.lsdas_lookup.ensureTotalCapacity(info.gpa, @intCast(u32, info.records.items.len));
-    for (info.records.items) |rec, i| {
+    for (info.records.items, 0..) |rec, i| {
         info.lsdas_lookup.putAssumeCapacityNoClobber(@intCast(RecordIndex, i), @intCast(u32, info.lsdas.items.len));
         if (rec.lsda == 0) continue;
         try info.lsdas.append(info.gpa, @intCast(RecordIndex, i));
@@ -556,7 +556,7 @@ pub fn write(info: *UnwindInfo, zld: *Zld) !void {
     const cpu_arch = zld.options.target.cpu.arch;
 
     log.debug("Personalities:", .{});
-    for (info.personalities[0..info.personalities_count]) |target, i| {
+    for (info.personalities[0..info.personalities_count], 0..) |target, i| {
         const atom_index = zld.getGotAtomIndexForSymbol(target).?;
         const atom = zld.getAtom(atom_index);
         const sym = zld.getSymbol(atom.getSymbolWithLoc());
@@ -581,7 +581,7 @@ pub fn write(info: *UnwindInfo, zld: *Zld) !void {
         }
     }
 
-    for (info.records.items) |record, i| {
+    for (info.records.items, 0..) |record, i| {
         log.debug("Unwind record at offset 0x{x}", .{i * @sizeOf(macho.compact_unwind_entry)});
         log.debug("  start: 0x{x}", .{record.rangeStart});
         log.debug("  length: 0x{x}", .{record.rangeLength});
@@ -621,7 +621,7 @@ pub fn write(info: *UnwindInfo, zld: *Zld) !void {
     const pages_base_offset = @intCast(u32, size - (info.pages.items.len * second_level_page_bytes));
     const lsda_base_offset = @intCast(u32, pages_base_offset -
         (info.lsdas.items.len * @sizeOf(macho.unwind_info_section_header_lsda_index_entry)));
-    for (info.pages.items) |page, i| {
+    for (info.pages.items, 0..) |page, i| {
         assert(page.count > 0);
         const first_entry = info.records.items[page.start];
         try writer.writeStruct(macho.unwind_info_section_header_index_entry{
diff --git a/src/link/MachO/dead_strip.zig b/src/link/MachO/dead_strip.zig
index 6ba70acbfd..9dfd6226b4 100644
--- a/src/link/MachO/dead_strip.zig
+++ b/src/link/MachO/dead_strip.zig
@@ -238,7 +238,7 @@ fn mark(zld: *Zld, roots: AtomTable, alive: *AtomTable) !void {
         }
     }
 
-    for (zld.objects.items) |_, object_id| {
+    for (zld.objects.items, 0..) |_, object_id| {
         // Traverse unwind and eh_frame records noting if the source symbol has been marked, and if so,
         // marking all references as live.
         try markUnwindRecords(zld, @intCast(u32, object_id), alive);
diff --git a/src/link/MachO/dyld_info/Rebase.zig b/src/link/MachO/dyld_info/Rebase.zig
index 0233744c43..1d7a0c94c0 100644
--- a/src/link/MachO/dyld_info/Rebase.zig
+++ b/src/link/MachO/dyld_info/Rebase.zig
@@ -45,7 +45,7 @@ pub fn finalize(rebase: *Rebase, gpa: Allocator) !void {
 
     var start: usize = 0;
     var seg_id: ?u8 = null;
-    for (rebase.entries.items) |entry, i| {
+    for (rebase.entries.items, 0..) |entry, i| {
         if (seg_id != null and seg_id.? == entry.segment_id) continue;
         try finalizeSegment(rebase.entries.items[start..i], writer);
         seg_id = entry.segment_id;
diff --git a/src/link/MachO/dyld_info/bind.zig b/src/link/MachO/dyld_info/bind.zig
index b4e51478e0..98a693920a 100644
--- a/src/link/MachO/dyld_info/bind.zig
+++ b/src/link/MachO/dyld_info/bind.zig
@@ -51,7 +51,7 @@ pub fn Bind(comptime Ctx: type, comptime Target: type) type {
 
             var start: usize = 0;
             var seg_id: ?u8 = null;
-            for (self.entries.items) |entry, i| {
+            for (self.entries.items, 0..) |entry, i| {
                 if (seg_id != null and seg_id.? == entry.segment_id) continue;
                 try finalizeSegment(self.entries.items[start..i], ctx, writer);
                 seg_id = entry.segment_id;
diff --git a/src/link/MachO/eh_frame.zig b/src/link/MachO/eh_frame.zig
index 3867b15a96..5420bf6c29 100644
--- a/src/link/MachO/eh_frame.zig
+++ b/src/link/MachO/eh_frame.zig
@@ -16,7 +16,7 @@ const Zld = @import("zld.zig").Zld;
 pub fn scanRelocs(zld: *Zld) !void {
     const gpa = zld.gpa;
 
-    for (zld.objects.items) |*object, object_id| {
+    for (zld.objects.items, 0..) |*object, object_id| {
         var cies = std.AutoHashMap(u32, void).init(gpa);
         defer cies.deinit();
 
@@ -108,7 +108,7 @@ pub fn write(zld: *Zld, unwind_info: *UnwindInfo) !void {
 
     var eh_frame_offset: u32 = 0;
 
-    for (zld.objects.items) |*object, object_id| {
+    for (zld.objects.items, 0..) |*object, object_id| {
         try eh_records.ensureUnusedCapacity(2 * @intCast(u32, object.exec_atoms.items.len));
 
         var cies = std.AutoHashMap(u32, u32).init(gpa);
@@ -407,7 +407,7 @@ pub fn EhFrameRecord(comptime is_mutable: bool) type {
             var creader = std.io.countingReader(stream.reader());
             const reader = creader.reader();
 
-            for (aug_str) |ch, i| switch (ch) {
+            for (aug_str, 0..) |ch, i| switch (ch) {
                 'z' => if (i > 0) {
                     return error.BadDwarfCfi;
                 } else {
@@ -467,7 +467,7 @@ pub fn EhFrameRecord(comptime is_mutable: bool) type {
             var creader = std.io.countingReader(stream.reader());
             const reader = creader.reader();
 
-            for (aug_str) |ch, i| switch (ch) {
+            for (aug_str, 0..) |ch, i| switch (ch) {
                 'z' => if (i > 0) {
                     return error.BadDwarfCfi;
                 } else {
diff --git a/src/link/MachO/thunks.zig b/src/link/MachO/thunks.zig
index f12fb80668..ce3fda0b1f 100644
--- a/src/link/MachO/thunks.zig
+++ b/src/link/MachO/thunks.zig
@@ -329,7 +329,7 @@ fn createThunkAtom(zld: *Zld) !AtomIndex {
 fn getThunkIndex(zld: *Zld, atom_index: AtomIndex) ?ThunkIndex {
     const atom = zld.getAtom(atom_index);
     const sym = zld.getSymbol(atom.getSymbolWithLoc());
-    for (zld.thunks.items) |thunk, i| {
+    for (zld.thunks.items, 0..) |thunk, i| {
         if (thunk.len == 0) continue;
 
         const thunk_atom_index = thunk.getStartAtomIndex();
diff --git a/src/link/MachO/zld.zig b/src/link/MachO/zld.zig
index a94a0828fc..a901e4fd4b 100644
--- a/src/link/MachO/zld.zig
+++ b/src/link/MachO/zld.zig
@@ -321,7 +321,7 @@ pub const Zld = struct {
         syslibroot: ?[]const u8,
         dependent_libs: anytype,
     ) !void {
-        for (lib_names) |lib, i| {
+        for (lib_names, 0..) |lib, i| {
             const lib_info = lib_infos[i];
             log.debug("parsing lib path '{s}'", .{lib});
             if (try self.parseDylib(lib, dependent_libs, .{
@@ -1092,7 +1092,7 @@ pub const Zld = struct {
             const sym = self.getSymbolPtr(global);
             const sym_name = self.getSymbolName(global);
 
-            for (self.dylibs.items) |dylib, id| {
+            for (self.dylibs.items, 0..) |dylib, id| {
                 if (!dylib.symbols.contains(sym_name)) continue;
 
                 const dylib_id = @intCast(u16, id);
@@ -1223,7 +1223,7 @@ pub const Zld = struct {
         const global = SymbolWithLoc{ .sym_index = sym_index };
         try self.globals.append(gpa, global);
 
-        for (self.dylibs.items) |dylib, id| {
+        for (self.dylibs.items, 0..) |dylib, id| {
             if (!dylib.symbols.contains(sym_name)) continue;
 
             const dylib_id = @intCast(u16, id);
@@ -1311,7 +1311,7 @@ pub const Zld = struct {
             });
         }
 
-        for (self.sections.items(.header)) |header, sect_id| {
+        for (self.sections.items(.header), 0..) |header, sect_id| {
             if (header.size == 0) continue; // empty section
 
             const segname = header.segName();
@@ -1385,7 +1385,7 @@ pub const Zld = struct {
         const gpa = self.gpa;
         const slice = self.sections.slice();
 
-        for (slice.items(.first_atom_index)) |first_atom_index, sect_id| {
+        for (slice.items(.first_atom_index), 0..) |first_atom_index, sect_id| {
             const header = slice.items(.header)[sect_id];
             var atom_index = first_atom_index;
 
@@ -1525,7 +1525,7 @@ pub const Zld = struct {
 
     fn calcSectionSizes(self: *Zld) !void {
         const slice = self.sections.slice();
-        for (slice.items(.header)) |*header, sect_id| {
+        for (slice.items(.header), 0..) |*header, sect_id| {
             if (header.size == 0) continue;
             if (self.requiresThunks()) {
                 if (header.isCode() and !(header.type() == macho.S_SYMBOL_STUBS) and !mem.eql(u8, header.sectName(), "__stub_helper")) continue;
@@ -1556,7 +1556,7 @@ pub const Zld = struct {
         }
 
         if (self.requiresThunks()) {
-            for (slice.items(.header)) |header, sect_id| {
+            for (slice.items(.header), 0..) |header, sect_id| {
                 if (!header.isCode()) continue;
                 if (header.type() == macho.S_SYMBOL_STUBS) continue;
                 if (mem.eql(u8, header.sectName(), "__stub_helper")) continue;
@@ -1568,7 +1568,7 @@ pub const Zld = struct {
     }
 
     fn allocateSegments(self: *Zld) !void {
-        for (self.segments.items) |*segment, segment_index| {
+        for (self.segments.items, 0..) |*segment, segment_index| {
             const is_text_segment = mem.eql(u8, segment.segName(), "__TEXT");
             const base_size = if (is_text_segment) try load_commands.calcMinHeaderPad(self.gpa, self.options, .{
                 .segments = self.segments.items,
@@ -1606,7 +1606,7 @@ pub const Zld = struct {
         var start = init_size;
 
         const slice = self.sections.slice();
-        for (slice.items(.header)[indexes.start..indexes.end]) |*header, sect_id| {
+        for (slice.items(.header)[indexes.start..indexes.end], 0..) |*header, sect_id| {
             const alignment = try math.powi(u32, 2, header.@"align");
             const start_aligned = mem.alignForwardGeneric(u64, start, alignment);
             const n_sect = @intCast(u8, indexes.start + sect_id + 1);
@@ -1750,7 +1750,7 @@ pub const Zld = struct {
     }
 
     fn writeSegmentHeaders(self: *Zld, writer: anytype) !void {
-        for (self.segments.items) |seg, i| {
+        for (self.segments.items, 0..) |seg, i| {
             const indexes = self.getSectionIndexes(@intCast(u8, i));
             var out_seg = seg;
             out_seg.cmdsize = @sizeOf(macho.segment_command_64);
@@ -1852,7 +1852,7 @@ pub const Zld = struct {
         }
 
         // Finally, unpack the rest.
-        for (slice.items(.header)) |header, sect_id| {
+        for (slice.items(.header), 0..) |header, sect_id| {
             switch (header.type()) {
                 macho.S_LITERAL_POINTERS,
                 macho.S_REGULAR,
@@ -1989,7 +1989,7 @@ pub const Zld = struct {
 
         // Finally, unpack the rest.
         const slice = self.sections.slice();
-        for (slice.items(.header)) |header, sect_id| {
+        for (slice.items(.header), 0..) |header, sect_id| {
             switch (header.type()) {
                 macho.S_LITERAL_POINTERS,
                 macho.S_REGULAR,
@@ -2710,7 +2710,7 @@ pub const Zld = struct {
                     const amt = try self.file.preadAll(locals_buf, self.symtab_cmd.symoff);
                     if (amt != locals_buf.len) return error.InputOutput;
 
-                    const istab: usize = for (locals) |local, i| {
+                    const istab: usize = for (locals, 0..) |local, i| {
                         if (local.stab()) break i;
                     } else locals.len;
                     const nstabs = locals.len - istab;
@@ -2897,7 +2897,7 @@ pub const Zld = struct {
     }
 
     fn getSegmentByName(self: Zld, segname: []const u8) ?u8 {
-        for (self.segments.items) |seg, i| {
+        for (self.segments.items, 0..) |seg, i| {
             if (mem.eql(u8, segname, seg.segName())) return @intCast(u8, i);
         } else return null;
     }
@@ -2921,7 +2921,7 @@ pub const Zld = struct {
 
     pub fn getSectionByName(self: Zld, segname: []const u8, sectname: []const u8) ?u8 {
         // TODO investigate caching with a hashmap
-        for (self.sections.items(.header)) |header, i| {
+        for (self.sections.items(.header), 0..) |header, i| {
             if (mem.eql(u8, header.segName(), segname) and mem.eql(u8, header.sectName(), sectname))
                 return @intCast(u8, i);
         } else return null;
@@ -2929,7 +2929,7 @@ pub const Zld = struct {
 
     pub fn getSectionIndexes(self: Zld, segment_index: u8) struct { start: u8, end: u8 } {
         var start: u8 = 0;
-        const nsects = for (self.segments.items) |seg, i| {
+        const nsects = for (self.segments.items, 0..) |seg, i| {
             if (i == segment_index) break @intCast(u8, seg.nsects);
             start += @intCast(u8, seg.nsects);
         } else 0;
@@ -3220,7 +3220,7 @@ pub const Zld = struct {
 
     fn logSegments(self: *Zld) void {
         log.debug("segments:", .{});
-        for (self.segments.items) |segment, i| {
+        for (self.segments.items, 0..) |segment, i| {
             log.debug("  segment({d}): {s} @{x} ({x}), sizeof({x})", .{
                 i,
                 segment.segName(),
@@ -3233,7 +3233,7 @@ pub const Zld = struct {
 
     fn logSections(self: *Zld) void {
         log.debug("sections:", .{});
-        for (self.sections.items(.header)) |header, i| {
+        for (self.sections.items(.header), 0..) |header, i| {
             log.debug("  sect({d}): {s},{s} @{x} ({x}), sizeof({x})", .{
                 i + 1,
                 header.segName(),
@@ -3271,10 +3271,10 @@ pub const Zld = struct {
         const scoped_log = std.log.scoped(.symtab);
 
         scoped_log.debug("locals:", .{});
-        for (self.objects.items) |object, id| {
+        for (self.objects.items, 0..) |object, id| {
             scoped_log.debug("  object({d}): {s}", .{ id, object.name });
             if (object.in_symtab == null) continue;
-            for (object.symtab) |sym, sym_id| {
+            for (object.symtab, 0..) |sym, sym_id| {
                 mem.set(u8, &buf, '_');
                 scoped_log.debug("    %{d}: {s} @{x} in sect({d}), {s}", .{
                     sym_id,
@@ -3286,7 +3286,7 @@ pub const Zld = struct {
             }
         }
         scoped_log.debug("  object(-1)", .{});
-        for (self.locals.items) |sym, sym_id| {
+        for (self.locals.items, 0..) |sym, sym_id| {
             if (sym.undf()) continue;
             scoped_log.debug("    %{d}: {s} @{x} in sect({d}), {s}", .{
                 sym_id,
@@ -3298,7 +3298,7 @@ pub const Zld = struct {
         }
 
         scoped_log.debug("exports:", .{});
-        for (self.globals.items) |global, i| {
+        for (self.globals.items, 0..) |global, i| {
             const sym = self.getSymbol(global);
             if (sym.undf()) continue;
             if (sym.n_desc == N_DEAD) continue;
@@ -3313,7 +3313,7 @@ pub const Zld = struct {
         }
 
         scoped_log.debug("imports:", .{});
-        for (self.globals.items) |global, i| {
+        for (self.globals.items, 0..) |global, i| {
             const sym = self.getSymbol(global);
             if (!sym.undf()) continue;
             if (sym.n_desc == N_DEAD) continue;
@@ -3328,7 +3328,7 @@ pub const Zld = struct {
         }
 
         scoped_log.debug("GOT entries:", .{});
-        for (self.got_entries.items) |entry, i| {
+        for (self.got_entries.items, 0..) |entry, i| {
             const atom_sym = entry.getAtomSymbol(self);
             const target_sym = entry.getTargetSymbol(self);
             const target_sym_name = entry.getTargetSymbolName(self);
@@ -3350,7 +3350,7 @@ pub const Zld = struct {
         }
 
         scoped_log.debug("__thread_ptrs entries:", .{});
-        for (self.tlv_ptr_entries.items) |entry, i| {
+        for (self.tlv_ptr_entries.items, 0..) |entry, i| {
             const atom_sym = entry.getAtomSymbol(self);
             const target_sym = entry.getTargetSymbol(self);
             const target_sym_name = entry.getTargetSymbolName(self);
@@ -3363,7 +3363,7 @@ pub const Zld = struct {
         }
 
         scoped_log.debug("stubs entries:", .{});
-        for (self.stubs.items) |entry, i| {
+        for (self.stubs.items, 0..) |entry, i| {
             const atom_sym = entry.getAtomSymbol(self);
             const target_sym = entry.getTargetSymbol(self);
             const target_sym_name = entry.getTargetSymbolName(self);
@@ -3376,9 +3376,9 @@ pub const Zld = struct {
         }
 
         scoped_log.debug("thunks:", .{});
-        for (self.thunks.items) |thunk, i| {
+        for (self.thunks.items, 0..) |thunk, i| {
             scoped_log.debug("  thunk({d})", .{i});
-            for (thunk.lookup.keys()) |target, j| {
+            for (thunk.lookup.keys(), 0..) |target, j| {
                 const target_sym = self.getSymbol(target);
                 const atom = self.getAtom(thunk.lookup.get(target).?);
                 const atom_sym = self.getSymbol(atom.getSymbolWithLoc());
@@ -3395,7 +3395,7 @@ pub const Zld = struct {
     fn logAtoms(self: *Zld) void {
         log.debug("atoms:", .{});
         const slice = self.sections.slice();
-        for (slice.items(.first_atom_index)) |first_atom_index, sect_id| {
+        for (slice.items(.first_atom_index), 0..) |first_atom_index, sect_id| {
             var atom_index = first_atom_index;
             if (atom_index == 0) continue;
 
@@ -3980,7 +3980,7 @@ pub fn linkWithZld(macho_file: *MachO, comp: *Compilation, prog_node: *std.Progr
             .unresolved = std.AutoArrayHashMap(u32, void).init(arena),
         };
 
-        for (zld.objects.items) |_, object_id| {
+        for (zld.objects.items, 0..) |_, object_id| {
             try zld.resolveSymbolsInObject(@intCast(u32, object_id), &resolver);
         }
 
@@ -4010,7 +4010,7 @@ pub fn linkWithZld(macho_file: *MachO, comp: *Compilation, prog_node: *std.Progr
             zld.entry_index = global_index;
         }
 
-        for (zld.objects.items) |*object, object_id| {
+        for (zld.objects.items, 0..) |*object, object_id| {
             try object.splitIntoAtoms(&zld, @intCast(u32, object_id));
         }