diff --git a/lib/std/zig/string_literal.zig b/lib/std/zig/string_literal.zig
index 89653de312b6d56678662cff0ff6201be3c633a2..2c9d201d97a30b19503306cb0ab0f0eb74951256 100644
--- a/lib/std/zig/string_literal.zig
+++ b/lib/std/zig/string_literal.zig
@@ -44,7 +44,7 @@ pub const Error = union(enum) {
         raw_string: []const u8,
     };
 
-    fn formatMessage(self: FormatMessage, bw: *std.io.BufferedWriter, comptime f: []const u8) anyerror!void {
+    fn formatMessage(self: FormatMessage, bw: *std.io.BufferedWriter, comptime f: []const u8) !void {
         _ = f;
         switch (self.err) {
             .invalid_escape_character => |bad_index| try bw.print(
@@ -318,7 +318,7 @@ test parseCharLiteral {
 
 /// Parses `bytes` as a Zig string literal and writes the result to the `std.io.Writer` type.
 /// Asserts `bytes` has '"' at beginning and end.
-pub fn parseWrite(writer: *std.io.BufferedWriter, bytes: []const u8) anyerror!Result {
+pub fn parseWrite(writer: *std.io.BufferedWriter, bytes: []const u8) std.io.Writer.Error!Result {
     assert(bytes.len >= 2 and bytes[0] == '"' and bytes[bytes.len - 1] == '"');
 
     var index: usize = 1;
diff --git a/lib/std/zon/stringify.zig b/lib/std/zon/stringify.zig
index 07bfe93ae151308f73c55230b3d6e84ada15f8c8..c99cec2175e983f4939fe3b5039feaa9aaade12a 100644
--- a/lib/std/zon/stringify.zig
+++ b/lib/std/zon/stringify.zig
@@ -40,7 +40,7 @@ pub const SerializeOptions = struct {
 /// Serialize the given value as ZON.
 ///
 /// It is asserted at comptime that `@TypeOf(val)` is not a recursive type.
-pub fn serialize(val: anytype, options: SerializeOptions, writer: *std.io.BufferedWriter) anyerror!void {
+pub fn serialize(val: anytype, options: SerializeOptions, writer: *std.io.BufferedWriter) std.io.Writer.Error!void {
     var s: Serializer = .{
         .writer = writer,
         .options = .{ .whitespace = options.whitespace },
@@ -61,7 +61,7 @@ pub fn serializeMaxDepth(
     options: SerializeOptions,
     writer: *std.io.BufferedWriter,
     depth: usize,
-) anyerror!void {
+) std.io.Writer.Error!void {
     var s: Serializer = .{
         .writer = writer,
         .options = .{ .whitespace = options.whitespace },
@@ -80,7 +80,7 @@ pub fn serializeArbitraryDepth(
     val: anytype,
     options: SerializeOptions,
     writer: *std.io.BufferedWriter,
-) anyerror!void {
+) std.io.Writer.Error!void {
     var s: Serializer = .{
         .writer = writer,
         .options = .{ .whitespace = options.whitespace },
@@ -438,26 +438,28 @@ pub const Serializer = struct {
     indent_level: u8 = 0,
     writer: *std.io.BufferedWriter,
 
+    pub const Error = std.io.Writer.Error;
+
     pub const Options = struct {
         /// If false, only syntactically necessary whitespace is emitted.
         whitespace: bool = true,
     };
 
     /// Serialize a value, similar to `serialize`.
-    pub fn value(self: *Serializer, val: anytype, options: ValueOptions) anyerror!void {
+    pub fn value(self: *Serializer, val: anytype, options: ValueOptions) Error!void {
         comptime assert(!typeIsRecursive(@TypeOf(val)));
         return self.valueArbitraryDepth(val, options);
     }
 
     /// Serialize a value, similar to `serializeMaxDepth`.
     /// Can return `error.ExceededMaxDepth`.
-    pub fn valueMaxDepth(self: *Serializer, val: anytype, options: ValueOptions, depth: usize) anyerror!void {
+    pub fn valueMaxDepth(self: *Serializer, val: anytype, options: ValueOptions, depth: usize) Error!void {
         try checkValueDepth(val, depth);
         return self.valueArbitraryDepth(val, options);
     }
 
     /// Serialize a value, similar to `serializeArbitraryDepth`.
-    pub fn valueArbitraryDepth(self: *Serializer, val: anytype, options: ValueOptions) anyerror!void {
+    pub fn valueArbitraryDepth(self: *Serializer, val: anytype, options: ValueOptions) Error!void {
         comptime assert(canSerializeType(@TypeOf(val)));
         switch (@typeInfo(@TypeOf(val))) {
             .int, .comptime_int => if (options.emit_codepoint_literals.emitAsCodepoint(val)) |c| {
@@ -582,12 +584,12 @@ pub const Serializer = struct {
     }
 
     /// Serialize an integer.
-    pub fn int(self: *Serializer, val: anytype) anyerror!void {
+    pub fn int(self: *Serializer, val: anytype) Error!void {
         try self.writer.printIntOptions(val, 10, .lower, .{});
     }
 
     /// Serialize a float.
-    pub fn float(self: *Serializer, val: anytype) anyerror!void {
+    pub fn float(self: *Serializer, val: anytype) Error!void {
         switch (@typeInfo(@TypeOf(val))) {
             .float => if (std.math.isNan(val)) {
                 return self.writer.writeAll("nan");
@@ -612,7 +614,7 @@ pub const Serializer = struct {
     /// Serialize `name` as an identifier prefixed with `.`.
     ///
     /// Escapes the identifier if necessary.
-    pub fn ident(self: *Serializer, name: []const u8) anyerror!void {
+    pub fn ident(self: *Serializer, name: []const u8) Error!void {
         try self.writer.print(".{fp_}", .{std.zig.fmtId(name)});
     }
 
@@ -622,7 +624,7 @@ pub const Serializer = struct {
     pub fn codePoint(
         self: *Serializer,
         val: u21,
-    ) anyerror!void {
+    ) Error!void {
         var buf: [8]u8 = undefined;
         const len = std.unicode.utf8Encode(val, &buf) catch return error.InvalidCodepoint;
         const str = buf[0..len];
@@ -632,7 +634,7 @@ pub const Serializer = struct {
     /// Like `value`, but always serializes `val` as a tuple.
     ///
     /// Will fail at comptime if `val` is not a tuple, array, pointer to an array, or slice.
-    pub fn tuple(self: *Serializer, val: anytype, options: ValueOptions) anyerror!void {
+    pub fn tuple(self: *Serializer, val: anytype, options: ValueOptions) Error!void {
         comptime assert(!typeIsRecursive(@TypeOf(val)));
         try self.tupleArbitraryDepth(val, options);
     }
@@ -645,7 +647,7 @@ pub const Serializer = struct {
         val: anytype,
         options: ValueOptions,
         depth: usize,
-    ) anyerror!void {
+    ) Error!void {
         try checkValueDepth(val, depth);
         try self.tupleArbitraryDepth(val, options);
     }
@@ -657,11 +659,11 @@ pub const Serializer = struct {
         self: *Serializer,
         val: anytype,
         options: ValueOptions,
-    ) anyerror!void {
+    ) Error!void {
         try self.tupleImpl(val, options);
     }
 
-    fn tupleImpl(self: *Serializer, val: anytype, options: ValueOptions) anyerror!void {
+    fn tupleImpl(self: *Serializer, val: anytype, options: ValueOptions) Error!void {
         comptime assert(canSerializeType(@TypeOf(val)));
         switch (@typeInfo(@TypeOf(val))) {
             .@"struct" => {
@@ -683,7 +685,7 @@ pub const Serializer = struct {
     }
 
     /// Like `value`, but always serializes `val` as a string.
-    pub fn string(self: *Serializer, val: []const u8) anyerror!void {
+    pub fn string(self: *Serializer, val: []const u8) Error!void {
         try std.fmt.format(self.writer, "\"{f}\"", .{std.zig.fmtEscapes(val)});
     }
 
@@ -703,7 +705,7 @@ pub const Serializer = struct {
         self: *Serializer,
         val: []const u8,
         options: MultilineStringOptions,
-    ) anyerror!void {
+    ) Error!void {
         // Make sure the string does not contain any carriage returns not followed by a newline
         var i: usize = 0;
         while (i < val.len) : (i += 1) {
@@ -744,7 +746,7 @@ pub const Serializer = struct {
     pub fn beginStruct(
         self: *Serializer,
         options: SerializeContainerOptions,
-    ) anyerror!Struct {
+    ) Error!Struct {
         return Struct.begin(self, options);
     }
 
@@ -752,23 +754,23 @@ pub const Serializer = struct {
     pub fn beginTuple(
         self: *Serializer,
         options: SerializeContainerOptions,
-    ) anyerror!Tuple {
+    ) Error!Tuple {
         return Tuple.begin(self, options);
     }
 
-    fn indent(self: *Serializer) anyerror!void {
+    fn indent(self: *Serializer) Error!void {
         if (self.options.whitespace) {
             try self.writer.splatByteAll(' ', 4 * self.indent_level);
         }
     }
 
-    fn newline(self: *Serializer) anyerror!void {
+    fn newline(self: *Serializer) Error!void {
         if (self.options.whitespace) {
             try self.writer.writeByte('\n');
         }
     }
 
-    fn newlineOrSpace(self: *Serializer, len: usize) anyerror!void {
+    fn newlineOrSpace(self: *Serializer, len: usize) Error!void {
         if (self.containerShouldWrap(len)) {
             try self.newline();
         } else {
@@ -776,7 +778,7 @@ pub const Serializer = struct {
         }
     }
 
-    fn space(self: *Serializer) anyerror!void {
+    fn space(self: *Serializer) Error!void {
         if (self.options.whitespace) {
             try self.writer.writeByte(' ');
         }
@@ -786,7 +788,7 @@ pub const Serializer = struct {
     pub const Tuple = struct {
         container: Container,
 
-        fn begin(parent: *Serializer, options: SerializeContainerOptions) anyerror!Tuple {
+        fn begin(parent: *Serializer, options: SerializeContainerOptions) Error!Tuple {
             return .{
                 .container = try Container.begin(parent, .anon, options),
             };
@@ -795,7 +797,7 @@ pub const Serializer = struct {
         /// Finishes serializing the tuple.
         ///
         /// Prints a trailing comma as configured when appropriate, and the closing bracket.
-        pub fn end(self: *Tuple) anyerror!void {
+        pub fn end(self: *Tuple) Error!void {
             try self.container.end();
             self.* = undefined;
         }
@@ -805,7 +807,7 @@ pub const Serializer = struct {
             self: *Tuple,
             val: anytype,
             options: ValueOptions,
-        ) anyerror!void {
+        ) Error!void {
             try self.container.field(null, val, options);
         }
 
@@ -816,7 +818,7 @@ pub const Serializer = struct {
             val: anytype,
             options: ValueOptions,
             depth: usize,
-        ) anyerror!void {
+        ) Error!void {
             try self.container.fieldMaxDepth(null, val, options, depth);
         }
 
@@ -826,7 +828,7 @@ pub const Serializer = struct {
             self: *Tuple,
             val: anytype,
             options: ValueOptions,
-        ) anyerror!void {
+        ) Error!void {
             try self.container.fieldArbitraryDepth(null, val, options);
         }
 
@@ -834,7 +836,7 @@ pub const Serializer = struct {
         pub fn beginStructField(
             self: *Tuple,
             options: SerializeContainerOptions,
-        ) anyerror!Struct {
+        ) Error!Struct {
             try self.fieldPrefix();
             return self.container.serializer.beginStruct(options);
         }
@@ -843,14 +845,14 @@ pub const Serializer = struct {
         pub fn beginTupleField(
             self: *Tuple,
             options: SerializeContainerOptions,
-        ) anyerror!Tuple {
+        ) Error!Tuple {
             try self.fieldPrefix();
             return self.container.serializer.beginTuple(options);
         }
 
         /// Print a field prefix. This prints any necessary commas, and whitespace as
         /// configured. Useful if you want to serialize the field value yourself.
-        pub fn fieldPrefix(self: *Tuple) anyerror!void {
+        pub fn fieldPrefix(self: *Tuple) Error!void {
             try self.container.fieldPrefix(null);
         }
     };
@@ -859,7 +861,7 @@ pub const Serializer = struct {
     pub const Struct = struct {
         container: Container,
 
-        fn begin(parent: *Serializer, options: SerializeContainerOptions) anyerror!Struct {
+        fn begin(parent: *Serializer, options: SerializeContainerOptions) Error!Struct {
             return .{
                 .container = try Container.begin(parent, .named, options),
             };
@@ -868,7 +870,7 @@ pub const Serializer = struct {
         /// Finishes serializing the struct.
         ///
         /// Prints a trailing comma as configured when appropriate, and the closing bracket.
-        pub fn end(self: *Struct) anyerror!void {
+        pub fn end(self: *Struct) Error!void {
             try self.container.end();
             self.* = undefined;
         }
@@ -879,7 +881,7 @@ pub const Serializer = struct {
             name: []const u8,
             val: anytype,
             options: ValueOptions,
-        ) anyerror!void {
+        ) Error!void {
             try self.container.field(name, val, options);
         }
 
@@ -891,7 +893,7 @@ pub const Serializer = struct {
             val: anytype,
             options: ValueOptions,
             depth: usize,
-        ) anyerror!void {
+        ) Error!void {
             try self.container.fieldMaxDepth(name, val, options, depth);
         }
 
@@ -902,7 +904,7 @@ pub const Serializer = struct {
             name: []const u8,
             val: anytype,
             options: ValueOptions,
-        ) anyerror!void {
+        ) Error!void {
             try self.container.fieldArbitraryDepth(name, val, options);
         }
 
@@ -911,7 +913,7 @@ pub const Serializer = struct {
             self: *Struct,
             name: []const u8,
             options: SerializeContainerOptions,
-        ) anyerror!Struct {
+        ) Error!Struct {
             try self.fieldPrefix(name);
             return self.container.serializer.beginStruct(options);
         }
@@ -921,7 +923,7 @@ pub const Serializer = struct {
             self: *Struct,
             name: []const u8,
             options: SerializeContainerOptions,
-        ) anyerror!Tuple {
+        ) Error!Tuple {
             try self.fieldPrefix(name);
             return self.container.serializer.beginTuple(options);
         }
@@ -929,7 +931,7 @@ pub const Serializer = struct {
         /// Print a field prefix. This prints any necessary commas, the field name (escaped if
         /// necessary) and whitespace as configured. Useful if you want to serialize the field
         /// value yourself.
-        pub fn fieldPrefix(self: *Struct, name: []const u8) anyerror!void {
+        pub fn fieldPrefix(self: *Struct, name: []const u8) Error!void {
             try self.container.fieldPrefix(name);
         }
     };
@@ -946,7 +948,7 @@ pub const Serializer = struct {
             sz: *Serializer,
             field_style: FieldStyle,
             options: SerializeContainerOptions,
-        ) anyerror!Container {
+        ) Error!Container {
             if (options.shouldWrap()) sz.indent_level +|= 1;
             try sz.writer.writeAll(".{");
             return .{
@@ -957,7 +959,7 @@ pub const Serializer = struct {
             };
         }
 
-        fn end(self: *Container) anyerror!void {
+        fn end(self: *Container) Error!void {
             if (self.options.shouldWrap()) self.serializer.indent_level -|= 1;
             if (!self.empty) {
                 if (self.options.shouldWrap()) {
@@ -974,7 +976,7 @@ pub const Serializer = struct {
             self.* = undefined;
         }
 
-        fn fieldPrefix(self: *Container, name: ?[]const u8) anyerror!void {
+        fn fieldPrefix(self: *Container, name: ?[]const u8) Error!void {
             if (!self.empty) {
                 try self.serializer.writer.writeByte(',');
             }
@@ -998,7 +1000,7 @@ pub const Serializer = struct {
             name: ?[]const u8,
             val: anytype,
             options: ValueOptions,
-        ) anyerror!void {
+        ) Error!void {
             comptime assert(!typeIsRecursive(@TypeOf(val)));
             try self.fieldArbitraryDepth(name, val, options);
         }
@@ -1010,7 +1012,7 @@ pub const Serializer = struct {
             val: anytype,
             options: ValueOptions,
             depth: usize,
-        ) anyerror!void {
+        ) Error!void {
             try checkValueDepth(val, depth);
             try self.fieldArbitraryDepth(name, val, options);
         }
@@ -1020,7 +1022,7 @@ pub const Serializer = struct {
             name: ?[]const u8,
             val: anytype,
             options: ValueOptions,
-        ) anyerror!void {
+        ) Error!void {
             try self.fieldPrefix(name);
             try self.serializer.valueArbitraryDepth(val, options);
         }
diff --git a/src/Air.zig b/src/Air.zig
index 6cd8a4a2cbd9b9304a9dd9d00c0d0bc0c65fc719..7d4766125fbc2e5bae222de6736442daee0407e0 100644
--- a/src/Air.zig
+++ b/src/Air.zig
@@ -957,7 +957,7 @@ pub const Inst = struct {
             return index.unwrap().target;
         }
 
-        pub fn format(index: Index, bw: *std.io.BufferedWriter, comptime _: []const u8) anyerror!void {
+        pub fn format(index: Index, bw: *std.io.BufferedWriter, comptime _: []const u8) std.io.Writer.Error!void {
             try bw.writeByte('%');
             switch (index.unwrap()) {
                 .ref => {},
diff --git a/src/Air/Liveness.zig b/src/Air/Liveness.zig
index 5364853a6ac75cb1137caca9dab40fbabb57810d..038254b5d07f94b9465c2771924ba93c28a908e9 100644
--- a/src/Air/Liveness.zig
+++ b/src/Air/Liveness.zig
@@ -2036,7 +2036,7 @@ fn fmtInstSet(set: *const std.AutoHashMapUnmanaged(Air.Inst.Index, void)) FmtIns
 const FmtInstSet = struct {
     set: *const std.AutoHashMapUnmanaged(Air.Inst.Index, void),
 
-    pub fn format(val: FmtInstSet, bw: *std.io.BufferedWriter, comptime _: []const u8) anyerror!void {
+    pub fn format(val: FmtInstSet, bw: *std.io.BufferedWriter, comptime _: []const u8) !void {
         if (val.set.count() == 0) {
             try bw.writeAll("[no instructions]");
             return;
@@ -2056,7 +2056,7 @@ fn fmtInstList(list: []const Air.Inst.Index) FmtInstList {
 const FmtInstList = struct {
     list: []const Air.Inst.Index,
 
-    pub fn format(val: FmtInstList, bw: *std.io.BufferedWriter, comptime _: []const u8) anyerror!void {
+    pub fn format(val: FmtInstList, bw: *std.io.BufferedWriter, comptime _: []const u8) !void {
         if (val.list.len == 0) {
             try bw.writeAll("[no instructions]");
             return;
diff --git a/src/Air/print.zig b/src/Air/print.zig
index 5867494af6540bbd4e06c87676cbd3814ff11ef0..ea70d9a2281ad6733271463fe43774fa9628e377 100644
--- a/src/Air/print.zig
+++ b/src/Air/print.zig
@@ -91,14 +91,16 @@ const Writer = struct {
     indent: usize,
     skip_body: bool,
 
-    fn writeBody(w: *Writer, s: *std.io.BufferedWriter, body: []const Air.Inst.Index) anyerror!void {
+    const Error = std.io.Writer.Error;
+
+    fn writeBody(w: *Writer, s: *std.io.BufferedWriter, body: []const Air.Inst.Index) Error!void {
         for (body) |inst| {
             try w.writeInst(s, inst);
             try s.writeByte('\n');
         }
     }
 
-    fn writeInst(w: *Writer, s: *std.io.BufferedWriter, inst: Air.Inst.Index) anyerror!void {
+    fn writeInst(w: *Writer, s: *std.io.BufferedWriter, inst: Air.Inst.Index) Error!void {
         const tag = w.air.instructions.items(.tag)[@intFromEnum(inst)];
         try s.splatByteAll(' ', w.indent);
         try s.print("{f}{c}= {s}(", .{
@@ -338,19 +340,19 @@ const Writer = struct {
         try s.writeByte(')');
     }
 
-    fn writeBinOp(w: *Writer, s: *std.io.BufferedWriter, inst: Air.Inst.Index) anyerror!void {
+    fn writeBinOp(w: *Writer, s: *std.io.BufferedWriter, inst: Air.Inst.Index) Error!void {
         const bin_op = w.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
         try w.writeOperand(s, inst, 0, bin_op.lhs);
         try s.writeAll(", ");
         try w.writeOperand(s, inst, 1, bin_op.rhs);
     }
 
-    fn writeUnOp(w: *Writer, s: *std.io.BufferedWriter, inst: Air.Inst.Index) anyerror!void {
+    fn writeUnOp(w: *Writer, s: *std.io.BufferedWriter, inst: Air.Inst.Index) Error!void {
         const un_op = w.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
         try w.writeOperand(s, inst, 0, un_op);
     }
 
-    fn writeNoOp(w: *Writer, s: *std.io.BufferedWriter, inst: Air.Inst.Index) anyerror!void {
+    fn writeNoOp(w: *Writer, s: *std.io.BufferedWriter, inst: Air.Inst.Index) Error!void {
         _ = w;
         _ = s;
         _ = inst;
@@ -361,25 +363,25 @@ const Writer = struct {
         return ty.print(s, w.pt);
     }
 
-    fn writeTy(w: *Writer, s: *std.io.BufferedWriter, inst: Air.Inst.Index) anyerror!void {
+    fn writeTy(w: *Writer, s: *std.io.BufferedWriter, inst: Air.Inst.Index) Error!void {
         const ty = w.air.instructions.items(.data)[@intFromEnum(inst)].ty;
         try w.writeType(s, ty);
     }
 
-    fn writeArg(w: *Writer, s: *std.io.BufferedWriter, inst: Air.Inst.Index) anyerror!void {
+    fn writeArg(w: *Writer, s: *std.io.BufferedWriter, inst: Air.Inst.Index) Error!void {
         const arg = w.air.instructions.items(.data)[@intFromEnum(inst)].arg;
         try w.writeType(s, arg.ty.toType());
         try s.print(", {d}", .{arg.zir_param_index});
     }
 
-    fn writeTyOp(w: *Writer, s: *std.io.BufferedWriter, inst: Air.Inst.Index) anyerror!void {
+    fn writeTyOp(w: *Writer, s: *std.io.BufferedWriter, inst: Air.Inst.Index) Error!void {
         const ty_op = w.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
         try w.writeType(s, ty_op.ty.toType());
         try s.writeAll(", ");
         try w.writeOperand(s, inst, 0, ty_op.operand);
     }
 
-    fn writeBlock(w: *Writer, s: *std.io.BufferedWriter, tag: Air.Inst.Tag, inst: Air.Inst.Index) anyerror!void {
+    fn writeBlock(w: *Writer, s: *std.io.BufferedWriter, tag: Air.Inst.Tag, inst: Air.Inst.Index) Error!void {
         const ty_pl = w.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
         try w.writeType(s, ty_pl.ty.toType());
         const body: []const Air.Inst.Index = @ptrCast(switch (tag) {
@@ -420,7 +422,7 @@ const Writer = struct {
         }
     }
 
-    fn writeLoop(w: *Writer, s: *std.io.BufferedWriter, inst: Air.Inst.Index) anyerror!void {
+    fn writeLoop(w: *Writer, s: *std.io.BufferedWriter, inst: Air.Inst.Index) Error!void {
         const ty_pl = w.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
         const extra = w.air.extraData(Air.Block, ty_pl.payload);
         const body: []const Air.Inst.Index = @ptrCast(w.air.extra.items[extra.end..][0..extra.data.body_len]);
@@ -436,7 +438,7 @@ const Writer = struct {
         try s.writeAll("}");
     }
 
-    fn writeAggregateInit(w: *Writer, s: *std.io.BufferedWriter, inst: Air.Inst.Index) anyerror!void {
+    fn writeAggregateInit(w: *Writer, s: *std.io.BufferedWriter, inst: Air.Inst.Index) Error!void {
         const zcu = w.pt.zcu;
         const ty_pl = w.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
         const vector_ty = ty_pl.ty.toType();
@@ -452,7 +454,7 @@ const Writer = struct {
         try s.writeAll("]");
     }
 
-    fn writeUnionInit(w: *Writer, s: *std.io.BufferedWriter, inst: Air.Inst.Index) anyerror!void {
+    fn writeUnionInit(w: *Writer, s: *std.io.BufferedWriter, inst: Air.Inst.Index) Error!void {
         const ty_pl = w.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
         const extra = w.air.extraData(Air.UnionInit, ty_pl.payload).data;
 
@@ -460,7 +462,7 @@ const Writer = struct {
         try w.writeOperand(s, inst, 0, extra.init);
     }
 
-    fn writeStructField(w: *Writer, s: *std.io.BufferedWriter, inst: Air.Inst.Index) anyerror!void {
+    fn writeStructField(w: *Writer, s: *std.io.BufferedWriter, inst: Air.Inst.Index) Error!void {
         const ty_pl = w.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
         const extra = w.air.extraData(Air.StructField, ty_pl.payload).data;
 
@@ -468,7 +470,7 @@ const Writer = struct {
         try s.print(", {d}", .{extra.field_index});
     }
 
-    fn writeTyPlBin(w: *Writer, s: *std.io.BufferedWriter, inst: Air.Inst.Index) anyerror!void {
+    fn writeTyPlBin(w: *Writer, s: *std.io.BufferedWriter, inst: Air.Inst.Index) Error!void {
         const data = w.air.instructions.items(.data);
         const ty_pl = data[@intFromEnum(inst)].ty_pl;
         const extra = w.air.extraData(Air.Bin, ty_pl.payload).data;
@@ -481,7 +483,7 @@ const Writer = struct {
         try w.writeOperand(s, inst, 1, extra.rhs);
     }
 
-    fn writeCmpxchg(w: *Writer, s: *std.io.BufferedWriter, inst: Air.Inst.Index) anyerror!void {
+    fn writeCmpxchg(w: *Writer, s: *std.io.BufferedWriter, inst: Air.Inst.Index) Error!void {
         const ty_pl = w.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
         const extra = w.air.extraData(Air.Cmpxchg, ty_pl.payload).data;
 
@@ -495,7 +497,7 @@ const Writer = struct {
         });
     }
 
-    fn writeMulAdd(w: *Writer, s: *std.io.BufferedWriter, inst: Air.Inst.Index) anyerror!void {
+    fn writeMulAdd(w: *Writer, s: *std.io.BufferedWriter, inst: Air.Inst.Index) Error!void {
         const pl_op = w.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
         const extra = w.air.extraData(Air.Bin, pl_op.payload).data;
 
@@ -506,7 +508,7 @@ const Writer = struct {
         try w.writeOperand(s, inst, 2, pl_op.operand);
     }
 
-    fn writeShuffleOne(w: *Writer, s: anytype, inst: Air.Inst.Index) anyerror!void {
+    fn writeShuffleOne(w: *Writer, s: *std.io.BufferedWriter, inst: Air.Inst.Index) Error!void {
         const unwrapped = w.air.unwrapShuffleOne(w.pt.zcu, inst);
         try w.writeType(s, unwrapped.result_ty);
         try s.writeAll(", ");
@@ -522,7 +524,7 @@ const Writer = struct {
         try s.writeByte(']');
     }
 
-    fn writeShuffleTwo(w: *Writer, s: anytype, inst: Air.Inst.Index) @TypeOf(s).Error!void {
+    fn writeShuffleTwo(w: *Writer, s: anytype, inst: Air.Inst.Index) Error!void {
         const unwrapped = w.air.unwrapShuffleTwo(w.pt.zcu, inst);
         try w.writeType(s, unwrapped.result_ty);
         try s.writeAll(", ");
@@ -541,7 +543,7 @@ const Writer = struct {
         try s.writeByte(']');
     }
 
-    fn writeSelect(w: *Writer, s: *std.io.BufferedWriter, inst: Air.Inst.Index) anyerror!void {
+    fn writeSelect(w: *Writer, s: *std.io.BufferedWriter, inst: Air.Inst.Index) Error!void {
         const zcu = w.pt.zcu;
         const pl_op = w.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
         const extra = w.air.extraData(Air.Bin, pl_op.payload).data;
@@ -556,14 +558,14 @@ const Writer = struct {
         try w.writeOperand(s, inst, 2, extra.rhs);
     }
 
-    fn writeReduce(w: *Writer, s: *std.io.BufferedWriter, inst: Air.Inst.Index) anyerror!void {
+    fn writeReduce(w: *Writer, s: *std.io.BufferedWriter, inst: Air.Inst.Index) Error!void {
         const reduce = w.air.instructions.items(.data)[@intFromEnum(inst)].reduce;
 
         try w.writeOperand(s, inst, 0, reduce.operand);
         try s.print(", {s}", .{@tagName(reduce.operation)});
     }
 
-    fn writeCmpVector(w: *Writer, s: *std.io.BufferedWriter, inst: Air.Inst.Index) anyerror!void {
+    fn writeCmpVector(w: *Writer, s: *std.io.BufferedWriter, inst: Air.Inst.Index) Error!void {
         const ty_pl = w.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
         const extra = w.air.extraData(Air.VectorCmp, ty_pl.payload).data;
 
@@ -573,7 +575,7 @@ const Writer = struct {
         try w.writeOperand(s, inst, 1, extra.rhs);
     }
 
-    fn writeVectorStoreElem(w: *Writer, s: *std.io.BufferedWriter, inst: Air.Inst.Index) anyerror!void {
+    fn writeVectorStoreElem(w: *Writer, s: *std.io.BufferedWriter, inst: Air.Inst.Index) Error!void {
         const data = w.air.instructions.items(.data)[@intFromEnum(inst)].vector_store_elem;
         const extra = w.air.extraData(Air.VectorCmp, data.payload).data;
 
@@ -584,21 +586,21 @@ const Writer = struct {
         try w.writeOperand(s, inst, 2, extra.rhs);
     }
 
-    fn writeRuntimeNavPtr(w: *Writer, s: *std.io.BufferedWriter, inst: Air.Inst.Index) std.io.Writer.Error!void {
+    fn writeRuntimeNavPtr(w: *Writer, s: *std.io.BufferedWriter, inst: Air.Inst.Index) Error!void {
         const ip = &w.pt.zcu.intern_pool;
         const ty_nav = w.air.instructions.items(.data)[@intFromEnum(inst)].ty_nav;
         try w.writeType(s, .fromInterned(ty_nav.ty));
         try s.print(", '{}'", .{ip.getNav(ty_nav.nav).fqn.fmt(ip)});
     }
 
-    fn writeAtomicLoad(w: *Writer, s: *std.io.BufferedWriter, inst: Air.Inst.Index) std.io.Writer.Error!void {
+    fn writeAtomicLoad(w: *Writer, s: *std.io.BufferedWriter, inst: Air.Inst.Index) Error!void {
         const atomic_load = w.air.instructions.items(.data)[@intFromEnum(inst)].atomic_load;
 
         try w.writeOperand(s, inst, 0, atomic_load.ptr);
         try s.print(", {s}", .{@tagName(atomic_load.order)});
     }
 
-    fn writePrefetch(w: *Writer, s: *std.io.BufferedWriter, inst: Air.Inst.Index) anyerror!void {
+    fn writePrefetch(w: *Writer, s: *std.io.BufferedWriter, inst: Air.Inst.Index) Error!void {
         const prefetch = w.air.instructions.items(.data)[@intFromEnum(inst)].prefetch;
 
         try w.writeOperand(s, inst, 0, prefetch.ptr);
@@ -612,7 +614,7 @@ const Writer = struct {
         s: *std.io.BufferedWriter,
         inst: Air.Inst.Index,
         order: std.builtin.AtomicOrder,
-    ) anyerror!void {
+    ) Error!void {
         const bin_op = w.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
         try w.writeOperand(s, inst, 0, bin_op.lhs);
         try s.writeAll(", ");
@@ -620,7 +622,7 @@ const Writer = struct {
         try s.print(", {s}", .{@tagName(order)});
     }
 
-    fn writeAtomicRmw(w: *Writer, s: *std.io.BufferedWriter, inst: Air.Inst.Index) anyerror!void {
+    fn writeAtomicRmw(w: *Writer, s: *std.io.BufferedWriter, inst: Air.Inst.Index) Error!void {
         const pl_op = w.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
         const extra = w.air.extraData(Air.AtomicRmw, pl_op.payload).data;
 
@@ -630,7 +632,7 @@ const Writer = struct {
         try s.print(", {s}, {s}", .{ @tagName(extra.op()), @tagName(extra.ordering()) });
     }
 
-    fn writeFieldParentPtr(w: *Writer, s: *std.io.BufferedWriter, inst: Air.Inst.Index) anyerror!void {
+    fn writeFieldParentPtr(w: *Writer, s: *std.io.BufferedWriter, inst: Air.Inst.Index) Error!void {
         const ty_pl = w.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
         const extra = w.air.extraData(Air.FieldParentPtr, ty_pl.payload).data;
 
@@ -638,7 +640,7 @@ const Writer = struct {
         try s.print(", {d}", .{extra.field_index});
     }
 
-    fn writeAssembly(w: *Writer, s: *std.io.BufferedWriter, inst: Air.Inst.Index) anyerror!void {
+    fn writeAssembly(w: *Writer, s: *std.io.BufferedWriter, inst: Air.Inst.Index) Error!void {
         const ty_pl = w.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
         const extra = w.air.extraData(Air.Asm, ty_pl.payload);
         const is_volatile = @as(u1, @truncate(extra.data.flags >> 31)) != 0;
@@ -711,19 +713,19 @@ const Writer = struct {
         try s.print(", \"{f}\"", .{std.zig.fmtEscapes(asm_source)});
     }
 
-    fn writeDbgStmt(w: *Writer, s: *std.io.BufferedWriter, inst: Air.Inst.Index) anyerror!void {
+    fn writeDbgStmt(w: *Writer, s: *std.io.BufferedWriter, inst: Air.Inst.Index) Error!void {
         const dbg_stmt = w.air.instructions.items(.data)[@intFromEnum(inst)].dbg_stmt;
         try s.print("{d}:{d}", .{ dbg_stmt.line + 1, dbg_stmt.column + 1 });
     }
 
-    fn writeDbgVar(w: *Writer, s: *std.io.BufferedWriter, inst: Air.Inst.Index) anyerror!void {
+    fn writeDbgVar(w: *Writer, s: *std.io.BufferedWriter, inst: Air.Inst.Index) Error!void {
         const pl_op = w.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
         try w.writeOperand(s, inst, 0, pl_op.operand);
         const name: Air.NullTerminatedString = @enumFromInt(pl_op.payload);
         try s.print(", \"{f}\"", .{std.zig.fmtEscapes(name.toSlice(w.air))});
     }
 
-    fn writeCall(w: *Writer, s: *std.io.BufferedWriter, inst: Air.Inst.Index) anyerror!void {
+    fn writeCall(w: *Writer, s: *std.io.BufferedWriter, inst: Air.Inst.Index) Error!void {
         const pl_op = w.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
         const extra = w.air.extraData(Air.Call, pl_op.payload);
         const args = @as([]const Air.Inst.Ref, @ptrCast(w.air.extra.items[extra.end..][0..extra.data.args_len]));
@@ -736,19 +738,19 @@ const Writer = struct {
         try s.writeAll("]");
     }
 
-    fn writeBr(w: *Writer, s: *std.io.BufferedWriter, inst: Air.Inst.Index) anyerror!void {
+    fn writeBr(w: *Writer, s: *std.io.BufferedWriter, inst: Air.Inst.Index) Error!void {
         const br = w.air.instructions.items(.data)[@intFromEnum(inst)].br;
         try w.writeInstIndex(s, br.block_inst, false);
         try s.writeAll(", ");
         try w.writeOperand(s, inst, 0, br.operand);
     }
 
-    fn writeRepeat(w: *Writer, s: *std.io.BufferedWriter, inst: Air.Inst.Index) anyerror!void {
+    fn writeRepeat(w: *Writer, s: *std.io.BufferedWriter, inst: Air.Inst.Index) Error!void {
         const repeat = w.air.instructions.items(.data)[@intFromEnum(inst)].repeat;
         try w.writeInstIndex(s, repeat.loop_inst, false);
     }
 
-    fn writeTry(w: *Writer, s: *std.io.BufferedWriter, inst: Air.Inst.Index) anyerror!void {
+    fn writeTry(w: *Writer, s: *std.io.BufferedWriter, inst: Air.Inst.Index) Error!void {
         const pl_op = w.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
         const extra = w.air.extraData(Air.Try, pl_op.payload);
         const body: []const Air.Inst.Index = @ptrCast(w.air.extra.items[extra.end..][0..extra.data.body_len]);
@@ -782,7 +784,7 @@ const Writer = struct {
         }
     }
 
-    fn writeTryPtr(w: *Writer, s: *std.io.BufferedWriter, inst: Air.Inst.Index) anyerror!void {
+    fn writeTryPtr(w: *Writer, s: *std.io.BufferedWriter, inst: Air.Inst.Index) Error!void {
         const ty_pl = w.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
         const extra = w.air.extraData(Air.TryPtr, ty_pl.payload);
         const body: []const Air.Inst.Index = @ptrCast(w.air.extra.items[extra.end..][0..extra.data.body_len]);
@@ -819,7 +821,7 @@ const Writer = struct {
         }
     }
 
-    fn writeCondBr(w: *Writer, s: *std.io.BufferedWriter, inst: Air.Inst.Index) anyerror!void {
+    fn writeCondBr(w: *Writer, s: *std.io.BufferedWriter, inst: Air.Inst.Index) Error!void {
         const pl_op = w.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
         const extra = w.air.extraData(Air.CondBr, pl_op.payload);
         const then_body: []const Air.Inst.Index = @ptrCast(w.air.extra.items[extra.end..][0..extra.data.then_body_len]);
@@ -878,7 +880,7 @@ const Writer = struct {
         try s.writeAll("}");
     }
 
-    fn writeSwitchBr(w: *Writer, s: *std.io.BufferedWriter, inst: Air.Inst.Index) anyerror!void {
+    fn writeSwitchBr(w: *Writer, s: *std.io.BufferedWriter, inst: Air.Inst.Index) Error!void {
         const switch_br = w.air.unwrapSwitch(inst);
 
         const liveness: Air.Liveness.SwitchBrTable = if (w.liveness) |liveness|
@@ -964,18 +966,18 @@ const Writer = struct {
         try s.splatByteAll(' ', old_indent);
     }
 
-    fn writeWasmMemorySize(w: *Writer, s: *std.io.BufferedWriter, inst: Air.Inst.Index) anyerror!void {
+    fn writeWasmMemorySize(w: *Writer, s: *std.io.BufferedWriter, inst: Air.Inst.Index) Error!void {
         const pl_op = w.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
         try s.print("{d}", .{pl_op.payload});
     }
 
-    fn writeWasmMemoryGrow(w: *Writer, s: *std.io.BufferedWriter, inst: Air.Inst.Index) anyerror!void {
+    fn writeWasmMemoryGrow(w: *Writer, s: *std.io.BufferedWriter, inst: Air.Inst.Index) Error!void {
         const pl_op = w.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
         try s.print("{d}, ", .{pl_op.payload});
         try w.writeOperand(s, inst, 0, pl_op.operand);
     }
 
-    fn writeWorkDimension(w: *Writer, s: *std.io.BufferedWriter, inst: Air.Inst.Index) anyerror!void {
+    fn writeWorkDimension(w: *Writer, s: *std.io.BufferedWriter, inst: Air.Inst.Index) Error!void {
         const pl_op = w.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
         try s.print("{d}", .{pl_op.payload});
     }
@@ -986,7 +988,7 @@ const Writer = struct {
         inst: Air.Inst.Index,
         op_index: usize,
         operand: Air.Inst.Ref,
-    ) anyerror!void {
+    ) Error!void {
         const small_tomb_bits = Air.Liveness.bpi - 1;
         const dies = if (w.liveness) |liveness| blk: {
             if (op_index < small_tomb_bits)
@@ -1011,7 +1013,7 @@ const Writer = struct {
         s: anytype,
         operand: Air.Inst.Ref,
         dies: bool,
-    ) anyerror!void {
+    ) Error!void {
         if (@intFromEnum(operand) < InternPool.static_len) {
             return s.print("@{}", .{operand});
         } else if (operand.toInterned()) |ip_index| {
@@ -1031,7 +1033,7 @@ const Writer = struct {
         s: *std.io.BufferedWriter,
         inst: Air.Inst.Index,
         dies: bool,
-    ) anyerror!void {
+    ) Error!void {
         _ = w;
         try s.print("{f}", .{inst});
         if (dies) try s.writeByte('!');
diff --git a/src/Compilation.zig b/src/Compilation.zig
index 881173feb0f64832128a7307f2732484711b28eb..fc59429adc03e1a17c4d44d7f89d1998f2c88285 100644
--- a/src/Compilation.zig
+++ b/src/Compilation.zig
@@ -6024,7 +6024,7 @@ fn updateWin32Resource(comp: *Compilation, win32_resource: *Win32Resource, win32
 
             // In .rc files, a " within a quoted string is escaped as ""
             const fmtRcEscape = struct {
-                fn formatRcEscape(bytes: []const u8, bw: *std.io.BufferedWriter, comptime fmt: []const u8) anyerror!void {
+                fn formatRcEscape(bytes: []const u8, bw: *std.io.BufferedWriter, comptime fmt: []const u8) !void {
                     _ = fmt;
                     for (bytes) |byte| switch (byte) {
                         '"' => try bw.writeAll("\"\""),
diff --git a/src/InternPool.zig b/src/InternPool.zig
index 42b5fd44a618b1067a6dec473b9643587c6cb682..f9818dc1a67cd22e8dee101972e3b820743462bb 100644
--- a/src/InternPool.zig
+++ b/src/InternPool.zig
@@ -1888,7 +1888,7 @@ pub const NullTerminatedString = enum(u32) {
         string: NullTerminatedString,
         ip: *const InternPool,
     };
-    fn format(data: FormatData, bw: *std.io.BufferedWriter, comptime specifier: []const u8) anyerror!void {
+    fn format(data: FormatData, bw: *std.io.BufferedWriter, comptime specifier: []const u8) std.io.Writer.Error!void {
         const slice = data.string.toSlice(data.ip);
         if (comptime std.mem.eql(u8, specifier, "")) {
             try bw.writeAll(slice);
diff --git a/src/Package/Fetch/git.zig b/src/Package/Fetch/git.zig
index ff28658226911b989fdeb66ffe9cf5981505e543..a54cb476e7a55ea3abb0a7cad695a39f04b7994c 100644
--- a/src/Package/Fetch/git.zig
+++ b/src/Package/Fetch/git.zig
@@ -119,7 +119,7 @@ pub const Oid = union(Format) {
         } else error.InvalidOid;
     }
 
-    pub fn format(oid: Oid, bw: *std.io.BufferedWriter, comptime fmt: []const u8) anyerror!void {
+    pub fn format(oid: Oid, bw: *std.io.BufferedWriter, comptime fmt: []const u8) std.io.Writer.Error!void {
         _ = fmt;
         try bw.print("{x}", .{oid.slice()});
     }
diff --git a/src/Sema.zig b/src/Sema.zig
index 4518d7122f11966166abdecc65e8ea6e5ceb399d..882e18a5088326dde87f436d8efcce1f65f3ed26 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -9544,7 +9544,7 @@ fn callConvSupportsVarArgs(cc: std.builtin.CallingConvention.Tag) bool {
 fn checkCallConvSupportsVarArgs(sema: *Sema, block: *Block, src: LazySrcLoc, cc: std.builtin.CallingConvention.Tag) CompileError!void {
     const CallingConventionsSupportingVarArgsList = struct {
         arch: std.Target.Cpu.Arch,
-        pub fn format(ctx: @This(), bw: *std.io.BufferedWriter, comptime fmt: []const u8) anyerror!void {
+        pub fn format(ctx: @This(), bw: *std.io.BufferedWriter, comptime fmt: []const u8) !void {
             _ = fmt;
             var first = true;
             for (calling_conventions_supporting_var_args) |cc_inner| {
@@ -9990,7 +9990,7 @@ fn finishFunc(
         .bad_arch => |allowed_archs| {
             const ArchListFormatter = struct {
                 archs: []const std.Target.Cpu.Arch,
-                pub fn format(formatter: @This(), bw: *std.io.BufferedWriter, comptime fmt: []const u8) anyerror!void {
+                pub fn format(formatter: @This(), bw: *std.io.BufferedWriter, comptime fmt: []const u8) !void {
                     _ = fmt;
                     for (formatter.archs, 0..) |arch, i| {
                         if (i != 0)
diff --git a/src/Type.zig b/src/Type.zig
index 34a06f2485b41363ecf024ed1afcdcce2f82d6eb..242c6582a2cfdcb079aee0477880f598b1179f9d 100644
--- a/src/Type.zig
+++ b/src/Type.zig
@@ -121,7 +121,7 @@ pub fn eql(a: Type, b: Type, zcu: *const Zcu) bool {
     return a.toIntern() == b.toIntern();
 }
 
-pub fn format(ty: Type, bw: *std.io.BufferedWriter, comptime f: []const u8) anyerror!usize {
+pub fn format(ty: Type, bw: *std.io.BufferedWriter, comptime f: []const u8) !usize {
     _ = ty;
     _ = f;
     _ = bw;
@@ -142,7 +142,7 @@ const FormatContext = struct {
     pt: Zcu.PerThread,
 };
 
-fn format2(ctx: FormatContext, bw: *std.io.BufferedWriter, comptime f: []const u8) anyerror!void {
+fn format2(ctx: FormatContext, bw: *std.io.BufferedWriter, comptime f: []const u8) !void {
     comptime assert(f.len == 0);
     try print(ctx.ty, bw, ctx.pt);
 }
@@ -153,14 +153,14 @@ pub fn fmtDebug(ty: Type) std.fmt.Formatter(dump) {
 
 /// This is a debug function. In order to print types in a meaningful way
 /// we also need access to the module.
-pub fn dump(start_type: Type, bw: *std.io.BufferedWriter, comptime unused_format_string: []const u8) anyerror!void {
+pub fn dump(start_type: Type, bw: *std.io.BufferedWriter, comptime unused_format_string: []const u8) !void {
     comptime assert(unused_format_string.len == 0);
     return bw.print("{any}", .{start_type.ip_index});
 }
 
 /// Prints a name suitable for `@typeName`.
 /// TODO: take an `opt_sema` to pass to `fmtValue` when printing sentinels.
-pub fn print(ty: Type, bw: *std.io.BufferedWriter, pt: Zcu.PerThread) anyerror!void {
+pub fn print(ty: Type, bw: *std.io.BufferedWriter, pt: Zcu.PerThread) std.io.Writer.Error!void {
     const zcu = pt.zcu;
     const ip = &zcu.intern_pool;
     switch (ip.indexToKey(ty.toIntern())) {
diff --git a/src/Zcu.zig b/src/Zcu.zig
index 41bd25d2731b26a0ea873d5badb7542efce959eb..65512194e2d075c42528b48ec224ba6518f1233b 100644
--- a/src/Zcu.zig
+++ b/src/Zcu.zig
@@ -4344,7 +4344,7 @@ pub fn fmtDependee(zcu: *Zcu, d: InternPool.Dependee) std.fmt.Formatter(formatDe
     return .{ .data = .{ .dependee = d, .zcu = zcu } };
 }
 
-fn formatAnalUnit(data: struct { unit: AnalUnit, zcu: *Zcu }, bw: *std.io.BufferedWriter, comptime fmt: []const u8) anyerror!void {
+fn formatAnalUnit(data: struct { unit: AnalUnit, zcu: *Zcu }, bw: *std.io.BufferedWriter, comptime fmt: []const u8) !void {
     _ = fmt;
     const zcu = data.zcu;
     const ip = &zcu.intern_pool;
@@ -4368,7 +4368,7 @@ fn formatAnalUnit(data: struct { unit: AnalUnit, zcu: *Zcu }, bw: *std.io.Buffer
         .memoized_state => return bw.writeAll("memoized_state"),
     }
 }
-fn formatDependee(data: struct { dependee: InternPool.Dependee, zcu: *Zcu }, bw: *std.io.BufferedWriter, comptime fmt: []const u8) anyerror!void {
+fn formatDependee(data: struct { dependee: InternPool.Dependee, zcu: *Zcu }, bw: *std.io.BufferedWriter, comptime fmt: []const u8) !void {
     _ = fmt;
     const zcu = data.zcu;
     const ip = &zcu.intern_pool;
diff --git a/src/arch/aarch64/Emit.zig b/src/arch/aarch64/Emit.zig
index eb5c629c10c29fbe81527d19ef074d57744092db..933c810f5a8a3245a78f48ba147e928f679c418f 100644
--- a/src/arch/aarch64/Emit.zig
+++ b/src/arch/aarch64/Emit.zig
@@ -71,10 +71,6 @@ const BranchType = enum {
 };
 
 pub fn emitMir(emit: *Emit) InnerError!void {
-    return @errorCast(emit.emitMirInner());
-}
-
-fn emitMirInner(emit: *Emit) anyerror!void {
     const mir_tags = emit.mir.instructions.items(.tag);
 
     // Find smallest lowerings for branch instructions
@@ -441,7 +437,7 @@ fn fail(emit: *Emit, comptime format: []const u8, args: anytype) InnerError {
     return error.EmitFail;
 }
 
-fn dbgAdvancePCAndLine(emit: *Emit, line: u32, column: u32) anyerror!void {
+fn dbgAdvancePCAndLine(emit: *Emit, line: u32, column: u32) InnerError!void {
     const delta_line = @as(i33, line) - @as(i33, emit.prev_di_line);
     const delta_pc: usize = emit.code.items.len - emit.prev_di_pc;
     log.debug("  (advance pc={d} and line={d})", .{ delta_pc, delta_line });
diff --git a/src/arch/arm/Emit.zig b/src/arch/arm/Emit.zig
index d50b4b1ef6efcd83a3a02660d187f8e0fa669657..70b9bd5e4fdcb9972fedf68185040aebf0788c65 100644
--- a/src/arch/arm/Emit.zig
+++ b/src/arch/arm/Emit.zig
@@ -68,10 +68,6 @@ const BranchType = enum {
 };
 
 pub fn emitMir(emit: *Emit) InnerError!void {
-    return @errorCast(emit.emitMirInner());
-}
-
-fn emitMirInner(emit: *Emit) anyerror!void {
     const mir_tags = emit.mir.instructions.items(.tag);
 
     // Find smallest lowerings for branch instructions
diff --git a/src/arch/riscv64/CodeGen.zig b/src/arch/riscv64/CodeGen.zig
index f8b852c7629878f0ede137755f8a6d471728ec67..19ee60550c3e931b049b277fe3b87db5a79463ef 100644
--- a/src/arch/riscv64/CodeGen.zig
+++ b/src/arch/riscv64/CodeGen.zig
@@ -566,7 +566,7 @@ const InstTracking = struct {
         }
     }
 
-    pub fn format(inst_tracking: InstTracking, bw: *std.io.BufferedWriter, comptime _: []const u8) anyerror!void {
+    pub fn format(inst_tracking: InstTracking, bw: *std.io.BufferedWriter, comptime _: []const u8) std.io.Writer.Error!void {
         if (!std.meta.eql(inst_tracking.long, inst_tracking.short)) try bw.print("|{}| ", .{inst_tracking.long});
         try bw.print("{}", .{inst_tracking.short});
     }
@@ -932,7 +932,7 @@ const FormatWipMirData = struct {
     func: *Func,
     inst: Mir.Inst.Index,
 };
-fn formatWipMir(data: FormatWipMirData, bw: *std.io.BufferedWriter, comptime _: []const u8) anyerror!void {
+fn formatWipMir(data: FormatWipMirData, bw: *std.io.BufferedWriter, comptime _: []const u8) std.io.Writer.Error!void {
     const pt = data.func.pt;
     const comp = pt.zcu.comp;
     var lower: Lower = .{
@@ -980,7 +980,7 @@ const FormatNavData = struct {
     ip: *const InternPool,
     nav_index: InternPool.Nav.Index,
 };
-fn formatNav(data: FormatNavData, bw: *std.io.BufferedWriter, comptime _: []const u8) anyerror!void {
+fn formatNav(data: FormatNavData, bw: *std.io.BufferedWriter, comptime _: []const u8) std.io.Writer.Error!void {
     try bw.print("{f}", .{data.ip.getNav(data.nav_index).fqn.fmt(data.ip)});
 }
 fn fmtNav(nav_index: InternPool.Nav.Index, ip: *const InternPool) std.fmt.Formatter(formatNav) {
@@ -994,7 +994,7 @@ const FormatAirData = struct {
     func: *Func,
     inst: Air.Inst.Index,
 };
-fn formatAir(data: FormatAirData, _: *std.io.BufferedWriter, comptime _: []const u8) anyerror!void {
+fn formatAir(data: FormatAirData, _: *std.io.BufferedWriter, comptime _: []const u8) std.io.Writer.Error!void {
     data.func.air.dumpInst(data.inst, data.func.pt, data.func.liveness);
 }
 fn fmtAir(func: *Func, inst: Air.Inst.Index) std.fmt.Formatter(formatAir) {
@@ -1004,7 +1004,7 @@ fn fmtAir(func: *Func, inst: Air.Inst.Index) std.fmt.Formatter(formatAir) {
 const FormatTrackingData = struct {
     func: *Func,
 };
-fn formatTracking(data: FormatTrackingData, bw: *std.io.BufferedWriter, comptime _: []const u8) anyerror!void {
+fn formatTracking(data: FormatTrackingData, bw: *std.io.BufferedWriter, comptime _: []const u8) std.io.Writer.Error!void {
     var it = data.func.inst_tracking.iterator();
     while (it.next()) |entry| try bw.print("\n%{d} = {f}", .{ entry.key_ptr.*, entry.value_ptr.* });
 }
diff --git a/src/arch/riscv64/Emit.zig b/src/arch/riscv64/Emit.zig
index aa3244ca863aa45cba854cdda8bf0a0ac0dfa0db..d79aec2dae4c9ac473c3f21c028a756399a60524 100644
--- a/src/arch/riscv64/Emit.zig
+++ b/src/arch/riscv64/Emit.zig
@@ -18,10 +18,6 @@ pub const Error = Lower.Error || error{
 };
 
 pub fn emitMir(emit: *Emit) Error!void {
-    return @errorCast(emit.emitMirInner());
-}
-
-fn emitMirInner(emit: *Emit) anyerror!void {
     const gpa = emit.bin_file.comp.gpa;
     var aw: std.io.AllocatingWriter = undefined;
     const bw = aw.fromArrayList(gpa, emit.code);
diff --git a/src/arch/riscv64/Mir.zig b/src/arch/riscv64/Mir.zig
index d3ebaac6c505853980b0d05e49a44f66a46d15e4..aac134a80c02b8f3d0dc1d093944cfb70ac7d43e 100644
--- a/src/arch/riscv64/Mir.zig
+++ b/src/arch/riscv64/Mir.zig
@@ -92,7 +92,7 @@ pub const Inst = struct {
         },
     };
 
-    pub fn format(inst: Inst, bw: *std.io.BufferedWriter, comptime fmt: []const u8) anyerror!void {
+    pub fn format(inst: Inst, bw: *std.io.BufferedWriter, comptime fmt: []const u8) !void {
         assert(fmt.len == 0);
         try bw.print("Tag: {s}, Data: {s}", .{ @tagName(inst.tag), @tagName(inst.data) });
     }
diff --git a/src/arch/riscv64/bits.zig b/src/arch/riscv64/bits.zig
index a3e39c9f75b85b0b42e68809117a849a43ab448d..86ff6473d729999547131e5851f0115e386f19b0 100644
--- a/src/arch/riscv64/bits.zig
+++ b/src/arch/riscv64/bits.zig
@@ -256,7 +256,7 @@ pub const FrameIndex = enum(u32) {
         return @intFromEnum(fi) < named_count;
     }
 
-    pub fn format(fi: FrameIndex, bw: *std.io.BufferedWriter, comptime _: []const u8) anyerror!void {
+    pub fn format(fi: FrameIndex, bw: *std.io.BufferedWriter, comptime _: []const u8) std.io.Writer.Error!void {
         try bw.writeAll("FrameIndex");
         if (fi.isNamed())
             try bw.print(".{s}", .{@tagName(fi)})
diff --git a/src/arch/wasm/Emit.zig b/src/arch/wasm/Emit.zig
index 60d05238fc14aa80c569c55683f7963665e0b2c7..e0795e746de586f264a5aa19d3a5ec0fdd5c6367 100644
--- a/src/arch/wasm/Emit.zig
+++ b/src/arch/wasm/Emit.zig
@@ -22,10 +22,6 @@ pub const Error = error{
 };
 
 pub fn lowerToCode(emit: *Emit) Error!void {
-    return @errorCast(emit.lowerToCodeInner());
-}
-
-fn lowerToCodeInner(emit: *Emit) anyerror!void {
     const mir = &emit.mir;
     const bw = emit.bw;
     const wasm = emit.wasm;
@@ -897,12 +893,12 @@ fn lowerToCodeInner(emit: *Emit) anyerror!void {
 }
 
 /// Asserts 20 unused capacity.
-fn encodeMemArg(bw: *std.io.BufferedWriter, mem_arg: Mir.MemArg) anyerror!void {
+fn encodeMemArg(bw: *std.io.BufferedWriter, mem_arg: Mir.MemArg) std.io.Writer.Error!void {
     try bw.writeLeb128(Wasm.Alignment.fromNonzeroByteUnits(mem_arg.alignment).toLog2Units());
     try bw.writeLeb128(mem_arg.offset);
 }
 
-fn uavRefObj(wasm: *Wasm, bw: *std.io.BufferedWriter, value: InternPool.Index, offset: i32, is_wasm32: bool) !void {
+fn uavRefObj(wasm: *Wasm, bw: *std.io.BufferedWriter, value: InternPool.Index, offset: i32, is_wasm32: bool) std.io.Writer.Error!void {
     const comp = wasm.base.comp;
     const gpa = comp.gpa;
     const opcode: std.wasm.Opcode = if (is_wasm32) .i32_const else .i64_const;
@@ -951,6 +947,6 @@ fn navRefOff(wasm: *Wasm, bw: *std.io.BufferedWriter, data: Mir.NavRefOff, is_wa
     }
 }
 
-fn appendOutputFunctionIndex(bw: *std.io.BufferedWriter, i: Wasm.OutputFunctionIndex) anyerror!void {
+fn appendOutputFunctionIndex(bw: *std.io.BufferedWriter, i: Wasm.OutputFunctionIndex) std.io.Writer.Error!void {
     return bw.writeLeb128(@intFromEnum(i));
 }
diff --git a/src/arch/x86_64/CodeGen.zig b/src/arch/x86_64/CodeGen.zig
index 387febe0a743de9dd0b655fb281d20de8cc50a28..63e743605899255c87173e881576411b7a65ac51 100644
--- a/src/arch/x86_64/CodeGen.zig
+++ b/src/arch/x86_64/CodeGen.zig
@@ -524,7 +524,7 @@ pub const MCValue = union(enum) {
         };
     }
 
-    pub fn format(mcv: MCValue, bw: *std.io.BufferedWriter, comptime _: []const u8) anyerror!void {
+    pub fn format(mcv: MCValue, bw: *std.io.BufferedWriter, comptime _: []const u8) std.io.Writer.Error!void {
         switch (mcv) {
             .none, .unreach, .dead, .undef => try bw.print("({s})", .{@tagName(mcv)}),
             .immediate => |pl| try bw.print("0x{x}", .{pl}),
@@ -811,7 +811,7 @@ const InstTracking = struct {
         }
     }
 
-    pub fn format(tracking: InstTracking, bw: *std.io.BufferedWriter, comptime _: []const u8) anyerror!void {
+    pub fn format(tracking: InstTracking, bw: *std.io.BufferedWriter, comptime _: []const u8) std.io.Writer.Error!void {
         if (!std.meta.eql(tracking.long, tracking.short)) try bw.print("|{f}| ", .{tracking.long});
         try bw.print("{f}", .{tracking.short});
     }
@@ -1087,7 +1087,7 @@ const FormatNavData = struct {
     ip: *const InternPool,
     nav_index: InternPool.Nav.Index,
 };
-fn formatNav(data: FormatNavData, bw: *std.io.BufferedWriter, comptime _: []const u8) anyerror!void {
+fn formatNav(data: FormatNavData, bw: *std.io.BufferedWriter, comptime _: []const u8) std.io.Writer.Error!void {
     try bw.print("{f}", .{data.ip.getNav(data.nav_index).fqn.fmt(data.ip)});
 }
 fn fmtNav(nav_index: InternPool.Nav.Index, ip: *const InternPool) std.fmt.Formatter(formatNav) {
@@ -1101,7 +1101,7 @@ const FormatAirData = struct {
     self: *CodeGen,
     inst: Air.Inst.Index,
 };
-fn formatAir(data: FormatAirData, _: *std.io.BufferedWriter, comptime _: []const u8) anyerror!void {
+fn formatAir(data: FormatAirData, _: *std.io.BufferedWriter, comptime _: []const u8) std.io.Writer.Error!void {
     data.self.air.dumpInst(data.inst, data.self.pt, data.self.liveness);
 }
 fn fmtAir(self: *CodeGen, inst: Air.Inst.Index) std.fmt.Formatter(formatAir) {
@@ -1112,7 +1112,7 @@ const FormatWipMirData = struct {
     self: *CodeGen,
     inst: Mir.Inst.Index,
 };
-fn formatWipMir(data: FormatWipMirData, bw: *std.io.BufferedWriter, comptime _: []const u8) !void {
+fn formatWipMir(data: FormatWipMirData, bw: *std.io.BufferedWriter, comptime _: []const u8) std.io.Writer.Error!void {
     var lower: Lower = .{
         .target = data.self.target,
         .allocator = data.self.gpa,
@@ -1208,7 +1208,7 @@ fn fmtWipMir(self: *CodeGen, inst: Mir.Inst.Index) std.fmt.Formatter(formatWipMi
 const FormatTrackingData = struct {
     self: *CodeGen,
 };
-fn formatTracking(data: FormatTrackingData, bw: *std.io.BufferedWriter, comptime _: []const u8) anyerror!void {
+fn formatTracking(data: FormatTrackingData, bw: *std.io.BufferedWriter, comptime _: []const u8) std.io.Writer.Error!void {
     var it = data.self.inst_tracking.iterator();
     while (it.next()) |entry| try bw.print("\n{f} = {f}", .{ entry.key_ptr.*, entry.value_ptr.* });
 }
diff --git a/src/arch/x86_64/Disassembler.zig b/src/arch/x86_64/Disassembler.zig
index 163689de1915eb7749e5c1f64975079ff43afbf4..88e5f4cd4dc6c6908852ddfd38b5fe362b63ecf4 100644
--- a/src/arch/x86_64/Disassembler.zig
+++ b/src/arch/x86_64/Disassembler.zig
@@ -31,10 +31,6 @@ pub fn init(code: []const u8) Disassembler {
 }
 
 pub fn next(dis: *Disassembler) Error!?Instruction {
-    return @errorCast(dis.nextInner());
-}
-
-fn nextInner(dis: *Disassembler) anyerror!?Instruction {
     const prefixes = try dis.parsePrefixes();
 
     const enc = try dis.parseEncoding(prefixes) orelse return error.UnknownOpcode;
@@ -375,7 +371,7 @@ fn parseGpRegister(low_enc: u3, is_extended: bool, rex: Rex, bit_size: u64) Regi
     };
 }
 
-fn parseImm(dis: *Disassembler, kind: Encoding.Op) anyerror!Immediate {
+fn parseImm(dis: *Disassembler, kind: Encoding.Op) !Immediate {
     var br: std.io.BufferedReader = undefined;
     br.initFixed(dis.code[dis.pos..]);
     defer dis.pos += br.seek;
@@ -391,7 +387,7 @@ fn parseImm(dis: *Disassembler, kind: Encoding.Op) anyerror!Immediate {
     };
 }
 
-fn parseOffset(dis: *Disassembler) anyerror!u64 {
+fn parseOffset(dis: *Disassembler) !u64 {
     var br: std.io.BufferedReader = undefined;
     br.initFixed(dis.code[dis.pos..]);
     defer dis.pos += br.seek;
@@ -467,7 +463,7 @@ fn parseSibByte(dis: *Disassembler) !Sib {
     return Sib{ .scale = scale, .index = index, .base = base };
 }
 
-fn parseDisplacement(dis: *Disassembler, modrm: ModRm, sib: ?Sib) anyerror!i32 {
+fn parseDisplacement(dis: *Disassembler, modrm: ModRm, sib: ?Sib) !i32 {
     var br: std.io.BufferedReader = undefined;
     br.initFixed(dis.code[dis.pos..]);
     defer dis.pos += br.seek;
diff --git a/src/arch/x86_64/Emit.zig b/src/arch/x86_64/Emit.zig
index bacac7d2967541c8cf21fd68e52e3e48cdcf357f..7450f90bcdf0c7d48432d38fe0152831ef0c1a28 100644
--- a/src/arch/x86_64/Emit.zig
+++ b/src/arch/x86_64/Emit.zig
@@ -909,7 +909,7 @@ const Loc = struct {
     is_stmt: bool,
 };
 
-fn dbgAdvancePCAndLine(emit: *Emit, loc: Loc, pc: usize) anyerror!void {
+fn dbgAdvancePCAndLine(emit: *Emit, loc: Loc, pc: usize) Error!void {
     const delta_line = @as(i33, loc.line) - @as(i33, emit.prev_di_loc.line);
     const delta_pc = pc - emit.prev_di_pc;
     log.debug("  (advance pc={d} and line={d})", .{ delta_pc, delta_line });
diff --git a/src/arch/x86_64/Encoding.zig b/src/arch/x86_64/Encoding.zig
index 5bd9baaf83732e4a4b4a5f953b938ffd70c4faf8..07567f2fbdeeeb388bdbd3464319b5d90fb34782 100644
--- a/src/arch/x86_64/Encoding.zig
+++ b/src/arch/x86_64/Encoding.zig
@@ -158,7 +158,7 @@ pub fn modRmExt(encoding: Encoding) u3 {
     };
 }
 
-pub fn format(encoding: Encoding, bw: *std.io.BufferedWriter, comptime fmt: []const u8) anyerror!void {
+pub fn format(encoding: Encoding, bw: *std.io.BufferedWriter, comptime fmt: []const u8) !void {
     _ = fmt;
 
     var opc = encoding.opcode();
diff --git a/src/arch/x86_64/bits.zig b/src/arch/x86_64/bits.zig
index 9592a5e40c58d127e0a48aa1479196695984e9cf..0c913836cd2e4d06715b784f8586e5ed3c861736 100644
--- a/src/arch/x86_64/bits.zig
+++ b/src/arch/x86_64/bits.zig
@@ -728,7 +728,7 @@ pub const FrameIndex = enum(u32) {
         return @intFromEnum(fi) < named_count;
     }
 
-    pub fn format(fi: FrameIndex, bw: *std.io.BufferedWriter, comptime _: []const u8) anyerror!void {
+    pub fn format(fi: FrameIndex, bw: *std.io.BufferedWriter, comptime _: []const u8) std.io.Writer.Error!void {
         try bw.writeAll("FrameIndex");
         if (fi.isNamed())
             try bw.print(".{s}", .{@tagName(fi)})
@@ -835,7 +835,7 @@ pub const Memory = struct {
             };
         }
 
-        pub fn format(s: Size, bw: *std.io.BufferedWriter, comptime _: []const u8) anyerror!void {
+        pub fn format(s: Size, bw: *std.io.BufferedWriter, comptime _: []const u8) std.io.Writer.Error!void {
             if (s == .none) return;
             try bw.writeAll(@tagName(s));
             switch (s) {
diff --git a/src/arch/x86_64/encoder.zig b/src/arch/x86_64/encoder.zig
index 8c7d06259f1ef8d593c427da31ecd15d13c5c18d..652e6867e47f94afafaa1e702287552c275c0629 100644
--- a/src/arch/x86_64/encoder.zig
+++ b/src/arch/x86_64/encoder.zig
@@ -226,7 +226,7 @@ pub const Instruction = struct {
             };
         }
 
-        fn format(op: Operand, bw: *std.io.BufferedWriter, comptime unused_format_string: []const u8) anyerror!void {
+        fn format(op: Operand, bw: *std.io.BufferedWriter, comptime unused_format_string: []const u8) !void {
             _ = op;
             _ = bw;
             _ = unused_format_string;
@@ -238,7 +238,7 @@ pub const Instruction = struct {
             enc_op: Encoding.Op,
         };
 
-        fn fmtContext(ctx: FormatContext, bw: *std.io.BufferedWriter, comptime unused_format_string: []const u8) anyerror!void {
+        fn fmtContext(ctx: FormatContext, bw: *std.io.BufferedWriter, comptime unused_format_string: []const u8) std.io.Writer.Error!void {
             _ = unused_format_string;
             const op = ctx.op;
             const enc_op = ctx.enc_op;
@@ -360,7 +360,7 @@ pub const Instruction = struct {
         return inst;
     }
 
-    pub fn format(inst: Instruction, bw: *std.io.BufferedWriter, comptime unused_format_string: []const u8) anyerror!void {
+    pub fn format(inst: Instruction, bw: *std.io.BufferedWriter, comptime unused_format_string: []const u8) std.io.Writer.Error!void {
         _ = unused_format_string;
         switch (inst.prefix) {
             .none, .directive => {},
@@ -794,7 +794,7 @@ fn Encoder(comptime opts: Options) type {
         // --------
 
         /// Encodes legacy prefixes
-        pub fn legacyPrefixes(self: Self, prefixes: LegacyPrefixes) anyerror!void {
+        pub fn legacyPrefixes(self: Self, prefixes: LegacyPrefixes) !void {
             if (@as(u16, @bitCast(prefixes)) != 0) {
                 // Hopefully this path isn't taken very often, so we'll do it the slow way for now
 
@@ -830,7 +830,7 @@ fn Encoder(comptime opts: Options) type {
         /// Use 16 bit operand size
         ///
         /// Note that this flag is overridden by REX.W, if both are present.
-        pub fn prefix16BitMode(self: Self) anyerror!void {
+        pub fn prefix16BitMode(self: Self) !void {
             try self.bw.writeByte(0x66);
         }
 
@@ -840,7 +840,7 @@ fn Encoder(comptime opts: Options) type {
         /// or one of reg, index, r/m, base, or opcode-reg might be extended.
         ///
         /// See struct `Rex` for a description of each field.
-        pub fn rex(self: Self, fields: Rex) anyerror!void {
+        pub fn rex(self: Self, fields: Rex) !void {
             if (!fields.present and !fields.isSet()) return;
 
             var byte: u8 = 0b0100_0000;
@@ -856,7 +856,7 @@ fn Encoder(comptime opts: Options) type {
         /// Encodes a VEX prefix given all the fields
         ///
         /// See struct `Vex` for a description of each field.
-        pub fn vex(self: Self, fields: Vex) anyerror!void {
+        pub fn vex(self: Self, fields: Vex) !void {
             if (fields.is3Byte()) {
                 try self.bw.writeByte(0b1100_0100);
 
@@ -889,7 +889,7 @@ fn Encoder(comptime opts: Options) type {
         // ------
 
         /// Encodes a 1 byte opcode
-        pub fn opcode_1byte(self: Self, opcode: u8) anyerror!void {
+        pub fn opcode_1byte(self: Self, opcode: u8) !void {
             try self.bw.writeByte(opcode);
         }
 
@@ -898,7 +898,7 @@ fn Encoder(comptime opts: Options) type {
         /// e.g. IMUL has the opcode 0x0f 0xaf, so you use
         ///
         /// encoder.opcode_2byte(0x0f, 0xaf);
-        pub fn opcode_2byte(self: Self, prefix: u8, opcode: u8) anyerror!void {
+        pub fn opcode_2byte(self: Self, prefix: u8, opcode: u8) !void {
             try self.bw.writeAll(&.{ prefix, opcode });
         }
 
@@ -907,14 +907,14 @@ fn Encoder(comptime opts: Options) type {
         /// e.g. MOVSD has the opcode 0xf2 0x0f 0x10
         ///
         /// encoder.opcode_3byte(0xf2, 0x0f, 0x10);
-        pub fn opcode_3byte(self: Self, prefix_1: u8, prefix_2: u8, opcode: u8) anyerror!void {
+        pub fn opcode_3byte(self: Self, prefix_1: u8, prefix_2: u8, opcode: u8) !void {
             try self.bw.writeAll(&.{ prefix_1, prefix_2, opcode });
         }
 
         /// Encodes a 1 byte opcode with a reg field
         ///
         /// Remember to add a REX prefix byte if reg is extended!
-        pub fn opcode_withReg(self: Self, opcode: u8, reg: u3) anyerror!void {
+        pub fn opcode_withReg(self: Self, opcode: u8, reg: u3) !void {
             assert(opcode & 0b111 == 0);
             try self.bw.writeByte(opcode | reg);
         }
@@ -926,7 +926,7 @@ fn Encoder(comptime opts: Options) type {
         /// Construct a ModR/M byte given all the fields
         ///
         /// Remember to add a REX prefix byte if reg or rm are extended!
-        pub fn modRm(self: Self, mod: u2, reg_or_opx: u3, rm: u3) anyerror!void {
+        pub fn modRm(self: Self, mod: u2, reg_or_opx: u3, rm: u3) !void {
             try self.bw.writeByte(@as(u8, mod) << 6 | @as(u8, reg_or_opx) << 3 | rm);
         }
 
@@ -935,7 +935,7 @@ fn Encoder(comptime opts: Options) type {
         ///
         /// Note reg's effective address is always just reg for the ModR/M byte.
         /// Remember to add a REX prefix byte if reg or rm are extended!
-        pub fn modRm_direct(self: Self, reg_or_opx: u3, rm: u3) anyerror!void {
+        pub fn modRm_direct(self: Self, reg_or_opx: u3, rm: u3) !void {
             try self.modRm(0b11, reg_or_opx, rm);
         }
 
@@ -944,7 +944,7 @@ fn Encoder(comptime opts: Options) type {
         ///
         /// Note reg's effective address is always just reg for the ModR/M byte.
         /// Remember to add a REX prefix byte if reg or rm are extended!
-        pub fn modRm_indirectDisp0(self: Self, reg_or_opx: u3, rm: u3) anyerror!void {
+        pub fn modRm_indirectDisp0(self: Self, reg_or_opx: u3, rm: u3) !void {
             assert(rm != 4 and rm != 5);
             try self.modRm(0b00, reg_or_opx, rm);
         }
@@ -954,7 +954,7 @@ fn Encoder(comptime opts: Options) type {
         ///
         /// Note reg's effective address is always just reg for the ModR/M byte.
         /// Remember to add a REX prefix byte if reg or rm are extended!
-        pub fn modRm_SIBDisp0(self: Self, reg_or_opx: u3) anyerror!void {
+        pub fn modRm_SIBDisp0(self: Self, reg_or_opx: u3) !void {
             try self.modRm(0b00, reg_or_opx, 0b100);
         }
 
@@ -963,7 +963,7 @@ fn Encoder(comptime opts: Options) type {
         ///
         /// Note reg's effective address is always just reg for the ModR/M byte.
         /// Remember to add a REX prefix byte if reg or rm are extended!
-        pub fn modRm_RIPDisp32(self: Self, reg_or_opx: u3) anyerror!void {
+        pub fn modRm_RIPDisp32(self: Self, reg_or_opx: u3) !void {
             try self.modRm(0b00, reg_or_opx, 0b101);
         }
 
@@ -972,7 +972,7 @@ fn Encoder(comptime opts: Options) type {
         ///
         /// Note reg's effective address is always just reg for the ModR/M byte.
         /// Remember to add a REX prefix byte if reg or rm are extended!
-        pub fn modRm_indirectDisp8(self: Self, reg_or_opx: u3, rm: u3) anyerror!void {
+        pub fn modRm_indirectDisp8(self: Self, reg_or_opx: u3, rm: u3) !void {
             assert(rm != 4);
             try self.modRm(0b01, reg_or_opx, rm);
         }
@@ -982,7 +982,7 @@ fn Encoder(comptime opts: Options) type {
         ///
         /// Note reg's effective address is always just reg for the ModR/M byte.
         /// Remember to add a REX prefix byte if reg or rm are extended!
-        pub fn modRm_SIBDisp8(self: Self, reg_or_opx: u3) anyerror!void {
+        pub fn modRm_SIBDisp8(self: Self, reg_or_opx: u3) !void {
             try self.modRm(0b01, reg_or_opx, 0b100);
         }
 
@@ -991,7 +991,7 @@ fn Encoder(comptime opts: Options) type {
         ///
         /// Note reg's effective address is always just reg for the ModR/M byte.
         /// Remember to add a REX prefix byte if reg or rm are extended!
-        pub fn modRm_indirectDisp32(self: Self, reg_or_opx: u3, rm: u3) anyerror!void {
+        pub fn modRm_indirectDisp32(self: Self, reg_or_opx: u3, rm: u3) !void {
             assert(rm != 4);
             try self.modRm(0b10, reg_or_opx, rm);
         }
@@ -1001,7 +1001,7 @@ fn Encoder(comptime opts: Options) type {
         ///
         /// Note reg's effective address is always just reg for the ModR/M byte.
         /// Remember to add a REX prefix byte if reg or rm are extended!
-        pub fn modRm_SIBDisp32(self: Self, reg_or_opx: u3) anyerror!void {
+        pub fn modRm_SIBDisp32(self: Self, reg_or_opx: u3) !void {
             try self.modRm(0b10, reg_or_opx, 0b100);
         }
 
@@ -1012,7 +1012,7 @@ fn Encoder(comptime opts: Options) type {
         /// Construct a SIB byte given all the fields
         ///
         /// Remember to add a REX prefix byte if index or base are extended!
-        pub fn sib(self: Self, scale: u2, index: u3, base: u3) anyerror!void {
+        pub fn sib(self: Self, scale: u2, index: u3, base: u3) !void {
             try self.bw.writeByte(@as(u8, scale) << 6 | @as(u8, index) << 3 | base);
         }
 
@@ -1020,7 +1020,7 @@ fn Encoder(comptime opts: Options) type {
         /// r/m effective address: [base + scale * index]
         ///
         /// Remember to add a REX prefix byte if index or base are extended!
-        pub fn sib_scaleIndexBase(self: Self, scale: u2, index: u3, base: u3) anyerror!void {
+        pub fn sib_scaleIndexBase(self: Self, scale: u2, index: u3, base: u3) !void {
             assert(base != 5);
 
             try self.sib(scale, index, base);
@@ -1030,7 +1030,7 @@ fn Encoder(comptime opts: Options) type {
         /// r/m effective address: [scale * index + disp32]
         ///
         /// Remember to add a REX prefix byte if index or base are extended!
-        pub fn sib_scaleIndexDisp32(self: Self, scale: u2, index: u3) anyerror!void {
+        pub fn sib_scaleIndexDisp32(self: Self, scale: u2, index: u3) !void {
             // scale is actually ignored
             // index = 4 means no index if and only if we haven't extended the register
             // TODO enforce this
@@ -1042,7 +1042,7 @@ fn Encoder(comptime opts: Options) type {
         /// r/m effective address: [base]
         ///
         /// Remember to add a REX prefix byte if index or base are extended!
-        pub fn sib_base(self: Self, base: u3) anyerror!void {
+        pub fn sib_base(self: Self, base: u3) !void {
             assert(base != 5);
 
             // scale is actually ignored
@@ -1054,7 +1054,7 @@ fn Encoder(comptime opts: Options) type {
         /// r/m effective address: [disp32]
         ///
         /// Remember to add a REX prefix byte if index or base are extended!
-        pub fn sib_disp32(self: Self) anyerror!void {
+        pub fn sib_disp32(self: Self) !void {
             // scale is actually ignored
             // index = 4 means no index
             // base = 5 means no base, if mod == 0.
@@ -1065,7 +1065,7 @@ fn Encoder(comptime opts: Options) type {
         /// r/m effective address: [base + scale * index + disp8]
         ///
         /// Remember to add a REX prefix byte if index or base are extended!
-        pub fn sib_scaleIndexBaseDisp8(self: Self, scale: u2, index: u3, base: u3) anyerror!void {
+        pub fn sib_scaleIndexBaseDisp8(self: Self, scale: u2, index: u3, base: u3) !void {
             try self.sib(scale, index, base);
         }
 
@@ -1073,7 +1073,7 @@ fn Encoder(comptime opts: Options) type {
         /// r/m effective address: [base + disp8]
         ///
         /// Remember to add a REX prefix byte if index or base are extended!
-        pub fn sib_baseDisp8(self: Self, base: u3) anyerror!void {
+        pub fn sib_baseDisp8(self: Self, base: u3) !void {
             // scale is ignored
             // index = 4 means no index
             try self.sib(0, 4, base);
@@ -1083,7 +1083,7 @@ fn Encoder(comptime opts: Options) type {
         /// r/m effective address: [base + scale * index + disp32]
         ///
         /// Remember to add a REX prefix byte if index or base are extended!
-        pub fn sib_scaleIndexBaseDisp32(self: Self, scale: u2, index: u3, base: u3) anyerror!void {
+        pub fn sib_scaleIndexBaseDisp32(self: Self, scale: u2, index: u3, base: u3) !void {
             try self.sib(scale, index, base);
         }
 
@@ -1091,7 +1091,7 @@ fn Encoder(comptime opts: Options) type {
         /// r/m effective address: [base + disp32]
         ///
         /// Remember to add a REX prefix byte if index or base are extended!
-        pub fn sib_baseDisp32(self: Self, base: u3) anyerror!void {
+        pub fn sib_baseDisp32(self: Self, base: u3) !void {
             // scale is ignored
             // index = 4 means no index
             try self.sib(0, 4, base);
@@ -1104,42 +1104,42 @@ fn Encoder(comptime opts: Options) type {
         /// Encode an 8 bit displacement
         ///
         /// It is sign-extended to 64 bits by the cpu.
-        pub fn disp8(self: Self, disp: i8) anyerror!void {
+        pub fn disp8(self: Self, disp: i8) !void {
             try self.bw.writeByte(@as(u8, @bitCast(disp)));
         }
 
         /// Encode an 32 bit displacement
         ///
         /// It is sign-extended to 64 bits by the cpu.
-        pub fn disp32(self: Self, disp: i32) anyerror!void {
+        pub fn disp32(self: Self, disp: i32) !void {
             try self.bw.writeInt(i32, disp, .little);
         }
 
         /// Encode an 8 bit immediate
         ///
         /// It is sign-extended to 64 bits by the cpu.
-        pub fn imm8(self: Self, imm: u8) anyerror!void {
+        pub fn imm8(self: Self, imm: u8) !void {
             try self.bw.writeByte(imm);
         }
 
         /// Encode an 16 bit immediate
         ///
         /// It is sign-extended to 64 bits by the cpu.
-        pub fn imm16(self: Self, imm: u16) anyerror!void {
+        pub fn imm16(self: Self, imm: u16) !void {
             try self.bw.writeInt(u16, imm, .little);
         }
 
         /// Encode an 32 bit immediate
         ///
         /// It is sign-extended to 64 bits by the cpu.
-        pub fn imm32(self: Self, imm: u32) anyerror!void {
+        pub fn imm32(self: Self, imm: u32) !void {
             try self.bw.writeInt(u32, imm, .little);
         }
 
         /// Encode an 64 bit immediate
         ///
         /// It is sign-extended to 64 bits by the cpu.
-        pub fn imm64(self: Self, imm: u64) anyerror!void {
+        pub fn imm64(self: Self, imm: u64) !void {
             try self.bw.writeInt(u64, imm, .little);
         }
     };
diff --git a/src/codegen.zig b/src/codegen.zig
index 5ea98b1a52783abe5ac716cd6084d625bc4bcd13..3bcf8208deaaf699bb4aead702d3f94074bb15ca 100644
--- a/src/codegen.zig
+++ b/src/codegen.zig
@@ -316,7 +316,10 @@ pub fn generateSymbol(
     var aw: std.io.AllocatingWriter = undefined;
     const bw = aw.fromArrayList(pt.zcu.gpa, code);
     defer code.* = aw.toArrayList();
-    return @errorCast(generateSymbolInner(bin_file, pt, src_loc, val, bw, reloc_parent));
+    return generateSymbolInner(bin_file, pt, src_loc, val, bw, reloc_parent) catch |err| switch (err) {
+        error.WriteFailed => return error.OutOfMemory,
+        else => |e| return e,
+    };
 }
 pub fn generateSymbolInner(
     bin_file: *link.File,
@@ -325,7 +328,7 @@ pub fn generateSymbolInner(
     val: Value,
     bw: *std.io.BufferedWriter,
     reloc_parent: link.File.RelocInfo.Parent,
-) anyerror!void {
+) GenerateSymbolError!void {
     const zcu = pt.zcu;
     const ip = &zcu.intern_pool;
     const ty = val.typeOf(zcu);
@@ -710,7 +713,7 @@ fn lowerPtr(
     bw: *std.io.BufferedWriter,
     reloc_parent: link.File.RelocInfo.Parent,
     prev_offset: u64,
-) anyerror!void {
+) GenerateSymbolError!void {
     const zcu = pt.zcu;
     const ptr = zcu.intern_pool.indexToKey(ptr_val).ptr;
     const offset: u64 = prev_offset + ptr.byte_offset;
@@ -763,7 +766,7 @@ fn lowerUavRef(
     bw: *std.io.BufferedWriter,
     reloc_parent: link.File.RelocInfo.Parent,
     offset: u64,
-) anyerror!void {
+) GenerateSymbolError!void {
     const zcu = pt.zcu;
     const ip = &zcu.intern_pool;
     const comp = lf.comp;
@@ -817,7 +820,7 @@ fn lowerNavRef(
     bw: *std.io.BufferedWriter,
     reloc_parent: link.File.RelocInfo.Parent,
     offset: u64,
-) anyerror!void {
+) GenerateSymbolError!void {
     const zcu = pt.zcu;
     const gpa = zcu.gpa;
     const ip = &zcu.intern_pool;
diff --git a/src/codegen/c.zig b/src/codegen/c.zig
index 42105d622ae4e3591be22ff237fa0c1fbbb7b780..c235c8f69050bbc2301e4cf23fcf9f2ad1f5c10b 100644
--- a/src/codegen/c.zig
+++ b/src/codegen/c.zig
@@ -8137,7 +8137,7 @@ const StringLiteral = struct {
         };
     }
 
-    pub fn start(self: *StringLiteral) anyerror!void {
+    pub fn start(self: *StringLiteral) std.io.Writer.Error!void {
         const writer = self.writer;
         if (self.len <= max_string_initializer_len) {
             self.bytes_written += try writer.writeByteCount('\"');
@@ -8146,7 +8146,7 @@ const StringLiteral = struct {
         }
     }
 
-    pub fn end(self: *StringLiteral) anyerror!void {
+    pub fn end(self: *StringLiteral) std.io.Writer.Error!void {
         const writer = self.writer;
         if (self.len <= max_string_initializer_len) {
             self.bytes_written += try writer.writeByteCount('\"');
@@ -8155,7 +8155,7 @@ const StringLiteral = struct {
         }
     }
 
-    fn writeStringLiteralChar(writer: *std.io.BufferedWriter, c: u8) anyerror!usize {
+    fn writeStringLiteralChar(writer: *std.io.BufferedWriter, c: u8) std.io.Writer.Error!usize {
         switch (c) {
             7 => return writer.writeAllCount("\\a"),
             8 => return writer.writeAllCount("\\b"),
@@ -8172,7 +8172,7 @@ const StringLiteral = struct {
         }
     }
 
-    pub fn writeChar(self: *StringLiteral, c: u8) anyerror!void {
+    pub fn writeChar(self: *StringLiteral, c: u8) std.io.Writer.Error!void {
         const writer = self.writer;
         if (self.len <= max_string_initializer_len) {
             if (self.cur_len == 0 and self.bytes_written > 1)
diff --git a/src/codegen/spirv/spec.zig b/src/codegen/spirv/spec.zig
index 7c8bcedc358a9f07dbc841e8e9b6078beb20fc5e..344e6cd312a147d1bd59986e2ac96c5aaee6dfcc 100644
--- a/src/codegen/spirv/spec.zig
+++ b/src/codegen/spirv/spec.zig
@@ -18,7 +18,7 @@ pub const IdResult = enum(Word) {
     none,
     _,
 
-    pub fn format(self: IdResult, bw: *std.io.BufferedWriter, comptime _: []const u8) anyerror!void {
+    pub fn format(self: IdResult, bw: *std.io.BufferedWriter, comptime _: []const u8) std.io.Writer.Error!void {
         switch (self) {
             .none => try bw.writeAll("(none)"),
             else => try bw.print("%{}", .{@intFromEnum(self)}),
diff --git a/src/link/Coff.zig b/src/link/Coff.zig
index 650dfe7c0fc52693c33bf3558306b9257cca07d9..2a445b02f3b8ff9fd733cd3c0d277d117e861fb5 100644
--- a/src/link/Coff.zig
+++ b/src/link/Coff.zig
@@ -3066,14 +3066,14 @@ const ImportTable = struct {
         ctx: Context,
     };
 
-    fn format(itab: ImportTable, bw: *std.io.BufferedWriter, comptime unused_format_string: []const u8) anyerror!void {
+    fn format(itab: ImportTable, bw: *std.io.BufferedWriter, comptime unused_format_string: []const u8) std.io.Writer.Error!void {
         _ = itab;
         _ = bw;
         _ = unused_format_string;
         @compileError("do not format ImportTable directly; use itab.fmtDebug()");
     }
 
-    fn format2(fmt_ctx: FormatContext, bw: *std.io.BufferedWriter, comptime unused_format_string: []const u8) anyerror!void {
+    fn format2(fmt_ctx: FormatContext, bw: *std.io.BufferedWriter, comptime unused_format_string: []const u8) std.io.Writer.Error!void {
         comptime assert(unused_format_string.len == 0);
         const lib_name = fmt_ctx.ctx.coff.temp_strtab.getAssumeExists(fmt_ctx.ctx.name_off);
         const base_vaddr = getBaseAddress(fmt_ctx.ctx);
diff --git a/src/link/Dwarf.zig b/src/link/Dwarf.zig
index 385848b7cb387326baff8304c5d8a8eea11e81d9..b8baeedc05bd1bd38983663f25c903824190945b 100644
--- a/src/link/Dwarf.zig
+++ b/src/link/Dwarf.zig
@@ -1,4 +1,4 @@
-gpa: std.mem.Allocator,
+gpa: Allocator,
 bin_file: *link.File,
 format: DW.Format,
 endian: std.builtin.Endian,
@@ -50,7 +50,7 @@ const ModInfo = struct {
     dirs: std.AutoArrayHashMapUnmanaged(Unit.Index, void),
     files: std.AutoArrayHashMapUnmanaged(Zcu.File.Index, void),
 
-    fn deinit(mod_info: *ModInfo, gpa: std.mem.Allocator) void {
+    fn deinit(mod_info: *ModInfo, gpa: Allocator) void {
         mod_info.dirs.deinit(gpa);
         mod_info.files.deinit(gpa);
         mod_info.* = undefined;
@@ -132,7 +132,7 @@ const DebugInfo = struct {
         return AbbrevCode.decl_bytes + dwarf.sectionOffsetBytes();
     }
 
-    fn declAbbrevCode(debug_info: *DebugInfo, unit: Unit.Index, entry: Entry.Index) anyerror!AbbrevCode {
+    fn declAbbrevCode(debug_info: *DebugInfo, unit: Unit.Index, entry: Entry.Index) !AbbrevCode {
         const dwarf: *Dwarf = @fieldParentPtr("debug_info", debug_info);
         const unit_ptr = debug_info.section.getUnit(unit);
         const entry_ptr = unit_ptr.getEntry(entry);
@@ -221,13 +221,13 @@ const StringSection = struct {
         .section = Section.init,
     };
 
-    fn deinit(str_sec: *StringSection, gpa: std.mem.Allocator) void {
+    fn deinit(str_sec: *StringSection, gpa: Allocator) void {
         str_sec.contents.deinit(gpa);
         str_sec.map.deinit(gpa);
         str_sec.section.deinit(gpa);
     }
 
-    fn addString(str_sec: *StringSection, dwarf: *Dwarf, str: []const u8) anyerror!Entry.Index {
+    fn addString(str_sec: *StringSection, dwarf: *Dwarf, str: []const u8) !Entry.Index {
         const gop = try str_sec.map.getOrPutAdapted(dwarf.gpa, str, Adapter{ .str_sec = str_sec });
         const entry: Entry.Index = @enumFromInt(gop.index);
         if (!gop.found_existing) {
@@ -298,7 +298,7 @@ pub const Section = struct {
         .len = 0,
     };
 
-    fn deinit(sec: *Section, gpa: std.mem.Allocator) void {
+    fn deinit(sec: *Section, gpa: Allocator) void {
         for (sec.units.items) |*unit| unit.deinit(gpa);
         sec.units.deinit(gpa);
         sec.* = undefined;
@@ -358,7 +358,7 @@ pub const Section = struct {
         if (sec.last == unit.toOptional()) sec.last = unit_ptr.prev;
     }
 
-    fn popUnit(sec: *Section, gpa: std.mem.Allocator) void {
+    fn popUnit(sec: *Section, gpa: Allocator) void {
         const unit_index: Unit.Index = @enumFromInt(sec.units.items.len - 1);
         sec.unlinkUnit(unit_index);
         var unit = sec.units.pop().?;
@@ -369,7 +369,7 @@ pub const Section = struct {
         return &sec.units.items[@intFromEnum(unit)];
     }
 
-    fn resizeEntry(sec: *Section, unit: Unit.Index, entry: Entry.Index, dwarf: *Dwarf, len: u32) anyerror!void {
+    fn resizeEntry(sec: *Section, unit: Unit.Index, entry: Entry.Index, dwarf: *Dwarf, len: u32) UpdateError!void {
         const unit_ptr = sec.getUnit(unit);
         const entry_ptr = unit_ptr.getEntry(entry);
         if (len > 0) {
@@ -390,13 +390,13 @@ pub const Section = struct {
         assert(entry_ptr.len == len);
     }
 
-    fn replaceEntry(sec: *Section, unit: Unit.Index, entry: Entry.Index, dwarf: *Dwarf, contents: []const u8) anyerror!void {
+    fn replaceEntry(sec: *Section, unit: Unit.Index, entry: Entry.Index, dwarf: *Dwarf, contents: []const u8) UpdateError!void {
         try sec.resizeEntry(unit, entry, dwarf, @intCast(contents.len));
         const unit_ptr = sec.getUnit(unit);
         try unit_ptr.getEntry(entry).replace(unit_ptr, sec, dwarf, contents);
     }
 
-    fn freeEntry(sec: *Section, unit: Unit.Index, entry: Entry.Index, dwarf: *Dwarf) anyerror!void {
+    fn freeEntry(sec: *Section, unit: Unit.Index, entry: Entry.Index, dwarf: *Dwarf) UpdateError!void {
         const unit_ptr = sec.getUnit(unit);
         const entry_ptr = unit_ptr.getEntry(entry);
         if (entry_ptr.len > 0) {
@@ -519,7 +519,7 @@ const Unit = struct {
         unit.cross_section_relocs.clearRetainingCapacity();
     }
 
-    fn deinit(unit: *Unit, gpa: std.mem.Allocator) void {
+    fn deinit(unit: *Unit, gpa: Allocator) void {
         for (unit.entries.items) |*entry| entry.deinit(gpa);
         unit.entries.deinit(gpa);
         unit.cross_unit_relocs.deinit(gpa);
@@ -527,7 +527,7 @@ const Unit = struct {
         unit.* = undefined;
     }
 
-    fn addEntry(unit: *Unit, gpa: std.mem.Allocator) std.mem.Allocator.Error!Entry.Index {
+    fn addEntry(unit: *Unit, gpa: Allocator) Allocator.Error!Entry.Index {
         if (unit.free.unwrap()) |entry| {
             const entry_ptr = unit.getEntry(entry);
             unit.free = entry_ptr.next;
@@ -782,7 +782,7 @@ const Entry = struct {
         entry.external_relocs.clearRetainingCapacity();
     }
 
-    fn deinit(entry: *Entry, gpa: std.mem.Allocator) void {
+    fn deinit(entry: *Entry, gpa: Allocator) void {
         entry.cross_entry_relocs.deinit(gpa);
         entry.cross_unit_relocs.deinit(gpa);
         entry.cross_section_relocs.deinit(gpa);
@@ -807,7 +807,7 @@ const Entry = struct {
         }
     };
 
-    fn pad(entry: *Entry, unit: *Unit, sec: *Section, dwarf: *Dwarf) anyerror!void {
+    fn pad(entry: *Entry, unit: *Unit, sec: *Section, dwarf: *Dwarf) UpdateError!void {
         assert(entry.len > 0);
         const start = entry.off + entry.len;
         if (sec == &dwarf.debug_frame.section) {
@@ -886,7 +886,7 @@ const Entry = struct {
         try dwarf.getFile().?.pwriteAll(bw.getWritten(), sec.off(dwarf) + unit.off + unit.header_len + start);
     }
 
-    fn resize(entry_ptr: *Entry, unit: *Unit, sec: *Section, dwarf: *Dwarf, len: u32) anyerror!void {
+    fn resize(entry_ptr: *Entry, unit: *Unit, sec: *Section, dwarf: *Dwarf, len: u32) UpdateError!void {
         assert(len > 0);
         assert(sec.alignment.check(len));
         if (entry_ptr.len == len) return;
@@ -1138,7 +1138,7 @@ pub const Loc = union(enum) {
         };
     }
 
-    fn writeReg(bw: *std.io.BufferedWriter, reg: u32, op0: u8, opx: u8) anyerror!void {
+    fn writeReg(bw: *std.io.BufferedWriter, reg: u32, op0: u8, opx: u8) std.io.Writer.Error!void {
         if (std.math.cast(u5, reg)) |small_reg| {
             try bw.writeByte(op0 + small_reg);
         } else {
@@ -1147,7 +1147,7 @@ pub const Loc = union(enum) {
         }
     }
 
-    fn write(loc: Loc, bw: *std.io.BufferedWriter, adapter: anytype) anyerror!void {
+    fn write(loc: Loc, bw: *std.io.BufferedWriter, adapter: anytype) UpdateError!void {
         switch (loc) {
             .empty => {},
             .addr_reloc => |sym_index| {
@@ -1312,7 +1312,7 @@ pub const Cfa = union(enum) {
     const RegOff = struct { reg: u32, off: i64 };
     const RegExpr = struct { reg: u32, expr: Loc };
 
-    fn write(cfa: Cfa, wip_nav: *WipNav) anyerror!void {
+    fn write(cfa: Cfa, wip_nav: *WipNav) UpdateError!void {
         const bw = &wip_nav.debug_frame.buffered_writer;
         switch (cfa) {
             .nop => try bw.writeByte(DW.CFA.nop),
@@ -1586,25 +1586,25 @@ pub const WipNav = struct {
         ) catch |err| return @errorCast(err);
     }
 
-    pub fn setColumn(wip_nav: *WipNav, column: u32) std.mem.Allocator.Error!void {
+    pub fn setColumn(wip_nav: *WipNav, column: u32) Allocator.Error!void {
         const dlbw = &wip_nav.debug_line.buffered_writer;
         dlbw.writeByte(DW.LNS.set_column) catch |err| return @errorCast(err);
         dlbw.writeLeb128(column + 1) catch |err| return @errorCast(err);
     }
 
-    pub fn negateStmt(wip_nav: *WipNav) std.mem.Allocator.Error!void {
+    pub fn negateStmt(wip_nav: *WipNav) Allocator.Error!void {
         return @errorCast(wip_nav.debug_line.buffered_writer.writeByte(DW.LNS.negate_stmt));
     }
 
-    pub fn setPrologueEnd(wip_nav: *WipNav) std.mem.Allocator.Error!void {
+    pub fn setPrologueEnd(wip_nav: *WipNav) Allocator.Error!void {
         return @errorCast(wip_nav.debug_line.buffered_writer.writeByte(DW.LNS.set_prologue_end));
     }
 
-    pub fn setEpilogueBegin(wip_nav: *WipNav) std.mem.Allocator.Error!void {
+    pub fn setEpilogueBegin(wip_nav: *WipNav) Allocator.Error!void {
         return @errorCast(wip_nav.debug_line.buffered_writer.writeByte(DW.LNS.set_epilogue_begin));
     }
 
-    pub fn enterBlock(wip_nav: *WipNav, code_off: u64) anyerror!void {
+    pub fn enterBlock(wip_nav: *WipNav, code_off: u64) UpdateError!void {
         const dwarf = wip_nav.dwarf;
         const dibw = &wip_nav.debug_info.buffered_writer;
         const block = try wip_nav.blocks.addOne(dwarf.gpa);
@@ -1618,7 +1618,7 @@ pub const WipNav = struct {
         wip_nav.any_children = false;
     }
 
-    pub fn leaveBlock(wip_nav: *WipNav, code_off: u64) anyerror!void {
+    pub fn leaveBlock(wip_nav: *WipNav, code_off: u64) UpdateError!void {
         const block_bytes = comptime uleb128Bytes(@intFromEnum(AbbrevCode.block));
         const block = wip_nav.blocks.pop().?;
         const dib = wip_nav.debug_info.getWritten();
@@ -1640,7 +1640,7 @@ pub const WipNav = struct {
         code_off: u64,
         line: u32,
         column: u32,
-    ) anyerror!void {
+    ) UpdateError!void {
         const dwarf = wip_nav.dwarf;
         const zcu = wip_nav.pt.zcu;
         const dibw = &wip_nav.debug_info.buffered_writer;
@@ -1659,7 +1659,7 @@ pub const WipNav = struct {
         wip_nav.any_children = false;
     }
 
-    pub fn leaveInlineFunc(wip_nav: *WipNav, func: InternPool.Index, code_off: u64) anyerror!void {
+    pub fn leaveInlineFunc(wip_nav: *WipNav, func: InternPool.Index, code_off: u64) UpdateError!void {
         const inlined_func_bytes = comptime uleb128Bytes(@intFromEnum(AbbrevCode.inlined_func));
         const block = wip_nav.blocks.pop().?;
         const dib = wip_nav.debug_info.getWritten();
@@ -1676,7 +1676,7 @@ pub const WipNav = struct {
         wip_nav.any_children = true;
     }
 
-    pub fn setInlineFunc(wip_nav: *WipNav, func: InternPool.Index) anyerror!void {
+    pub fn setInlineFunc(wip_nav: *WipNav, func: InternPool.Index) UpdateError!void {
         const zcu = wip_nav.pt.zcu;
         const dwarf = wip_nav.dwarf;
         if (wip_nav.func == func) return;
@@ -1725,19 +1725,19 @@ pub const WipNav = struct {
         wip_nav.func = func;
     }
 
-    fn externalReloc(wip_nav: *WipNav, sec: *Section, reloc: ExternalReloc) std.mem.Allocator.Error!void {
+    fn externalReloc(wip_nav: *WipNav, sec: *Section, reloc: ExternalReloc) Allocator.Error!void {
         try sec.getUnit(wip_nav.unit).getEntry(wip_nav.entry).external_relocs.append(wip_nav.dwarf.gpa, reloc);
     }
 
-    pub fn infoExternalReloc(wip_nav: *WipNav, reloc: ExternalReloc) std.mem.Allocator.Error!void {
+    pub fn infoExternalReloc(wip_nav: *WipNav, reloc: ExternalReloc) Allocator.Error!void {
         try wip_nav.externalReloc(&wip_nav.dwarf.debug_info.section, reloc);
     }
 
-    fn frameExternalReloc(wip_nav: *WipNav, reloc: ExternalReloc) std.mem.Allocator.Error!void {
+    fn frameExternalReloc(wip_nav: *WipNav, reloc: ExternalReloc) Allocator.Error!void {
         try wip_nav.externalReloc(&wip_nav.dwarf.debug_frame.section, reloc);
     }
 
-    fn abbrevCode(wip_nav: *WipNav, abbrev_code: AbbrevCode) anyerror!void {
+    fn abbrevCode(wip_nav: *WipNav, abbrev_code: AbbrevCode) UpdateError!void {
         try wip_nav.debug_info.buffered_writer.writeLeb128(try wip_nav.dwarf.refAbbrevCode(abbrev_code));
     }
 
@@ -1748,7 +1748,7 @@ pub const WipNav = struct {
         target_unit: Unit.Index,
         target_entry: Entry.Index,
         target_off: u32,
-    ) anyerror!void {
+    ) UpdateError!void {
         const dwarf = wip_nav.dwarf;
         const gpa = dwarf.gpa;
         const entry_ptr = @field(dwarf, @tagName(sec)).section.getUnit(wip_nav.unit).getEntry(wip_nav.entry);
@@ -1779,11 +1779,11 @@ pub const WipNav = struct {
         try bw.splatByteAll(0, dwarf.sectionOffsetBytes());
     }
 
-    fn infoSectionOffset(wip_nav: *WipNav, target_sec: Section.Index, target_unit: Unit.Index, target_entry: Entry.Index, target_off: u32) anyerror!void {
+    fn infoSectionOffset(wip_nav: *WipNav, target_sec: Section.Index, target_unit: Unit.Index, target_entry: Entry.Index, target_off: u32) UpdateError!void {
         try wip_nav.sectionOffset(.debug_info, target_sec, target_unit, target_entry, target_off);
     }
 
-    fn strp(wip_nav: *WipNav, str: []const u8) anyerror!void {
+    fn strp(wip_nav: *WipNav, str: []const u8) UpdateError!void {
         try wip_nav.infoSectionOffset(.debug_str, StringSection.unit, try wip_nav.dwarf.debug_str.addString(wip_nav.dwarf, str), 0);
     }
 
@@ -1807,7 +1807,7 @@ pub const WipNav = struct {
         }
     };
 
-    fn infoExprLoc(wip_nav: *WipNav, loc: Loc) anyerror!void {
+    fn infoExprLoc(wip_nav: *WipNav, loc: Loc) UpdateError!void {
         const bw = &wip_nav.debug_info.buffered_writer;
         const counter: ExprLocCounter = .init(wip_nav.dwarf);
         const start = bw.count;
@@ -1821,10 +1821,10 @@ pub const WipNav = struct {
             fn endian(ctx: @This()) std.builtin.Endian {
                 return ctx.wip_nav.dwarf.endian;
             }
-            fn addrSym(ctx: @This(), _: *std.io.BufferedWriter, sym_index: u32) anyerror!void {
+            fn addrSym(ctx: @This(), _: *std.io.BufferedWriter, sym_index: u32) UpdateError!void {
                 try ctx.wip_nav.infoAddrSym(sym_index, 0);
             }
-            fn infoEntry(ctx: @This(), _: *std.io.BufferedWriter, unit: Unit.Index, entry: Entry.Index) anyerror!void {
+            fn infoEntry(ctx: @This(), _: *std.io.BufferedWriter, unit: Unit.Index, entry: Entry.Index) UpdateError!void {
                 try ctx.wip_nav.infoSectionOffset(.debug_info, unit, entry, 0);
             }
         } = .{ .wip_nav = wip_nav };
@@ -1832,7 +1832,7 @@ pub const WipNav = struct {
         try loc.write(bw, adapter);
     }
 
-    fn infoAddrSym(wip_nav: *WipNav, sym_index: u32, sym_off: u64) anyerror!void {
+    fn infoAddrSym(wip_nav: *WipNav, sym_index: u32, sym_off: u64) UpdateError!void {
         const dibw = &wip_nav.debug_info.buffered_writer;
         try wip_nav.infoExternalReloc(.{
             .source_off = @intCast(dibw.count),
@@ -1856,10 +1856,10 @@ pub const WipNav = struct {
             fn endian(ctx: @This()) std.builtin.Endian {
                 return ctx.wip_nav.dwarf.endian;
             }
-            fn addrSym(ctx: @This(), _: *std.io.BufferedWriter, sym_index: u32) anyerror!void {
+            fn addrSym(ctx: @This(), _: *std.io.BufferedWriter, sym_index: u32) UpdateError!void {
                 try ctx.wip_nav.frameAddrSym(sym_index, 0);
             }
-            fn infoEntry(ctx: @This(), _: *std.io.BufferedWriter, unit: Unit.Index, entry: Entry.Index) anyerror!void {
+            fn infoEntry(ctx: @This(), _: *std.io.BufferedWriter, unit: Unit.Index, entry: Entry.Index) UpdateError!void {
                 try ctx.wip_nav.sectionOffset(.debug_frame, .debug_info, unit, entry, 0);
             }
         } = .{ .wip_nav = wip_nav };
@@ -1867,7 +1867,7 @@ pub const WipNav = struct {
         try loc.write(bw, adapter);
     }
 
-    fn frameAddrSym(wip_nav: *WipNav, sym_index: u32, sym_off: u64) anyerror!void {
+    fn frameAddrSym(wip_nav: *WipNav, sym_index: u32, sym_off: u64) UpdateError!void {
         const dfbw = &wip_nav.debug_frame.buffered_writer;
         try wip_nav.frameExternalReloc(.{
             .source_off = @intCast(dfbw.count),
@@ -1877,7 +1877,7 @@ pub const WipNav = struct {
         try dfbw.splatByteAll(0, @intFromEnum(wip_nav.dwarf.address_size));
     }
 
-    fn getNavEntry(wip_nav: *WipNav, nav_index: InternPool.Nav.Index) anyerror!struct { Unit.Index, Entry.Index } {
+    fn getNavEntry(wip_nav: *WipNav, nav_index: InternPool.Nav.Index) UpdateError!struct { Unit.Index, Entry.Index } {
         const zcu = wip_nav.pt.zcu;
         const ip = &zcu.intern_pool;
         const nav = ip.getNav(nav_index);
@@ -1889,12 +1889,12 @@ pub const WipNav = struct {
         return .{ unit, entry };
     }
 
-    fn refNav(wip_nav: *WipNav, nav_index: InternPool.Nav.Index) anyerror!void {
+    fn refNav(wip_nav: *WipNav, nav_index: InternPool.Nav.Index) UpdateError!void {
         const unit, const entry = try wip_nav.getNavEntry(nav_index);
         try wip_nav.infoSectionOffset(.debug_info, unit, entry, 0);
     }
 
-    fn getTypeEntry(wip_nav: *WipNav, ty: Type) anyerror!struct { Unit.Index, Entry.Index } {
+    fn getTypeEntry(wip_nav: *WipNav, ty: Type) UpdateError!struct { Unit.Index, Entry.Index } {
         const zcu = wip_nav.pt.zcu;
         const ip = &zcu.intern_pool;
         const maybe_inst_index = ty.typeDeclInst(zcu);
@@ -1916,12 +1916,12 @@ pub const WipNav = struct {
         return .{ unit, entry };
     }
 
-    fn refType(wip_nav: *WipNav, ty: Type) anyerror!void {
+    fn refType(wip_nav: *WipNav, ty: Type) UpdateError!void {
         const unit, const entry = try wip_nav.getTypeEntry(ty);
         try wip_nav.infoSectionOffset(.debug_info, unit, entry, 0);
     }
 
-    fn getValueEntry(wip_nav: *WipNav, value: Value) anyerror!struct { Unit.Index, Entry.Index } {
+    fn getValueEntry(wip_nav: *WipNav, value: Value) UpdateError!struct { Unit.Index, Entry.Index } {
         const zcu = wip_nav.pt.zcu;
         const ip = &zcu.intern_pool;
         const ty = value.typeOf(zcu);
@@ -1937,12 +1937,12 @@ pub const WipNav = struct {
         return .{ unit, entry };
     }
 
-    fn refValue(wip_nav: *WipNav, value: Value) anyerror!void {
+    fn refValue(wip_nav: *WipNav, value: Value) UpdateError!void {
         const unit, const entry = try wip_nav.getValueEntry(value);
         try wip_nav.infoSectionOffset(.debug_info, unit, entry, 0);
     }
 
-    fn refForward(wip_nav: *WipNav) anyerror!u32 {
+    fn refForward(wip_nav: *WipNav) Allocator.Error!u32 {
         const dwarf = wip_nav.dwarf;
         const dibw = &wip_nav.debug_info.buffered_writer;
         const cross_entry_relocs = &dwarf.debug_info.section.getUnit(wip_nav.unit).getEntry(wip_nav.entry).cross_entry_relocs;
@@ -1962,7 +1962,7 @@ pub const WipNav = struct {
         reloc.target_off = @intCast(wip_nav.debug_info.buffered_writer.count);
     }
 
-    fn blockValue(wip_nav: *WipNav, src_loc: Zcu.LazySrcLoc, val: Value) anyerror!void {
+    fn blockValue(wip_nav: *WipNav, src_loc: Zcu.LazySrcLoc, val: Value) UpdateError!void {
         const ty = val.typeOf(wip_nav.pt.zcu);
         const dibw = &wip_nav.debug_info.buffered_writer;
         const bytes = if (ty.hasRuntimeBits(wip_nav.pt.zcu)) ty.abiSize(wip_nav.pt.zcu) else 0;
@@ -1996,7 +1996,7 @@ pub const WipNav = struct {
         abbrev_code: AbbrevCodeForForm,
         ty: Type,
         big_int: std.math.big.int.Const,
-    ) anyerror!void {
+    ) UpdateError!void {
         const zcu = wip_nav.pt.zcu;
         const dibw = &wip_nav.debug_info.buffered_writer;
         const signedness = switch (ty.toIntern()) {
@@ -2045,7 +2045,7 @@ pub const WipNav = struct {
         loaded_enum: InternPool.LoadedEnumType,
         abbrev_code: AbbrevCodeForForm,
         field_index: usize,
-    ) anyerror!void {
+    ) UpdateError!void {
         const zcu = wip_nav.pt.zcu;
         const ip = &zcu.intern_pool;
         var big_int_space: Value.BigIntSpace = undefined;
@@ -2065,7 +2065,7 @@ pub const WipNav = struct {
         nav: *const InternPool.Nav,
         file: Zcu.File.Index,
         decl: *const std.zig.Zir.Inst.Declaration.Unwrapped,
-    ) anyerror!void {
+    ) UpdateError!void {
         const zcu = wip_nav.pt.zcu;
         const ip = &zcu.intern_pool;
         const dwarf = wip_nav.dwarf;
@@ -2143,7 +2143,7 @@ pub const WipNav = struct {
         const empty: PendingLazy = .{ .types = .empty, .values = .empty };
     };
 
-    fn updateLazy(wip_nav: *WipNav, src_loc: Zcu.LazySrcLoc) anyerror!void {
+    fn updateLazy(wip_nav: *WipNav, src_loc: Zcu.LazySrcLoc) UpdateError!void {
         while (true) if (wip_nav.pending_lazy.types.pop()) |pending_ty|
             try wip_nav.dwarf.updateLazyType(wip_nav.pt, src_loc, pending_ty, &wip_nav.pending_lazy)
         else if (wip_nav.pending_lazy.values.pop()) |pending_val|
@@ -2366,7 +2366,7 @@ pub fn deinit(dwarf: *Dwarf) void {
     dwarf.* = undefined;
 }
 
-fn getUnit(dwarf: *Dwarf, mod: *Module) anyerror!Unit.Index {
+fn getUnit(dwarf: *Dwarf, mod: *Module) !Unit.Index {
     const mod_gop = try dwarf.mods.getOrPut(dwarf.gpa, mod);
     const unit: Unit.Index = @enumFromInt(mod_gop.index);
     if (!mod_gop.found_existing) {
@@ -2494,7 +2494,7 @@ fn initWipNavInner(
     pt: Zcu.PerThread,
     nav_index: InternPool.Nav.Index,
     sym_index: u32,
-) anyerror!?WipNav {
+) !?WipNav {
     const zcu = pt.zcu;
     const ip = &zcu.intern_pool;
 
@@ -2702,7 +2702,7 @@ fn finishWipNavFuncInner(
     nav_index: InternPool.Nav.Index,
     code_size: u64,
     wip_nav: *WipNav,
-) anyerror!void {
+) UpdateError!void {
     const zcu = pt.zcu;
     const ip = &zcu.intern_pool;
     const nav = ip.getNav(nav_index);
@@ -2802,7 +2802,7 @@ fn finishWipNavInner(
     pt: Zcu.PerThread,
     nav_index: InternPool.Nav.Index,
     wip_nav: *WipNav,
-) anyerror!void {
+) UpdateError!void {
     const zcu = pt.zcu;
     const ip = &zcu.intern_pool;
     const nav = ip.getNav(nav_index);
@@ -2822,7 +2822,7 @@ fn finishWipNavInner(
     try wip_nav.updateLazy(zcu.navSrcLoc(nav_index));
 }
 
-fn updateComptimeNavInner(dwarf: *Dwarf, pt: Zcu.PerThread, nav_index: InternPool.Nav.Index) anyerror!void {
+fn updateComptimeNavInner(dwarf: *Dwarf, pt: Zcu.PerThread, nav_index: InternPool.Nav.Index) !void {
     const zcu = pt.zcu;
     const ip = &zcu.intern_pool;
     const nav_src_loc = zcu.navSrcLoc(nav_index);
@@ -3276,7 +3276,7 @@ fn updateLazyType(
     src_loc: Zcu.LazySrcLoc,
     type_index: InternPool.Index,
     pending_lazy: *WipNav.PendingLazy,
-) anyerror!void {
+) UpdateError!void {
     const zcu = pt.zcu;
     const ip = &zcu.intern_pool;
     assert(ip.typeOf(type_index) == .type_type);
@@ -3783,7 +3783,7 @@ fn updateLazyValue(
     src_loc: Zcu.LazySrcLoc,
     value_index: InternPool.Index,
     pending_lazy: *WipNav.PendingLazy,
-) anyerror!void {
+) UpdateError!void {
     const zcu = pt.zcu;
     const ip = &zcu.intern_pool;
     assert(ip.typeOf(value_index) != .type_type);
@@ -4175,7 +4175,7 @@ fn optRepr(opt_child_type: Type, zcu: *const Zcu) enum {
     };
 }
 
-fn updateContainerTypeInner(dwarf: *Dwarf, pt: Zcu.PerThread, type_index: InternPool.Index) anyerror!void {
+fn updateContainerTypeInner(dwarf: *Dwarf, pt: Zcu.PerThread, type_index: InternPool.Index) UpdateError!void {
     const zcu = pt.zcu;
     const ip = &zcu.intern_pool;
     const ty: Type = .fromInterned(type_index);
@@ -4498,7 +4498,7 @@ pub fn freeNav(dwarf: *Dwarf, nav_index: InternPool.Nav.Index) void {
     _ = nav_index;
 }
 
-fn refAbbrevCode(dwarf: *Dwarf, abbrev_code: AbbrevCode) anyerror!@typeInfo(AbbrevCode).@"enum".tag_type {
+fn refAbbrevCode(dwarf: *Dwarf, abbrev_code: AbbrevCode) UpdateError!@typeInfo(AbbrevCode).@"enum".tag_type {
     assert(abbrev_code != .null);
     const entry: Entry.Index = @enumFromInt(@intFromEnum(abbrev_code));
     if (dwarf.debug_abbrev.section.getUnit(DebugAbbrev.unit).getEntry(entry).len > 0) return @intFromEnum(abbrev_code);
@@ -6063,7 +6063,7 @@ fn addCommonEntry(dwarf: *Dwarf, unit: Unit.Index) UpdateError!Entry.Index {
     return entry;
 }
 
-fn freeCommonEntry(dwarf: *Dwarf, unit: Unit.Index, entry: Entry.Index) anyerror!void {
+fn freeCommonEntry(dwarf: *Dwarf, unit: Unit.Index, entry: Entry.Index) UpdateError!void {
     try dwarf.debug_aranges.section.freeEntry(unit, entry, dwarf);
     try dwarf.debug_frame.section.freeEntry(unit, entry, dwarf);
     try dwarf.debug_info.section.freeEntry(unit, entry, dwarf);
@@ -6082,7 +6082,7 @@ fn writeInt(dwarf: *Dwarf, buf: []u8, int: u64) void {
     }
 }
 
-fn writeIntTo(dwarf: *Dwarf, bw: *std.io.BufferedWriter, len: usize, int: u64) anyerror!void {
+fn writeIntTo(dwarf: *Dwarf, bw: *std.io.BufferedWriter, len: usize, int: u64) !void {
     dwarf.writeInt((try bw.writableSlice(len))[0..len], int);
     bw.advance(len);
 }
@@ -6159,3 +6159,4 @@ const link = @import("../link.zig");
 const log = std.log.scoped(.dwarf);
 const std = @import("std");
 const target_info = @import("../target.zig");
+const Allocator = std.mem.Allocator;
diff --git a/src/link/Elf.zig b/src/link/Elf.zig
index a510a30dbaa5afd403742733d5bf6d9205be428f..14e8c03392105931fe769a5ed96d5781d2ac89df 100644
--- a/src/link/Elf.zig
+++ b/src/link/Elf.zig
@@ -2996,7 +2996,7 @@ fn allocateSpecialPhdrs(self: *Elf) void {
     }
 }
 
-fn writeAtoms(self: *Elf) anyerror!void {
+fn writeAtoms(self: *Elf) !void {
     const gpa = self.base.comp.gpa;
 
     var undefs: std.AutoArrayHashMap(SymbolResolver.Index, std.ArrayList(Ref)) = .init(gpa);
@@ -3130,7 +3130,7 @@ pub fn updateSymtabSize(self: *Elf) !void {
     strtab.sh_size = strsize + 1;
 }
 
-fn writeSyntheticSections(self: *Elf) anyerror!void {
+fn writeSyntheticSections(self: *Elf) !void {
     const gpa = self.base.comp.gpa;
     const slice = self.sections.slice();
 
@@ -3883,7 +3883,7 @@ fn fmtShdr(self: *Elf, shdr: elf.Elf64_Shdr) std.fmt.Formatter(formatShdr) {
     } };
 }
 
-fn formatShdr(ctx: FormatShdrCtx, bw: *std.io.BufferedWriter, comptime unused_fmt_string: []const u8) anyerror!void {
+fn formatShdr(ctx: FormatShdrCtx, bw: *std.io.BufferedWriter, comptime unused_fmt_string: []const u8) std.io.Writer.Error!void {
     _ = unused_fmt_string;
     const shdr = ctx.shdr;
     try bw.print("{s} : @{x} ({x}) : align({x}) : size({x}) : entsize({x}) : flags({f})", .{
@@ -4216,7 +4216,7 @@ pub const Ref = struct {
         return ref.index == other.index and ref.file == other.file;
     }
 
-    pub fn format(ref: Ref, bw: *std.io.BufferedWriter, comptime unused_fmt_string: []const u8) anyerror!void {
+    pub fn format(ref: Ref, bw: *std.io.BufferedWriter, comptime unused_fmt_string: []const u8) std.io.Writer.Error!void {
         _ = unused_fmt_string;
         try bw.print("ref({},{})", .{ ref.index, ref.file });
     }
diff --git a/src/link/Elf/Archive.zig b/src/link/Elf/Archive.zig
index 930bf267740630a82a5336274ee543da7f71b69f..6e0c8ca8aafad7b7968ed92f08c7e42deee5c93e 100644
--- a/src/link/Elf/Archive.zig
+++ b/src/link/Elf/Archive.zig
@@ -184,7 +184,7 @@ pub const ArSymtab = struct {
         }
     }
 
-    pub fn format(ar: ArSymtab, bw: *std.io.BufferedWriter, comptime unused_fmt_string: []const u8) anyerror!void {
+    pub fn format(ar: ArSymtab, bw: *std.io.BufferedWriter, comptime unused_fmt_string: []const u8) std.io.Writer.Error!void {
         _ = ar;
         _ = bw;
         _ = unused_fmt_string;
@@ -203,7 +203,7 @@ pub const ArSymtab = struct {
         } };
     }
 
-    fn format2(ctx: FormatContext, bw: *std.io.BufferedWriter, comptime unused_fmt_string: []const u8) anyerror!void {
+    fn format2(ctx: FormatContext, bw: *std.io.BufferedWriter, comptime unused_fmt_string: []const u8) std.io.Writer.Error!void {
         _ = unused_fmt_string;
         const ar = ctx.ar;
         const elf_file = ctx.elf_file;
@@ -251,7 +251,7 @@ pub const ArStrtab = struct {
         try writer.writeAll(ar.buffer.items);
     }
 
-    pub fn format(ar: ArStrtab, bw: *std.io.BufferedWriter, comptime unused_fmt_string: []const u8) anyerror!void {
+    pub fn format(ar: ArStrtab, bw: *std.io.BufferedWriter, comptime unused_fmt_string: []const u8) std.io.Writer.Error!void {
         _ = unused_fmt_string;
         try bw.print("{f}", .{std.fmt.fmtSliceEscapeLower(ar.buffer.items)});
     }
diff --git a/src/link/Elf/Atom.zig b/src/link/Elf/Atom.zig
index 8ed6171dfdc108d404c6fc55227f3f7b14c5fecd..c44f8a53727e3d0b06cd2c24f103c044346b4a24 100644
--- a/src/link/Elf/Atom.zig
+++ b/src/link/Elf/Atom.zig
@@ -908,7 +908,7 @@ pub fn setExtra(atom: Atom, extras: Extra, elf_file: *Elf) void {
     atom.file(elf_file).?.setAtomExtra(atom.extra_index, extras);
 }
 
-pub fn format(atom: Atom, bw: *std.io.BufferedWriter, comptime unused_fmt_string: []const u8) anyerror!void {
+pub fn format(atom: Atom, bw: *std.io.BufferedWriter, comptime unused_fmt_string: []const u8) std.io.Writer.Error!void {
     _ = atom;
     _ = bw;
     _ = unused_fmt_string;
@@ -927,7 +927,7 @@ const FormatContext = struct {
     elf_file: *Elf,
 };
 
-fn format2(ctx: FormatContext, bw: *std.io.BufferedWriter, comptime unused_fmt_string: []const u8) anyerror!void {
+fn format2(ctx: FormatContext, bw: *std.io.BufferedWriter, comptime unused_fmt_string: []const u8) std.io.Writer.Error!void {
     _ = unused_fmt_string;
     const atom = ctx.atom;
     const elf_file = ctx.elf_file;
@@ -1080,7 +1080,7 @@ const x86_64 = struct {
         args: ResolveArgs,
         it: *RelocsIterator,
         bw: *std.io.BufferedWriter,
-    ) anyerror!void {
+    ) std.io.Writer.Error!void {
         dev.check(.x86_64_backend);
         const t = &elf_file.base.comp.root_mod.resolved_target.result;
         const diags = &elf_file.base.comp.link_diags;
@@ -1212,7 +1212,7 @@ const x86_64 = struct {
         target: *const Symbol,
         args: ResolveArgs,
         bw: *std.io.BufferedWriter,
-    ) anyerror!void {
+    ) std.io.Writer.Error!void {
         dev.check(.x86_64_backend);
 
         const r_type: elf.R_X86_64 = @enumFromInt(rel.r_type());
@@ -1593,7 +1593,7 @@ const aarch64 = struct {
         args: ResolveArgs,
         it: *RelocsIterator,
         bw: *std.io.BufferedWriter,
-    ) anyerror!void {
+    ) std.io.Writer.Error!void {
         _ = it;
 
         const diags = &elf_file.base.comp.link_diags;
@@ -2004,7 +2004,7 @@ const riscv = struct {
         target: *const Symbol,
         args: ResolveArgs,
         bw: *std.io.BufferedWriter,
-    ) anyerror!void {
+    ) std.io.Writer.Error!void {
         const r_type: elf.R_RISCV = @enumFromInt(rel.r_type());
 
         _, const A, const S, const GOT, _, _, const DTP = args;
diff --git a/src/link/Elf/AtomList.zig b/src/link/Elf/AtomList.zig
index 2f70a29f273ae8e3e0a78ccba13975598c38d49a..0271cd6c4adf80433765f2865e0de82fa421ed7b 100644
--- a/src/link/Elf/AtomList.zig
+++ b/src/link/Elf/AtomList.zig
@@ -167,7 +167,7 @@ pub fn lastAtom(list: AtomList, elf_file: *Elf) *Atom {
     return elf_file.atom(list.atoms.keys()[list.atoms.keys().len - 1]).?;
 }
 
-pub fn format(list: AtomList, bw: *std.io.BufferedWriter, comptime unused_fmt_string: []const u8) anyerror!void {
+pub fn format(list: AtomList, bw: *std.io.BufferedWriter, comptime unused_fmt_string: []const u8) std.io.Writer.Error!void {
     _ = list;
     _ = bw;
     _ = unused_fmt_string;
@@ -180,7 +180,7 @@ pub fn fmt(list: AtomList, elf_file: *Elf) std.fmt.Formatter(format2) {
     return .{ .data = .{ list, elf_file } };
 }
 
-fn format2(ctx: FormatCtx, bw: *std.io.BufferedWriter, comptime unused_fmt_string: []const u8) anyerror!void {
+fn format2(ctx: FormatCtx, bw: *std.io.BufferedWriter, comptime unused_fmt_string: []const u8) std.io.Writer.Error!void {
     _ = unused_fmt_string;
     const list, const elf_file = ctx;
     try bw.print("list : @{x} : shdr({d}) : align({x}) : size({x})", .{
diff --git a/src/link/Elf/LinkerDefined.zig b/src/link/Elf/LinkerDefined.zig
index 80d599ca2c2b6dd67f4872983dd6943b453ff396..871150a945aedda6825fcee47c4b41c8e55aa6b4 100644
--- a/src/link/Elf/LinkerDefined.zig
+++ b/src/link/Elf/LinkerDefined.zig
@@ -449,7 +449,7 @@ const FormatContext = struct {
     elf_file: *Elf,
 };
 
-fn formatSymtab(ctx: FormatContext, bw: *std.io.BufferedWriter, comptime unused_fmt_string: []const u8) anyerror!void {
+fn formatSymtab(ctx: FormatContext, bw: *std.io.BufferedWriter, comptime unused_fmt_string: []const u8) std.io.Writer.Error!void {
     _ = unused_fmt_string;
     const self = ctx.self;
     const elf_file = ctx.elf_file;
diff --git a/src/link/Elf/Merge.zig b/src/link/Elf/Merge.zig
index be019856827f61a9f403bfe574587dbfb8445f48..27a4f26a2a640f0d3de16cff3244247fd3415a7c 100644
--- a/src/link/Elf/Merge.zig
+++ b/src/link/Elf/Merge.zig
@@ -157,7 +157,7 @@ pub const Section = struct {
         }
     };
 
-    pub fn format(msec: Section, bw: *std.io.BufferedWriter, comptime unused_fmt_string: []const u8) anyerror!void {
+    pub fn format(msec: Section, bw: *std.io.BufferedWriter, comptime unused_fmt_string: []const u8) std.io.Writer.Error!void {
         _ = msec;
         _ = bw;
         _ = unused_fmt_string;
@@ -176,7 +176,7 @@ pub const Section = struct {
         elf_file: *Elf,
     };
 
-    pub fn format2(ctx: FormatContext, bw: *std.io.BufferedWriter, comptime unused_fmt_string: []const u8) anyerror!void {
+    pub fn format2(ctx: FormatContext, bw: *std.io.BufferedWriter, comptime unused_fmt_string: []const u8) std.io.Writer.Error!void {
         _ = unused_fmt_string;
         const msec = ctx.msec;
         const elf_file = ctx.elf_file;
@@ -219,7 +219,7 @@ pub const Subsection = struct {
         return msec.bytes.items[msub.string_index..][0..msub.size];
     }
 
-    pub fn format(msub: Subsection, bw: *std.io.BufferedWriter, comptime unused_fmt_string: []const u8) anyerror!void {
+    pub fn format(msub: Subsection, bw: *std.io.BufferedWriter, comptime unused_fmt_string: []const u8) std.io.Writer.Error!void {
         _ = msub;
         _ = bw;
         _ = unused_fmt_string;
@@ -238,7 +238,7 @@ pub const Subsection = struct {
         elf_file: *Elf,
     };
 
-    pub fn format2(ctx: FormatContext, bw: *std.io.BufferedWriter, comptime unused_fmt_string: []const u8) anyerror!void {
+    pub fn format2(ctx: FormatContext, bw: *std.io.BufferedWriter, comptime unused_fmt_string: []const u8) std.io.Writer.Error!void {
         _ = unused_fmt_string;
         const msub = ctx.msub;
         const elf_file = ctx.elf_file;
diff --git a/src/link/Elf/Object.zig b/src/link/Elf/Object.zig
index 7cb17f01f6d9188437b3a71256cccd08b5a61ec1..1c1b8e11f75e7f26a5606db16832740238aaea8e 100644
--- a/src/link/Elf/Object.zig
+++ b/src/link/Elf/Object.zig
@@ -1431,7 +1431,7 @@ pub fn group(self: *Object, index: Elf.Group.Index) *Elf.Group {
     return &self.groups.items[index];
 }
 
-pub fn format(self: *Object, bw: *std.io.BufferedWriter, comptime unused_fmt_string: []const u8) anyerror!void {
+pub fn format(self: *Object, bw: *std.io.BufferedWriter, comptime unused_fmt_string: []const u8) std.io.Writer.Error!void {
     _ = self;
     _ = bw;
     _ = unused_fmt_string;
@@ -1450,7 +1450,7 @@ const FormatContext = struct {
     elf_file: *Elf,
 };
 
-fn formatSymtab(ctx: FormatContext, bw: *std.io.BufferedWriter, comptime unused_fmt_string: []const u8) anyerror!void {
+fn formatSymtab(ctx: FormatContext, bw: *std.io.BufferedWriter, comptime unused_fmt_string: []const u8) std.io.Writer.Error!void {
     _ = unused_fmt_string;
     const object = ctx.object;
     const elf_file = ctx.elf_file;
@@ -1477,7 +1477,7 @@ pub fn fmtAtoms(self: *Object, elf_file: *Elf) std.fmt.Formatter(formatAtoms) {
     } };
 }
 
-fn formatAtoms(ctx: FormatContext, bw: *std.io.BufferedWriter, comptime unused_fmt_string: []const u8) anyerror!void {
+fn formatAtoms(ctx: FormatContext, bw: *std.io.BufferedWriter, comptime unused_fmt_string: []const u8) std.io.Writer.Error!void {
     _ = unused_fmt_string;
     const object = ctx.object;
     try bw.writeAll("  atoms\n");
@@ -1494,7 +1494,7 @@ pub fn fmtCies(self: *Object, elf_file: *Elf) std.fmt.Formatter(formatCies) {
     } };
 }
 
-fn formatCies(ctx: FormatContext, bw: *std.io.BufferedWriter, comptime unused_fmt_string: []const u8) anyerror!void {
+fn formatCies(ctx: FormatContext, bw: *std.io.BufferedWriter, comptime unused_fmt_string: []const u8) std.io.Writer.Error!void {
     _ = unused_fmt_string;
     const object = ctx.object;
     try bw.writeAll("  cies\n");
@@ -1510,7 +1510,7 @@ pub fn fmtFdes(self: *Object, elf_file: *Elf) std.fmt.Formatter(formatFdes) {
     } };
 }
 
-fn formatFdes(ctx: FormatContext, bw: *std.io.BufferedWriter, comptime unused_fmt_string: []const u8) anyerror!void {
+fn formatFdes(ctx: FormatContext, bw: *std.io.BufferedWriter, comptime unused_fmt_string: []const u8) std.io.Writer.Error!void {
     _ = unused_fmt_string;
     const object = ctx.object;
     try bw.writeAll("  fdes\n");
@@ -1526,8 +1526,8 @@ pub fn fmtGroups(self: *Object, elf_file: *Elf) std.fmt.Formatter(formatGroups)
     } };
 }
 
-fn formatGroups(ctx: FormatContext, bw: *std.io.BufferedWriter, comptime unused_fmt_string: []const u8) anyerror!void {
-    _ = unused_fmt_string;
+fn formatGroups(ctx: FormatContext, bw: *std.io.BufferedWriter, comptime unused_fmt_string: []const u8) std.io.Writer.Error!void {
+    comptime assert(unused_fmt_string.len == 0);
     const object = ctx.object;
     const elf_file = ctx.elf_file;
     try bw.writeAll("  groups\n");
@@ -1548,7 +1548,7 @@ pub fn fmtPath(self: Object) std.fmt.Formatter(formatPath) {
     return .{ .data = self };
 }
 
-fn formatPath(object: Object, bw: *std.io.BufferedWriter, comptime unused_fmt_string: []const u8) anyerror!void {
+fn formatPath(object: Object, bw: *std.io.BufferedWriter, comptime unused_fmt_string: []const u8) std.io.Writer.Error!void {
     _ = unused_fmt_string;
     if (object.archive) |ar| {
         try bw.print("{f}({f})", .{ ar.path, object.path });
diff --git a/src/link/Elf/SharedObject.zig b/src/link/Elf/SharedObject.zig
index 298670c8398230a64c6bbca3025dbcb2ed54708c..d2baaf11d608bbc4e0f0640fbab6637e1fa21800 100644
--- a/src/link/Elf/SharedObject.zig
+++ b/src/link/Elf/SharedObject.zig
@@ -509,7 +509,7 @@ pub fn setSymbolExtra(self: *SharedObject, index: u32, extra: Symbol.Extra) void
     }
 }
 
-pub fn format(self: SharedObject, bw: *std.io.BufferedWriter, comptime unused_fmt_string: []const u8) anyerror!void {
+pub fn format(self: SharedObject, bw: *std.io.BufferedWriter, comptime unused_fmt_string: []const u8) std.io.Writer.Error!void {
     _ = self;
     _ = bw;
     _ = unused_fmt_string;
@@ -528,7 +528,7 @@ const FormatContext = struct {
     elf_file: *Elf,
 };
 
-fn formatSymtab(ctx: FormatContext, bw: *std.io.BufferedWriter, comptime unused_fmt_string: []const u8) anyerror!void {
+fn formatSymtab(ctx: FormatContext, bw: *std.io.BufferedWriter, comptime unused_fmt_string: []const u8) std.io.Writer.Error!void {
     _ = unused_fmt_string;
     const shared = ctx.shared;
     const elf_file = ctx.elf_file;
diff --git a/src/link/Elf/Symbol.zig b/src/link/Elf/Symbol.zig
index 6c5e0c55e65a2efa2963eb15f4cd0842e07266be..1bb70a5c05624f1f4af9d22a4bbd0d9cc9b4b260 100644
--- a/src/link/Elf/Symbol.zig
+++ b/src/link/Elf/Symbol.zig
@@ -316,7 +316,7 @@ pub fn setOutputSym(symbol: Symbol, elf_file: *Elf, out: *elf.Elf64_Sym) void {
     out.st_size = esym.st_size;
 }
 
-pub fn format(symbol: Symbol, bw: *std.io.BufferedWriter, comptime unused_fmt_string: []const u8) anyerror!void {
+pub fn format(symbol: Symbol, bw: *std.io.BufferedWriter, comptime unused_fmt_string: []const u8) std.io.Writer.Error!void {
     _ = symbol;
     _ = bw;
     _ = unused_fmt_string;
@@ -335,7 +335,7 @@ pub fn fmtName(symbol: Symbol, elf_file: *Elf) std.fmt.Formatter(formatName) {
     } };
 }
 
-fn formatName(ctx: FormatContext, bw: *std.io.BufferedWriter, comptime unused_fmt_string: []const u8) anyerror!void {
+fn formatName(ctx: FormatContext, bw: *std.io.BufferedWriter, comptime unused_fmt_string: []const u8) std.io.Writer.Error!void {
     _ = unused_fmt_string;
     const elf_file = ctx.elf_file;
     const symbol = ctx.symbol;
@@ -358,7 +358,7 @@ pub fn fmt(symbol: Symbol, elf_file: *Elf) std.fmt.Formatter(format2) {
     } };
 }
 
-fn format2(ctx: FormatContext, bw: *std.io.BufferedWriter, comptime unused_fmt_string: []const u8) anyerror!void {
+fn format2(ctx: FormatContext, bw: *std.io.BufferedWriter, comptime unused_fmt_string: []const u8) std.io.Writer.Error!void {
     _ = unused_fmt_string;
     const symbol = ctx.symbol;
     const elf_file = ctx.elf_file;
diff --git a/src/link/Elf/Thunk.zig b/src/link/Elf/Thunk.zig
index c5ddce75423d877a8df3b32819012bd41b5a0d40..b8b19164e7a9dc708621c2ebfebe0621929aacd3 100644
--- a/src/link/Elf/Thunk.zig
+++ b/src/link/Elf/Thunk.zig
@@ -65,7 +65,7 @@ fn trampolineSize(cpu_arch: std.Target.Cpu.Arch) usize {
     };
 }
 
-pub fn format(thunk: Thunk, bw: *std.io.BufferedWriter, comptime unused_fmt_string: []const u8) anyerror!void {
+pub fn format(thunk: Thunk, bw: *std.io.BufferedWriter, comptime unused_fmt_string: []const u8) std.io.Writer.Error!void {
     _ = thunk;
     _ = bw;
     _ = unused_fmt_string;
@@ -84,7 +84,7 @@ const FormatContext = struct {
     elf_file: *Elf,
 };
 
-fn format2(ctx: FormatContext, bw: *std.io.BufferedWriter, comptime unused_fmt_string: []const u8) anyerror!void {
+fn format2(ctx: FormatContext, bw: *std.io.BufferedWriter, comptime unused_fmt_string: []const u8) std.io.Writer.Error!void {
     _ = unused_fmt_string;
     const thunk = ctx.thunk;
     const elf_file = ctx.elf_file;
diff --git a/src/link/Elf/ZigObject.zig b/src/link/Elf/ZigObject.zig
index 7bf293f14474519e606b2f024ad5c1bd8195d1b0..0881d4696c41b9897ca91d58a8ce6d04b75b4a92 100644
--- a/src/link/Elf/ZigObject.zig
+++ b/src/link/Elf/ZigObject.zig
@@ -2198,7 +2198,7 @@ const FormatContext = struct {
     elf_file: *Elf,
 };
 
-fn formatSymtab(ctx: FormatContext, bw: *std.io.BufferedWriter, comptime unused_fmt_string: []const u8) anyerror!void {
+fn formatSymtab(ctx: FormatContext, bw: *std.io.BufferedWriter, comptime unused_fmt_string: []const u8) std.io.Writer.Error!void {
     _ = unused_fmt_string;
     const self = ctx.self;
     const elf_file = ctx.elf_file;
@@ -2221,7 +2221,7 @@ pub fn fmtAtoms(self: *ZigObject, elf_file: *Elf) std.fmt.Formatter(formatAtoms)
     } };
 }
 
-fn formatAtoms(ctx: FormatContext, bw: *std.io.BufferedWriter, comptime unused_fmt_string: []const u8) anyerror!void {
+fn formatAtoms(ctx: FormatContext, bw: *std.io.BufferedWriter, comptime unused_fmt_string: []const u8) std.io.Writer.Error!void {
     _ = unused_fmt_string;
     try bw.writeAll("  atoms\n");
     for (ctx.self.atoms_indexes.items) |atom_index| {
diff --git a/src/link/Elf/file.zig b/src/link/Elf/file.zig
index c6c9aea6b3f3f381f22e8a8dbb6956efcc6b0ffb..d007942dd17c76c8c2c77b6aaab0ba9d691c7382 100644
--- a/src/link/Elf/file.zig
+++ b/src/link/Elf/file.zig
@@ -14,7 +14,7 @@ pub const File = union(enum) {
         return .{ .data = file };
     }
 
-    fn formatPath(file: File, bw: *std.io.BufferedWriter, comptime unused_fmt_string: []const u8) anyerror!void {
+    fn formatPath(file: File, bw: *std.io.BufferedWriter, comptime unused_fmt_string: []const u8) std.io.Writer.Error!void {
         _ = unused_fmt_string;
         switch (file) {
             .zig_object => |zo| try bw.writeAll(zo.basename),
diff --git a/src/link/Elf/gc.zig b/src/link/Elf/gc.zig
index 3a702e53a4b79dc4e8ee20558d20886409b7ff87..69c2d9753c17030a0f36e22f281083a1c4054982 100644
--- a/src/link/Elf/gc.zig
+++ b/src/link/Elf/gc.zig
@@ -185,7 +185,7 @@ const Level = struct {
         self.value += 1;
     }
 
-    pub fn format(self: *const @This(), bw: *std.io.BufferedWriter, comptime unused_fmt_string: []const u8) anyerror!void {
+    pub fn format(self: *const @This(), bw: *std.io.BufferedWriter, comptime unused_fmt_string: []const u8) std.io.Writer.Error!void {
         _ = unused_fmt_string;
         try bw.splatByteAll(' ', self.value);
     }
diff --git a/src/link/Elf/relocation.zig b/src/link/Elf/relocation.zig
index 70214373d20712a280f8d6c5f2c180388e741e33..48e74ae2fe02fa0d248f1acbc1aff4e3e6ebb7ff 100644
--- a/src/link/Elf/relocation.zig
+++ b/src/link/Elf/relocation.zig
@@ -148,7 +148,7 @@ pub fn fmtRelocType(r_type: u32, cpu_arch: std.Target.Cpu.Arch) std.fmt.Formatte
     } };
 }
 
-fn formatRelocType(ctx: FormatRelocTypeCtx, bw: *std.io.BufferedWriter, comptime unused_fmt_string: []const u8) anyerror!void {
+fn formatRelocType(ctx: FormatRelocTypeCtx, bw: *std.io.BufferedWriter, comptime unused_fmt_string: []const u8) std.io.Writer.Error!void {
     _ = unused_fmt_string;
     const r_type = ctx.r_type;
     switch (ctx.cpu_arch) {
diff --git a/src/link/Elf/synthetic_sections.zig b/src/link/Elf/synthetic_sections.zig
index 8de6ecbe56316700d7a4e5357201e2ba101b96fb..2b8a37f5b053ebbe107285876fc832037b5fd811 100644
--- a/src/link/Elf/synthetic_sections.zig
+++ b/src/link/Elf/synthetic_sections.zig
@@ -94,7 +94,7 @@ pub const DynamicSection = struct {
         return nentries * @sizeOf(elf.Elf64_Dyn);
     }
 
-    pub fn write(dt: DynamicSection, elf_file: *Elf, bw: *std.io.BufferedWriter) anyerror!void {
+    pub fn write(dt: DynamicSection, elf_file: *Elf, bw: *std.io.BufferedWriter) std.io.Writer.Error!void {
         const shdrs = elf_file.sections.items(.shdr);
 
         // NEEDED
@@ -360,7 +360,7 @@ pub const GotSection = struct {
         return s;
     }
 
-    pub fn write(got: GotSection, elf_file: *Elf, bw: *std.io.BufferedWriter) anyerror!void {
+    pub fn write(got: GotSection, elf_file: *Elf, bw: *std.io.BufferedWriter) std.io.Writer.Error!void {
         const comp = elf_file.base.comp;
         const is_dyn_lib = elf_file.isEffectivelyDynLib();
         const apply_relocs = true; // TODO add user option for this
@@ -615,7 +615,7 @@ pub const GotSection = struct {
         return .{ .data = .{ .got = got, .elf_file = elf_file } };
     }
 
-    pub fn format2(ctx: FormatCtx, bw: *std.io.BufferedWriter, comptime unused_fmt_string: []const u8) anyerror!void {
+    pub fn format2(ctx: FormatCtx, bw: *std.io.BufferedWriter, comptime unused_fmt_string: []const u8) std.io.Writer.Error!void {
         _ = unused_fmt_string;
         const got = ctx.got;
         const elf_file = ctx.elf_file;
@@ -672,7 +672,7 @@ pub const PltSection = struct {
         };
     }
 
-    pub fn write(plt: PltSection, elf_file: *Elf, bw: *std.io.BufferedWriter) anyerror!void {
+    pub fn write(plt: PltSection, elf_file: *Elf, bw: *std.io.BufferedWriter) std.io.Writer.Error!void {
         const cpu_arch = elf_file.getTarget().cpu.arch;
         switch (cpu_arch) {
             .x86_64 => try x86_64.write(plt, elf_file, bw),
@@ -752,7 +752,7 @@ pub const PltSection = struct {
         return .{ .data = .{ .plt = plt, .elf_file = elf_file } };
     }
 
-    pub fn format2(ctx: FormatCtx, bw: *std.io.BufferedWriter, comptime unused_fmt_string: []const u8) anyerror!void {
+    pub fn format2(ctx: FormatCtx, bw: *std.io.BufferedWriter, comptime unused_fmt_string: []const u8) std.io.Writer.Error!void {
         _ = unused_fmt_string;
         const plt = ctx.plt;
         const elf_file = ctx.elf_file;
@@ -770,7 +770,7 @@ pub const PltSection = struct {
     }
 
     const x86_64 = struct {
-        fn write(plt: PltSection, elf_file: *Elf, bw: *std.io.BufferedWriter) anyerror!void {
+        fn write(plt: PltSection, elf_file: *Elf, bw: *std.io.BufferedWriter) std.io.Writer.Error!void {
             const shdrs = elf_file.sections.items(.shdr);
             const plt_addr = shdrs[elf_file.section_indexes.plt.?].sh_addr;
             const got_plt_addr = shdrs[elf_file.section_indexes.got_plt.?].sh_addr;
@@ -805,7 +805,7 @@ pub const PltSection = struct {
     };
 
     const aarch64 = struct {
-        fn write(plt: PltSection, elf_file: *Elf, bw: *std.io.BufferedWriter) anyerror!void {
+        fn write(plt: PltSection, elf_file: *Elf, bw: *std.io.BufferedWriter) std.io.Writer.Error!void {
             {
                 const shdrs = elf_file.sections.items(.shdr);
                 const plt_addr: i64 = @intCast(shdrs[elf_file.section_indexes.plt.?].sh_addr);
@@ -871,7 +871,7 @@ pub const GotPltSection = struct {
         return preamble_size + elf_file.plt.symbols.items.len * 8;
     }
 
-    pub fn write(got_plt: GotPltSection, elf_file: *Elf, bw: *std.io.BufferedWriter) anyerror!void {
+    pub fn write(got_plt: GotPltSection, elf_file: *Elf, bw: *std.io.BufferedWriter) std.io.Writer.Error!void {
         _ = got_plt;
         {
             // [0]: _DYNAMIC
@@ -922,7 +922,7 @@ pub const PltGotSection = struct {
         };
     }
 
-    pub fn write(plt_got: PltGotSection, elf_file: *Elf, bw: *std.io.BufferedWriter) anyerror!void {
+    pub fn write(plt_got: PltGotSection, elf_file: *Elf, bw: *std.io.BufferedWriter) std.io.Writer.Error!void {
         const cpu_arch = elf_file.getTarget().cpu.arch;
         switch (cpu_arch) {
             .x86_64 => try x86_64.write(plt_got, elf_file, bw),
@@ -958,7 +958,7 @@ pub const PltGotSection = struct {
     }
 
     const x86_64 = struct {
-        pub fn write(plt_got: PltGotSection, elf_file: *Elf, bw: *std.io.BufferedWriter) anyerror!void {
+        pub fn write(plt_got: PltGotSection, elf_file: *Elf, bw: *std.io.BufferedWriter) std.io.Writer.Error!void {
             for (plt_got.symbols.items) |ref| {
                 const sym = elf_file.symbol(ref).?;
                 const target_addr = sym.gotAddress(elf_file);
@@ -976,7 +976,7 @@ pub const PltGotSection = struct {
     };
 
     const aarch64 = struct {
-        fn write(plt_got: PltGotSection, elf_file: *Elf, bw: *std.io.BufferedWriter) anyerror!void {
+        fn write(plt_got: PltGotSection, elf_file: *Elf, bw: *std.io.BufferedWriter) std.io.Writer.Error!void {
             for (plt_got.symbols.items) |ref| {
                 const sym = elf_file.symbol(ref).?;
                 const target_addr = sym.gotAddress(elf_file);
@@ -1155,7 +1155,7 @@ pub const DynsymSection = struct {
         return @as(u32, @intCast(dynsym.entries.items.len + 1));
     }
 
-    pub fn write(dynsym: DynsymSection, elf_file: *Elf, bw: *std.io.BufferedWriter) anyerror!void {
+    pub fn write(dynsym: DynsymSection, elf_file: *Elf, bw: *std.io.BufferedWriter) std.io.Writer.Error!void {
         try bw.writeStruct(Elf.null_sym);
         for (dynsym.entries.items) |entry| {
             const sym = elf_file.symbol(entry.ref).?;
@@ -1458,7 +1458,7 @@ pub const VerneedSection = struct {
         return vern.verneed.items.len * @sizeOf(elf.Elf64_Verneed) + vern.vernaux.items.len * @sizeOf(elf.Vernaux);
     }
 
-    pub fn write(vern: VerneedSection, bw: *std.io.BufferedWriter) anyerror!void {
+    pub fn write(vern: VerneedSection, bw: *std.io.BufferedWriter) std.io.Writer.Error!void {
         try bw.writeAll(mem.sliceAsBytes(vern.verneed.items));
         try bw.writeAll(mem.sliceAsBytes(vern.vernaux.items));
     }
@@ -1486,8 +1486,8 @@ pub const GroupSection = struct {
         return (members.len + 1) * @sizeOf(u32);
     }
 
-    pub fn write(cgs: GroupSection, elf_file: *Elf, bw: *std.io.BufferedWriter) !void {
-        const cg = cgs.group(elf_file);
+    pub fn write(cgs: GroupSection, elf_file: *Elf, bw: *std.io.BufferedWriter) std.io.Writer.Error!void {
+        const cg = cgs.comdatGroup(elf_file);
         const object = cg.file(elf_file).object;
         const members = cg.members(elf_file);
         try bw.writeInt(u32, if (cg.is_comdat) elf.GRP_COMDAT else 0, .little);
@@ -1514,7 +1514,7 @@ pub const GroupSection = struct {
     }
 };
 
-fn writeInt(value: anytype, elf_file: *Elf, bw: *std.io.BufferedWriter) anyerror!void {
+fn writeInt(value: anytype, elf_file: *Elf, bw: *std.io.BufferedWriter) std.io.Writer.Error!void {
     const entry_size = elf_file.archPtrWidthBytes();
     const target = elf_file.getTarget();
     const endian = target.cpu.arch.endian();
diff --git a/src/link/MachO.zig b/src/link/MachO.zig
index 57d7019e22e3d3b500056fd2ab89973e87c6a0e8..b74599855d15c84303ce82b6067ff113de7b233d 100644
--- a/src/link/MachO.zig
+++ b/src/link/MachO.zig
@@ -2822,7 +2822,7 @@ fn calcSymtabSize(self: *MachO) !void {
     }
 }
 
-fn writeLoadCommands(self: *MachO) anyerror!struct { usize, usize, u64 } {
+fn writeLoadCommands(self: *MachO) std.io.Writer.Error!struct { usize, usize, u64 } {
     const comp = self.base.comp;
     const gpa = comp.gpa;
 
@@ -3910,7 +3910,7 @@ pub fn dumpState(self: *MachO) std.fmt.Formatter(fmtDumpState) {
     return .{ .data = self };
 }
 
-fn fmtDumpState(self: *MachO, bw: *std.io.BufferedWriter, comptime unused_fmt_string: []const u8) anyerror!void {
+fn fmtDumpState(self: *MachO, bw: *std.io.BufferedWriter, comptime unused_fmt_string: []const u8) std.io.Writer.Error!void {
     _ = unused_fmt_string;
     if (self.getZigObject()) |zo| {
         try bw.print("zig_object({d}) : {s}\n", .{ zo.index, zo.basename });
@@ -3969,7 +3969,7 @@ fn fmtSections(self: *MachO) std.fmt.Formatter(formatSections) {
     return .{ .data = self };
 }
 
-fn formatSections(self: *MachO, bw: *std.io.BufferedWriter, comptime unused_fmt_string: []const u8) anyerror!void {
+fn formatSections(self: *MachO, bw: *std.io.BufferedWriter, comptime unused_fmt_string: []const u8) std.io.Writer.Error!void {
     _ = unused_fmt_string;
     const slice = self.sections.slice();
     for (slice.items(.header), slice.items(.segment_id), 0..) |header, seg_id, i| {
@@ -3987,7 +3987,7 @@ fn fmtSegments(self: *MachO) std.fmt.Formatter(formatSegments) {
     return .{ .data = self };
 }
 
-fn formatSegments(self: *MachO, bw: *std.io.BufferedWriter, comptime unused_fmt_string: []const u8) anyerror!void {
+fn formatSegments(self: *MachO, bw: *std.io.BufferedWriter, comptime unused_fmt_string: []const u8) std.io.Writer.Error!void {
     _ = unused_fmt_string;
     for (self.segments.items, 0..) |seg, i| {
         try bw.print("seg({d}) : {s} : @{x}-{x} ({x}-{x})\n", .{
@@ -4001,7 +4001,7 @@ pub fn fmtSectType(tt: u8) std.fmt.Formatter(formatSectType) {
     return .{ .data = tt };
 }
 
-fn formatSectType(tt: u8, bw: *std.io.BufferedWriter, comptime unused_fmt_string: []const u8) anyerror!void {
+fn formatSectType(tt: u8, bw: *std.io.BufferedWriter, comptime unused_fmt_string: []const u8) std.io.Writer.Error!void {
     _ = unused_fmt_string;
     const name = switch (tt) {
         macho.S_REGULAR => "REGULAR",
@@ -4270,7 +4270,7 @@ pub const Platform = struct {
         cpu_arch: std.Target.Cpu.Arch,
     };
 
-    pub fn formatTarget(ctx: FmtCtx, bw: *std.io.BufferedWriter, comptime unused_fmt_string: []const u8) anyerror!void {
+    pub fn formatTarget(ctx: FmtCtx, bw: *std.io.BufferedWriter, comptime unused_fmt_string: []const u8) std.io.Writer.Error!void {
         _ = unused_fmt_string;
         try bw.print("{s}-{s}", .{ @tagName(ctx.cpu_arch), @tagName(ctx.platform.os_tag) });
         if (ctx.platform.abi != .none) {
@@ -4483,7 +4483,7 @@ pub const Ref = struct {
         };
     }
 
-    pub fn format(ref: Ref, bw: *std.io.BufferedWriter, comptime unused_fmt_string: []const u8) anyerror!void {
+    pub fn format(ref: Ref, bw: *std.io.BufferedWriter, comptime unused_fmt_string: []const u8) std.io.Writer.Error!void {
         _ = unused_fmt_string;
         try bw.print("%{d} in file({d})", .{ ref.index, ref.file });
     }
diff --git a/src/link/MachO/Archive.zig b/src/link/MachO/Archive.zig
index 0ab3a338856d73fc3a8cf9023f2fce9d2ed19d55..e09c3a680c21e1a96ce0b498eda8d500d43bb45e 100644
--- a/src/link/MachO/Archive.zig
+++ b/src/link/MachO/Archive.zig
@@ -82,7 +82,7 @@ pub fn writeHeader(
     object_name: []const u8,
     object_size: usize,
     format: Format,
-) anyerror!void {
+) std.io.Writer.Error!void {
     var hdr: ar_hdr = undefined;
     @memset(mem.asBytes(&hdr), ' ');
     inline for (@typeInfo(ar_hdr).@"struct".fields) |field| @field(hdr, field.name)[0] = '0';
@@ -177,7 +177,7 @@ pub const ArSymtab = struct {
         return ptr_width + ar.entries.items.len * 2 * ptr_width + ptr_width + mem.alignForward(usize, ar.strtab.buffer.items.len, ptr_width);
     }
 
-    pub fn write(ar: ArSymtab, bw: *std.io.BufferedWriter, format: Format, macho_file: *MachO) anyerror!void {
+    pub fn write(ar: ArSymtab, bw: *std.io.BufferedWriter, format: Format, macho_file: *MachO) std.io.Writer.Error!void {
         const ptr_width = ptrWidth(format);
         // Header
         try writeHeader(bw, SYMDEF, ar.size(format), format);
@@ -212,7 +212,7 @@ pub const ArSymtab = struct {
         return .{ .data = .{ .ar = ar, .macho_file = macho_file } };
     }
 
-    fn format2(ctx: FormatContext, bw: *std.io.BufferedWriter, comptime unused_fmt_string: []const u8) anyerror!void {
+    fn format2(ctx: FormatContext, bw: *std.io.BufferedWriter, comptime unused_fmt_string: []const u8) std.io.Writer.Error!void {
         _ = unused_fmt_string;
         const ar = ctx.ar;
         const macho_file = ctx.macho_file;
@@ -249,7 +249,7 @@ pub fn ptrWidth(format: Format) usize {
     };
 }
 
-pub fn writeInt(bw: *std.io.BufferedWriter, format: Format, value: u64) anyerror!void {
+pub fn writeInt(bw: *std.io.BufferedWriter, format: Format, value: u64) std.io.Writer.Error!void {
     switch (format) {
         .p32 => try bw.writeInt(u32, std.math.cast(u32, value) orelse return error.Overflow, .little),
         .p64 => try bw.writeInt(u64, value, .little),
diff --git a/src/link/MachO/Atom.zig b/src/link/MachO/Atom.zig
index f2af52090f021c0bc495feefe55677abf8e751dd..5a45d508be76c43008ab30cafc9a274aec424623 100644
--- a/src/link/MachO/Atom.zig
+++ b/src/link/MachO/Atom.zig
@@ -639,7 +639,7 @@ fn resolveRelocInner(
     code: []u8,
     macho_file: *MachO,
     bw: *std.io.BufferedWriter,
-) anyerror!void {
+) std.io.Writer.Error!void {
     const t = &macho_file.base.comp.root_mod.resolved_target.result;
     const cpu_arch = t.cpu.arch;
     const rel_offset = math.cast(usize, rel.offset - self.off) orelse return error.Overflow;
@@ -1140,7 +1140,7 @@ const FormatContext = struct {
     macho_file: *MachO,
 };
 
-fn format2(ctx: FormatContext, bw: *std.io.BufferedWriter, comptime unused_fmt_string: []const u8) anyerror!void {
+fn format2(ctx: FormatContext, bw: *std.io.BufferedWriter, comptime unused_fmt_string: []const u8) std.io.Writer.Error!void {
     _ = unused_fmt_string;
     const atom = ctx.atom;
     const macho_file = ctx.macho_file;
diff --git a/src/link/MachO/Dylib.zig b/src/link/MachO/Dylib.zig
index 4b2e4c725ed1f75441a2043a95e53536c36f1e69..97918fc4a79cb9038af6bb7ae11e84d823968fce 100644
--- a/src/link/MachO/Dylib.zig
+++ b/src/link/MachO/Dylib.zig
@@ -676,7 +676,7 @@ const FormatContext = struct {
     macho_file: *MachO,
 };
 
-fn formatSymtab(ctx: FormatContext, bw: *std.io.BufferedWriter, comptime unused_fmt_string: []const u8) anyerror!void {
+fn formatSymtab(ctx: FormatContext, bw: *std.io.BufferedWriter, comptime unused_fmt_string: []const u8) std.io.Writer.Error!void {
     _ = unused_fmt_string;
     const dylib = ctx.dylib;
     const macho_file = ctx.macho_file;
diff --git a/src/link/MachO/InternalObject.zig b/src/link/MachO/InternalObject.zig
index 7182efb82316b57e1256a7441c610dc1059c2cdd..9a4d38c0b360d1ae05a52d2ce1d215d3880d525b 100644
--- a/src/link/MachO/InternalObject.zig
+++ b/src/link/MachO/InternalObject.zig
@@ -848,7 +848,7 @@ pub fn fmtAtoms(self: *InternalObject, macho_file: *MachO) std.fmt.Formatter(for
     } };
 }
 
-fn formatAtoms(ctx: FormatContext, bw: *std.io.BufferedWriter, comptime unused_fmt_string: []const u8) anyerror!void {
+fn formatAtoms(ctx: FormatContext, bw: *std.io.BufferedWriter, comptime unused_fmt_string: []const u8) std.io.Writer.Error!void {
     _ = unused_fmt_string;
     try bw.writeAll("  atoms\n");
     for (ctx.self.getAtoms()) |atom_index| {
@@ -864,7 +864,7 @@ pub fn fmtSymtab(self: *InternalObject, macho_file: *MachO) std.fmt.Formatter(fo
     } };
 }
 
-fn formatSymtab(ctx: FormatContext, bw: *std.io.BufferedWriter, comptime unused_fmt_string: []const u8) anyerror!void {
+fn formatSymtab(ctx: FormatContext, bw: *std.io.BufferedWriter, comptime unused_fmt_string: []const u8) std.io.Writer.Error!void {
     _ = unused_fmt_string;
     const macho_file = ctx.macho_file;
     const self = ctx.self;
diff --git a/src/link/MachO/Object.zig b/src/link/MachO/Object.zig
index e6a4d587fe90b6311bd12558edb3575f8d73ca14..f4073743bea9ccc8bd1baf5eeddf385001336cf5 100644
--- a/src/link/MachO/Object.zig
+++ b/src/link/MachO/Object.zig
@@ -2513,7 +2513,7 @@ pub fn readSectionData(self: Object, allocator: Allocator, file: File.Handle, n_
     return data;
 }
 
-pub fn format(self: *Object, bw: *std.io.BufferedWriter, comptime unused_fmt_string: []const u8) anyerror!void {
+pub fn format(self: *Object, bw: *std.io.BufferedWriter, comptime unused_fmt_string: []const u8) std.io.Writer.Error!void {
     _ = self;
     _ = bw;
     _ = unused_fmt_string;
@@ -2532,7 +2532,7 @@ pub fn fmtAtoms(self: *Object, macho_file: *MachO) std.fmt.Formatter(formatAtoms
     } };
 }
 
-fn formatAtoms(ctx: FormatContext, bw: *std.io.BufferedWriter, comptime unused_fmt_string: []const u8) anyerror!void {
+fn formatAtoms(ctx: FormatContext, bw: *std.io.BufferedWriter, comptime unused_fmt_string: []const u8) std.io.Writer.Error!void {
     _ = unused_fmt_string;
     const object = ctx.object;
     const macho_file = ctx.macho_file;
@@ -2550,7 +2550,7 @@ pub fn fmtCies(self: *Object, macho_file: *MachO) std.fmt.Formatter(formatCies)
     } };
 }
 
-fn formatCies(ctx: FormatContext, bw: *std.io.BufferedWriter, comptime unused_fmt_string: []const u8) anyerror!void {
+fn formatCies(ctx: FormatContext, bw: *std.io.BufferedWriter, comptime unused_fmt_string: []const u8) std.io.Writer.Error!void {
     _ = unused_fmt_string;
     const object = ctx.object;
     try bw.writeAll("  cies\n");
@@ -2566,7 +2566,7 @@ pub fn fmtFdes(self: *Object, macho_file: *MachO) std.fmt.Formatter(formatFdes)
     } };
 }
 
-fn formatFdes(ctx: FormatContext, bw: *std.io.BufferedWriter, comptime unused_fmt_string: []const u8) anyerror!void {
+fn formatFdes(ctx: FormatContext, bw: *std.io.BufferedWriter, comptime unused_fmt_string: []const u8) std.io.Writer.Error!void {
     _ = unused_fmt_string;
     const object = ctx.object;
     try bw.writeAll("  fdes\n");
@@ -2582,7 +2582,7 @@ pub fn fmtUnwindRecords(self: *Object, macho_file: *MachO) std.fmt.Formatter(for
     } };
 }
 
-fn formatUnwindRecords(ctx: FormatContext, bw: *std.io.BufferedWriter, comptime unused_fmt_string: []const u8) anyerror!void {
+fn formatUnwindRecords(ctx: FormatContext, bw: *std.io.BufferedWriter, comptime unused_fmt_string: []const u8) std.io.Writer.Error!void {
     _ = unused_fmt_string;
     const object = ctx.object;
     const macho_file = ctx.macho_file;
@@ -2599,7 +2599,7 @@ pub fn fmtSymtab(self: *Object, macho_file: *MachO) std.fmt.Formatter(formatSymt
     } };
 }
 
-fn formatSymtab(ctx: FormatContext, bw: *std.io.BufferedWriter, comptime unused_fmt_string: []const u8) anyerror!void {
+fn formatSymtab(ctx: FormatContext, bw: *std.io.BufferedWriter, comptime unused_fmt_string: []const u8) std.io.Writer.Error!void {
     _ = unused_fmt_string;
     const object = ctx.object;
     const macho_file = ctx.macho_file;
@@ -2629,7 +2629,7 @@ pub fn fmtPath(self: Object) std.fmt.Formatter(formatPath) {
     return .{ .data = self };
 }
 
-fn formatPath(object: Object, bw: *std.io.BufferedWriter, comptime unused_fmt_string: []const u8) anyerror!void {
+fn formatPath(object: Object, bw: *std.io.BufferedWriter, comptime unused_fmt_string: []const u8) std.io.Writer.Error!void {
     _ = unused_fmt_string;
     if (object.in_archive) |ar| {
         try bw.print("{f}({s})", .{
@@ -2690,7 +2690,7 @@ const StabFile = struct {
             return object.symbols.items[index];
         }
 
-        pub fn format(stab: Stab, bw: *std.io.BufferedWriter, comptime unused_fmt_string: []const u8) anyerror!void {
+        pub fn format(stab: Stab, bw: *std.io.BufferedWriter, comptime unused_fmt_string: []const u8) std.io.Writer.Error!void {
             _ = stab;
             _ = bw;
             _ = unused_fmt_string;
@@ -2703,7 +2703,7 @@ const StabFile = struct {
             return .{ .data = .{ stab, object } };
         }
 
-        fn format2(ctx: StabFormatContext, bw: *std.io.BufferedWriter, comptime unused_fmt_string: []const u8) anyerror!void {
+        fn format2(ctx: StabFormatContext, bw: *std.io.BufferedWriter, comptime unused_fmt_string: []const u8) std.io.Writer.Error!void {
             _ = unused_fmt_string;
             const stab, const object = ctx;
             const sym = stab.getSymbol(object).?;
diff --git a/src/link/MachO/Relocation.zig b/src/link/MachO/Relocation.zig
index 968e7ca0be899c25cc31c212dd2bb86014b97c57..baa953c9418d34d8b7a63f593cbecb269dc2e127 100644
--- a/src/link/MachO/Relocation.zig
+++ b/src/link/MachO/Relocation.zig
@@ -76,7 +76,7 @@ pub fn fmtPretty(rel: Relocation, cpu_arch: std.Target.Cpu.Arch) std.fmt.Formatt
     return .{ .data = .{ rel, cpu_arch } };
 }
 
-fn formatPretty(ctx: FormatCtx, bw: *std.io.BufferedWriter, comptime unused_fmt_string: []const u8) anyerror!void {
+fn formatPretty(ctx: FormatCtx, bw: *std.io.BufferedWriter, comptime unused_fmt_string: []const u8) std.io.Writer.Error!void {
     _ = unused_fmt_string;
     const rel, const cpu_arch = ctx;
     try bw.writeAll(switch (rel.type) {
diff --git a/src/link/MachO/Symbol.zig b/src/link/MachO/Symbol.zig
index f8f8eb791557d4fa35c76c2294d271fb698188b6..1ef01259e6e324221df76db5a0612966d4c54920 100644
--- a/src/link/MachO/Symbol.zig
+++ b/src/link/MachO/Symbol.zig
@@ -286,7 +286,7 @@ pub fn setOutputSym(symbol: Symbol, macho_file: *MachO, out: *macho.nlist_64) vo
     }
 }
 
-pub fn format(symbol: Symbol, bw: *std.io.BufferedWriter, comptime unused_fmt_string: []const u8) anyerror!void {
+pub fn format(symbol: Symbol, bw: *std.io.BufferedWriter, comptime unused_fmt_string: []const u8) std.io.Writer.Error!void {
     _ = symbol;
     _ = bw;
     _ = unused_fmt_string;
@@ -305,7 +305,7 @@ pub fn fmt(symbol: Symbol, macho_file: *MachO) std.fmt.Formatter(format2) {
     } };
 }
 
-fn format2(ctx: FormatContext, bw: *std.io.BufferedWriter, comptime unused_fmt_string: []const u8) anyerror!void {
+fn format2(ctx: FormatContext, bw: *std.io.BufferedWriter, comptime unused_fmt_string: []const u8) std.io.Writer.Error!void {
     _ = unused_fmt_string;
     const symbol = ctx.symbol;
     try bw.print("%{d} : {s} : @{x}", .{
diff --git a/src/link/MachO/Thunk.zig b/src/link/MachO/Thunk.zig
index 4fec423d633ac628e60f4ba402217f50ccca9cb0..f8b18084cff0f9097354c0953dae23fe281281dd 100644
--- a/src/link/MachO/Thunk.zig
+++ b/src/link/MachO/Thunk.zig
@@ -61,7 +61,7 @@ pub fn writeSymtab(thunk: Thunk, macho_file: *MachO, ctx: anytype) void {
     }
 }
 
-pub fn format(thunk: Thunk, bw: *std.io.BufferedWriter, comptime unused_fmt_string: []const u8) anyerror!void {
+pub fn format(thunk: Thunk, bw: *std.io.BufferedWriter, comptime unused_fmt_string: []const u8) std.io.Writer.Error!void {
     _ = thunk;
     _ = bw;
     _ = unused_fmt_string;
@@ -80,7 +80,7 @@ const FormatContext = struct {
     macho_file: *MachO,
 };
 
-fn format2(ctx: FormatContext, bw: *std.io.BufferedWriter, comptime unused_fmt_string: []const u8) anyerror!void {
+fn format2(ctx: FormatContext, bw: *std.io.BufferedWriter, comptime unused_fmt_string: []const u8) std.io.Writer.Error!void {
     _ = unused_fmt_string;
     const thunk = ctx.thunk;
     const macho_file = ctx.macho_file;
diff --git a/src/link/MachO/UnwindInfo.zig b/src/link/MachO/UnwindInfo.zig
index 5e62e1080f7aa96980b6f114dd50de8ff3a69e95..a6d90ebc391961eaa55ffff245cd8fdac0de3d20 100644
--- a/src/link/MachO/UnwindInfo.zig
+++ b/src/link/MachO/UnwindInfo.zig
@@ -289,7 +289,7 @@ pub fn calcSize(info: UnwindInfo) usize {
     return total_size;
 }
 
-pub fn write(info: UnwindInfo, macho_file: *MachO, bw: *std.io.BufferedWriter) anyerror!void {
+pub fn write(info: UnwindInfo, macho_file: *MachO, bw: *std.io.BufferedWriter) std.io.Writer.Error!void {
     const seg = macho_file.getTextSegment();
     const header = macho_file.sections.items(.header)[macho_file.unwind_info_sect_index.?];
 
@@ -449,7 +449,7 @@ pub const Encoding = extern struct {
         return enc.enc == other.enc;
     }
 
-    pub fn format(enc: Encoding, bw: *std.io.BufferedWriter, comptime unused_fmt_string: []const u8) anyerror!void {
+    pub fn format(enc: Encoding, bw: *std.io.BufferedWriter, comptime unused_fmt_string: []const u8) std.io.Writer.Error!void {
         _ = unused_fmt_string;
         try bw.print("0x{x:0>8}", .{enc.enc});
     }
@@ -505,7 +505,7 @@ pub const Record = struct {
         return lsda.getAddress(macho_file) + rec.lsda_offset;
     }
 
-    pub fn format(rec: Record, bw: *std.io.BufferedWriter, comptime unused_fmt_string: []const u8) anyerror!void {
+    pub fn format(rec: Record, bw: *std.io.BufferedWriter, comptime unused_fmt_string: []const u8) std.io.Writer.Error!void {
         _ = rec;
         _ = bw;
         _ = unused_fmt_string;
@@ -524,7 +524,7 @@ pub const Record = struct {
         macho_file: *MachO,
     };
 
-    fn format2(ctx: FormatContext, bw: *std.io.BufferedWriter, comptime unused_fmt_string: []const u8) anyerror!void {
+    fn format2(ctx: FormatContext, bw: *std.io.BufferedWriter, comptime unused_fmt_string: []const u8) std.io.Writer.Error!void {
         _ = unused_fmt_string;
         const rec = ctx.rec;
         const macho_file = ctx.macho_file;
@@ -589,7 +589,7 @@ const Page = struct {
         return null;
     }
 
-    fn format(page: *const Page, bw: *std.io.BufferedWriter, comptime unused_format_string: []const u8) anyerror!void {
+    fn format(page: *const Page, bw: *std.io.BufferedWriter, comptime unused_format_string: []const u8) std.io.Writer.Error!void {
         _ = page;
         _ = bw;
         _ = unused_format_string;
@@ -601,7 +601,7 @@ const Page = struct {
         info: UnwindInfo,
     };
 
-    fn format2(ctx: FormatPageContext, bw: *std.io.BufferedWriter, comptime unused_format_string: []const u8) anyerror!void {
+    fn format2(ctx: FormatPageContext, bw: *std.io.BufferedWriter, comptime unused_format_string: []const u8) std.io.Writer.Error!void {
         _ = unused_format_string;
         try bw.writeAll("Page:\n");
         try bw.print("  kind: {s}\n", .{@tagName(ctx.page.kind)});
diff --git a/src/link/MachO/ZigObject.zig b/src/link/MachO/ZigObject.zig
index ef716f953c7ebe0ec5dbc60ed05618f2bdc841ee..7d8b6857d418bb2a87a35affdd3985319ebe4b92 100644
--- a/src/link/MachO/ZigObject.zig
+++ b/src/link/MachO/ZigObject.zig
@@ -317,7 +317,7 @@ pub fn updateArSize(self: *ZigObject) void {
     self.output_ar_state.size = self.data.items.len;
 }
 
-pub fn writeAr(self: ZigObject, bw: *std.io.BufferedWriter, ar_format: Archive.Format) anyerror!void {
+pub fn writeAr(self: ZigObject, bw: *std.io.BufferedWriter, ar_format: Archive.Format) std.io.Writer.Error!void {
     // Header
     const size = std.math.cast(usize, self.output_ar_state.size) orelse return error.Overflow;
     try Archive.writeHeader(bw, self.basename, size, ar_format);
@@ -1688,7 +1688,7 @@ const FormatContext = struct {
     macho_file: *MachO,
 };
 
-fn formatSymtab(ctx: FormatContext, bw: *std.io.BufferedWriter, comptime unused_fmt_string: []const u8) anyerror!void {
+fn formatSymtab(ctx: FormatContext, bw: *std.io.BufferedWriter, comptime unused_fmt_string: []const u8) std.io.Writer.Error!void {
     _ = unused_fmt_string;
     try bw.writeAll("  symbols\n");
     const self = ctx.self;
@@ -1711,7 +1711,7 @@ pub fn fmtAtoms(self: *ZigObject, macho_file: *MachO) std.fmt.Formatter(formatAt
     } };
 }
 
-fn formatAtoms(ctx: FormatContext, bw: *std.io.BufferedWriter, comptime unused_fmt_string: []const u8) anyerror!void {
+fn formatAtoms(ctx: FormatContext, bw: *std.io.BufferedWriter, comptime unused_fmt_string: []const u8) std.io.Writer.Error!void {
     _ = unused_fmt_string;
     const self = ctx.self;
     const macho_file = ctx.macho_file;
diff --git a/src/link/MachO/dead_strip.zig b/src/link/MachO/dead_strip.zig
index 8397f11d4261b6bddfce8fc4b57c84876b46bc52..0bd8213414bf978e1a02364c455ed4aacaee330e 100644
--- a/src/link/MachO/dead_strip.zig
+++ b/src/link/MachO/dead_strip.zig
@@ -196,7 +196,7 @@ const Level = struct {
         self.value += 1;
     }
 
-    pub fn format(self: *const @This(), bw: *std.io.BufferedWriter, comptime unused_fmt_string: []const u8) anyerror!void {
+    pub fn format(self: *const @This(), bw: *std.io.BufferedWriter, comptime unused_fmt_string: []const u8) std.io.Writer.Error!void {
         _ = unused_fmt_string;
         try bw.splatByteAll(' ', self.value);
     }
diff --git a/src/link/MachO/dyld_info/Rebase.zig b/src/link/MachO/dyld_info/Rebase.zig
index 52c57ff1611d7d7c85f0e7789619d983eca07f42..ed337a72d832fc44206fa2e5c26a0d835dce13e5 100644
--- a/src/link/MachO/dyld_info/Rebase.zig
+++ b/src/link/MachO/dyld_info/Rebase.zig
@@ -133,7 +133,7 @@ fn finalize(rebase: *Rebase, gpa: Allocator) !void {
     try done(bw);
 }
 
-fn finalizeSegment(entries: []const Entry, bw: *std.io.BufferedWriter) anyerror!void {
+fn finalizeSegment(entries: []const Entry, bw: *std.io.BufferedWriter) std.io.Writer.Error!void {
     if (entries.len == 0) return;
 
     const segment_id = entries[0].segment_id;
@@ -220,24 +220,24 @@ fn finalizeSegment(entries: []const Entry, bw: *std.io.BufferedWriter) anyerror!
     }
 }
 
-fn setTypePointer(bw: *std.io.BufferedWriter) anyerror!void {
+fn setTypePointer(bw: *std.io.BufferedWriter) std.io.Writer.Error!void {
     log.debug(">>> set type: {d}", .{macho.REBASE_TYPE_POINTER});
     try bw.writeByte(macho.REBASE_OPCODE_SET_TYPE_IMM | @as(u4, @intCast(macho.REBASE_TYPE_POINTER)));
 }
 
-fn setSegmentOffset(segment_id: u4, offset: u64, bw: *std.io.BufferedWriter) anyerror!void {
+fn setSegmentOffset(segment_id: u4, offset: u64, bw: *std.io.BufferedWriter) std.io.Writer.Error!void {
     log.debug(">>> set segment: {d} and offset: {x}", .{ segment_id, offset });
     try bw.writeByte(macho.REBASE_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB | @as(u4, @truncate(segment_id)));
     try bw.writeLeb128(offset);
 }
 
-fn rebaseAddAddr(addr: u64, bw: *std.io.BufferedWriter) anyerror!void {
+fn rebaseAddAddr(addr: u64, bw: *std.io.BufferedWriter) std.io.Writer.Error!void {
     log.debug(">>> rebase with add: {x}", .{addr});
     try bw.writeByte(macho.REBASE_OPCODE_DO_REBASE_ADD_ADDR_ULEB);
     try bw.writeLeb128(addr);
 }
 
-fn rebaseTimes(count: usize, bw: *std.io.BufferedWriter) anyerror!void {
+fn rebaseTimes(count: usize, bw: *std.io.BufferedWriter) std.io.Writer.Error!void {
     log.debug(">>> rebase with count: {d}", .{count});
     if (count <= 0xf) {
         try bw.writeByte(macho.REBASE_OPCODE_DO_REBASE_IMM_TIMES | @as(u4, @truncate(count)));
@@ -247,14 +247,14 @@ fn rebaseTimes(count: usize, bw: *std.io.BufferedWriter) anyerror!void {
     }
 }
 
-fn rebaseTimesSkip(count: usize, skip: u64, bw: *std.io.BufferedWriter) anyerror!void {
+fn rebaseTimesSkip(count: usize, skip: u64, bw: *std.io.BufferedWriter) std.io.Writer.Error!void {
     log.debug(">>> rebase with count: {d} and skip: {x}", .{ count, skip });
     try bw.writeByte(macho.REBASE_OPCODE_DO_REBASE_ULEB_TIMES_SKIPPING_ULEB);
     try bw.writeLeb128(count);
     try bw.writeLeb128(skip);
 }
 
-fn addAddr(addr: u64, bw: *std.io.BufferedWriter) anyerror!void {
+fn addAddr(addr: u64, bw: *std.io.BufferedWriter) std.io.Writer.Error!void {
     log.debug(">>> add: {x}", .{addr});
     if (std.math.divExact(u64, addr, @sizeOf(u64))) |scaled| {
         if (std.math.cast(u4, scaled)) |imm_scaled| return bw.writeByte(
@@ -265,12 +265,12 @@ fn addAddr(addr: u64, bw: *std.io.BufferedWriter) anyerror!void {
     try bw.writeLeb128(addr);
 }
 
-fn done(bw: *std.io.BufferedWriter) anyerror!void {
+fn done(bw: *std.io.BufferedWriter) std.io.Writer.Error!void {
     log.debug(">>> done", .{});
     try bw.writeByte(macho.REBASE_OPCODE_DONE);
 }
 
-pub fn write(rebase: Rebase, bw: *std.io.BufferedWriter) anyerror!void {
+pub fn write(rebase: Rebase, bw: *std.io.BufferedWriter) std.io.Writer.Error!void {
     try bw.writeAll(rebase.buffer.items);
 }
 
diff --git a/src/link/MachO/dyld_info/Trie.zig b/src/link/MachO/dyld_info/Trie.zig
index d39f1aad52204fc35c987f1106e7250f5e038454..01b48afe80801599f61e0e59039b457f1970df76 100644
--- a/src/link/MachO/dyld_info/Trie.zig
+++ b/src/link/MachO/dyld_info/Trie.zig
@@ -232,7 +232,7 @@ pub fn deinit(self: *Trie, allocator: Allocator) void {
     allocator.free(self.buffer);
 }
 
-pub fn write(self: Trie, bw: *std.io.BufferedWriter) anyerror!void {
+pub fn write(self: Trie, bw: *std.io.BufferedWriter) std.io.Writer.Error!void {
     try bw.writeAll(self.buffer);
 }
 
diff --git a/src/link/MachO/dyld_info/bind.zig b/src/link/MachO/dyld_info/bind.zig
index 1b546b1fcc083dc9cb7ce1ac3886d12ceb7fda3b..bdb330b18c5f57f7c34330812b310465d8512917 100644
--- a/src/link/MachO/dyld_info/bind.zig
+++ b/src/link/MachO/dyld_info/bind.zig
@@ -139,7 +139,7 @@ pub const Bind = struct {
         try done(bw);
     }
 
-    fn finalizeSegment(entries: []const Entry, ctx: *MachO, bw: *std.io.BufferedWriter) anyerror!void {
+    fn finalizeSegment(entries: []const Entry, ctx: *MachO, bw: *std.io.BufferedWriter) std.io.Writer.Error!void {
         if (entries.len == 0) return;
 
         const seg_id = entries[0].segment_id;
@@ -251,7 +251,7 @@ pub const Bind = struct {
         }
     }
 
-    pub fn write(bind: Bind, bw: *std.io.BufferedWriter) anyerror!void {
+    pub fn write(bind: Bind, bw: *std.io.BufferedWriter) std.io.Writer.Error!void {
         try bw.writeAll(bind.buffer.items);
     }
 };
@@ -380,7 +380,7 @@ pub const WeakBind = struct {
         try done(bw);
     }
 
-    fn finalizeSegment(entries: []const Entry, ctx: *MachO, bw: *std.io.BufferedWriter) anyerror!void {
+    fn finalizeSegment(entries: []const Entry, ctx: *MachO, bw: *std.io.BufferedWriter) std.io.Writer.Error!void {
         if (entries.len == 0) return;
 
         const seg_id = entries[0].segment_id;
@@ -481,7 +481,7 @@ pub const WeakBind = struct {
         }
     }
 
-    pub fn write(bind: WeakBind, bw: *std.io.BufferedWriter) anyerror!void {
+    pub fn write(bind: WeakBind, bw: *std.io.BufferedWriter) std.io.Writer.Error!void {
         try bw.writeAll(bind.buffer.items);
     }
 };
@@ -565,30 +565,30 @@ pub const LazyBind = struct {
         }
     }
 
-    pub fn write(bind: LazyBind, bw: *std.io.BufferedWriter) anyerror!void {
+    pub fn write(bind: LazyBind, bw: *std.io.BufferedWriter) std.io.Writer.Error!void {
         try bw.writeAll(bind.buffer.items);
     }
 };
 
-fn setSegmentOffset(segment_id: u4, offset: u64, bw: *std.io.BufferedWriter) anyerror!void {
+fn setSegmentOffset(segment_id: u4, offset: u64, bw: *std.io.BufferedWriter) std.io.Writer.Error!void {
     log.debug(">>> set segment: {d} and offset: {x}", .{ segment_id, offset });
     try bw.writeByte(macho.BIND_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB | segment_id);
     try bw.writeLeb128(offset);
 }
 
-fn setSymbol(name: []const u8, flags: u4, bw: *std.io.BufferedWriter) anyerror!void {
+fn setSymbol(name: []const u8, flags: u4, bw: *std.io.BufferedWriter) std.io.Writer.Error!void {
     log.debug(">>> set symbol: {s} with flags: {x}", .{ name, flags });
     try bw.writeByte(macho.BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM | flags);
     try bw.writeAll(name);
     try bw.writeByte(0);
 }
 
-fn setTypePointer(bw: *std.io.BufferedWriter) anyerror!void {
+fn setTypePointer(bw: *std.io.BufferedWriter) std.io.Writer.Error!void {
     log.debug(">>> set type: {d}", .{macho.BIND_TYPE_POINTER});
     try bw.writeByte(macho.BIND_OPCODE_SET_TYPE_IMM | @as(u4, @intCast(macho.BIND_TYPE_POINTER)));
 }
 
-fn setDylibOrdinal(ordinal: i16, bw: *std.io.BufferedWriter) anyerror!void {
+fn setDylibOrdinal(ordinal: i16, bw: *std.io.BufferedWriter) std.io.Writer.Error!void {
     switch (ordinal) {
         else => unreachable, // Invalid dylib special binding
         macho.BIND_SPECIAL_DYLIB_SELF,
@@ -610,18 +610,18 @@ fn setDylibOrdinal(ordinal: i16, bw: *std.io.BufferedWriter) anyerror!void {
     }
 }
 
-fn setAddend(addend: i64, bw: *std.io.BufferedWriter) anyerror!void {
+fn setAddend(addend: i64, bw: *std.io.BufferedWriter) std.io.Writer.Error!void {
     log.debug(">>> set addend: {x}", .{addend});
     try bw.writeByte(macho.BIND_OPCODE_SET_ADDEND_SLEB);
     try bw.writeLeb128(addend);
 }
 
-fn doBind(bw: *std.io.BufferedWriter) anyerror!void {
+fn doBind(bw: *std.io.BufferedWriter) std.io.Writer.Error!void {
     log.debug(">>> bind", .{});
     try bw.writeByte(macho.BIND_OPCODE_DO_BIND);
 }
 
-fn doBindAddAddr(addr: u64, bw: *std.io.BufferedWriter) anyerror!void {
+fn doBindAddAddr(addr: u64, bw: *std.io.BufferedWriter) std.io.Writer.Error!void {
     log.debug(">>> bind with add: {x}", .{addr});
     if (std.math.divExact(u64, addr, @sizeOf(u64))) |scaled| {
         if (std.math.cast(u4, scaled)) |imm_scaled| return bw.writeByte(
@@ -632,20 +632,20 @@ fn doBindAddAddr(addr: u64, bw: *std.io.BufferedWriter) anyerror!void {
     try bw.writeLeb128(addr);
 }
 
-fn doBindTimesSkip(count: usize, skip: u64, bw: *std.io.BufferedWriter) anyerror!void {
+fn doBindTimesSkip(count: usize, skip: u64, bw: *std.io.BufferedWriter) std.io.Writer.Error!void {
     log.debug(">>> bind with count: {d} and skip: {x}", .{ count, skip });
     try bw.writeByte(macho.BIND_OPCODE_DO_BIND_ULEB_TIMES_SKIPPING_ULEB);
     try bw.writeLeb128(count);
     try bw.writeLeb128(skip);
 }
 
-fn addAddr(addr: u64, bw: *std.io.BufferedWriter) anyerror!void {
+fn addAddr(addr: u64, bw: *std.io.BufferedWriter) std.io.Writer.Error!void {
     log.debug(">>> add: {x}", .{addr});
     try bw.writeByte(macho.BIND_OPCODE_ADD_ADDR_ULEB);
     try bw.writeLeb128(addr);
 }
 
-fn done(bw: *std.io.BufferedWriter) anyerror!void {
+fn done(bw: *std.io.BufferedWriter) std.io.Writer.Error!void {
     log.debug(">>> done", .{});
     try bw.writeByte(macho.BIND_OPCODE_DONE);
 }
diff --git a/src/link/MachO/eh_frame.zig b/src/link/MachO/eh_frame.zig
index 3371ec7d027f4286f5ccc79319949afbc039da50..3993e9fc97a913b7309ceafccb52a0c9862a7f5a 100644
--- a/src/link/MachO/eh_frame.zig
+++ b/src/link/MachO/eh_frame.zig
@@ -104,7 +104,7 @@ pub const Cie = struct {
         macho_file: *MachO,
     };
 
-    fn format2(ctx: FormatContext, bw: *std.io.BufferedWriter, comptime unused_fmt_string: []const u8) anyerror!void {
+    fn format2(ctx: FormatContext, bw: *std.io.BufferedWriter, comptime unused_fmt_string: []const u8) std.io.Writer.Error!void {
         _ = unused_fmt_string;
         const cie = ctx.cie;
         try bw.print("@{x} : size({x})", .{
@@ -250,7 +250,7 @@ pub const Fde = struct {
         macho_file: *MachO,
     };
 
-    fn format2(ctx: FormatContext, bw: *std.io.BufferedWriter, comptime unused_fmt_string: []const u8) anyerror!void {
+    fn format2(ctx: FormatContext, bw: *std.io.BufferedWriter, comptime unused_fmt_string: []const u8) std.io.Writer.Error!void {
         _ = unused_fmt_string;
         const fde = ctx.fde;
         const macho_file = ctx.macho_file;
diff --git a/src/link/MachO/file.zig b/src/link/MachO/file.zig
index 9d438920abd8d704b9945296829eb5c6d760f574..ed43e2e50b80feaba73415c8dd39c25915723288 100644
--- a/src/link/MachO/file.zig
+++ b/src/link/MachO/file.zig
@@ -14,7 +14,7 @@ pub const File = union(enum) {
         return .{ .data = file };
     }
 
-    fn formatPath(file: File, bw: *std.io.BufferedWriter, comptime unused_fmt_string: []const u8) anyerror!void {
+    fn formatPath(file: File, bw: *std.io.BufferedWriter, comptime unused_fmt_string: []const u8) std.io.Writer.Error!void {
         _ = unused_fmt_string;
         switch (file) {
             .zig_object => |zo| try bw.writeAll(zo.basename),
@@ -322,7 +322,7 @@ pub const File = union(enum) {
         };
     }
 
-    pub fn writeAr(file: File, bw: *std.io.BufferedWriter, ar_format: Archive.Format, macho_file: *MachO) anyerror!void {
+    pub fn writeAr(file: File, bw: *std.io.BufferedWriter, ar_format: Archive.Format, macho_file: *MachO) std.io.Writer.Error!void {
         return switch (file) {
             .dylib, .internal => unreachable,
             .zig_object => |x| x.writeAr(bw, ar_format),
diff --git a/src/link/MachO/load_commands.zig b/src/link/MachO/load_commands.zig
index 77c6a1ce537ded4dafc9e5d51ec9f6b825690fa3..c0cb1ca33de8a18ce23419e33b1b163bf096e732 100644
--- a/src/link/MachO/load_commands.zig
+++ b/src/link/MachO/load_commands.zig
@@ -180,7 +180,7 @@ pub fn calcMinHeaderPadSize(macho_file: *MachO) !u32 {
     return offset;
 }
 
-pub fn writeDylinkerLC(bw: *std.io.BufferedWriter) anyerror!void {
+pub fn writeDylinkerLC(bw: *std.io.BufferedWriter) std.io.Writer.Error!void {
     const name_len = mem.sliceTo(default_dyld_path, 0).len;
     const cmdsize = @as(u32, @intCast(mem.alignForward(
         u64,
@@ -268,7 +268,7 @@ pub fn writeRpathLC(bw: *std.io.BufferedWriter, rpath: []const u8) !void {
     try bw.splatByteAll(0, cmdsize - @sizeOf(macho.rpath_command) - rpath_len);
 }
 
-pub fn writeVersionMinLC(bw: *std.io.BufferedWriter, platform: MachO.Platform, sdk_version: ?std.SemanticVersion) anyerror!void {
+pub fn writeVersionMinLC(bw: *std.io.BufferedWriter, platform: MachO.Platform, sdk_version: ?std.SemanticVersion) std.io.Writer.Error!void {
     const cmd: macho.LC = switch (platform.os_tag) {
         .macos => .VERSION_MIN_MACOSX,
         .ios => .VERSION_MIN_IPHONEOS,
@@ -286,7 +286,7 @@ pub fn writeVersionMinLC(bw: *std.io.BufferedWriter, platform: MachO.Platform, s
     }));
 }
 
-pub fn writeBuildVersionLC(bw: *std.io.BufferedWriter, platform: MachO.Platform, sdk_version: ?std.SemanticVersion) anyerror!void {
+pub fn writeBuildVersionLC(bw: *std.io.BufferedWriter, platform: MachO.Platform, sdk_version: ?std.SemanticVersion) std.io.Writer.Error!void {
     const cmdsize = @sizeOf(macho.build_version_command) + @sizeOf(macho.build_tool_version);
     try bw.writeStruct(macho.build_version_command{
         .cmdsize = cmdsize,
diff --git a/src/link/Wasm.zig b/src/link/Wasm.zig
index bf102b45c572dacf3c7106c8d9e51f40f13d9628..b16a8bfd070655c928cff410b9809bd5ad49afbb 100644
--- a/src/link/Wasm.zig
+++ b/src/link/Wasm.zig
@@ -2125,7 +2125,7 @@ pub const FunctionType = extern struct {
         wasm: *const Wasm,
         ft: FunctionType,
 
-        pub fn format(self: Formatter, bw: *std.io.BufferedWriter, comptime format_string: []const u8) anyerror!void {
+        pub fn format(self: Formatter, bw: *std.io.BufferedWriter, comptime format_string: []const u8) std.io.Writer.Error!void {
             if (format_string.len != 0) std.fmt.invalidFmtError(format_string, self);
             const params = self.ft.params.slice(self.wasm);
             const returns = self.ft.returns.slice(self.wasm);
@@ -2905,7 +2905,7 @@ pub const Feature = packed struct(u8) {
         @"=",
     };
 
-    pub fn format(feature: Feature, bw: *std.io.BufferedWriter, comptime fmt: []const u8) anyerror!void {
+    pub fn format(feature: Feature, bw: *std.io.BufferedWriter, comptime fmt: []const u8) std.io.Writer.Error!void {
         _ = fmt;
         try bw.print("{s} {s}", .{ @tagName(feature.prefix), @tagName(feature.tag) });
     }
diff --git a/src/link/Wasm/Flush.zig b/src/link/Wasm/Flush.zig
index 8e8fdab94816b0526e9a17703259d6b68ae475d8..f5a9ed43230926dcbeb11d13a50d0dec45fec272 100644
--- a/src/link/Wasm/Flush.zig
+++ b/src/link/Wasm/Flush.zig
@@ -1065,7 +1065,7 @@ fn emitNameSection(
     wasm: *Wasm,
     aw: *std.io.AllocatingWriter,
     data_segment_groups: []const DataSegmentGroup,
-) anyerror!void {
+) !void {
     const f = &wasm.flush_buffer;
     const bw = &aw.buffered_writer;
     const header_offset = try reserveSectionHeader(bw);
@@ -1127,7 +1127,7 @@ fn emitNameSection(
     }
 }
 
-fn emitFeaturesSection(aw: *std.io.AllocatingWriter, target: *const std.Target) anyerror!void {
+fn emitFeaturesSection(aw: *std.io.AllocatingWriter, target: *const std.Target) Allocator.Error!void {
     const feature_count = target.cpu.features.count();
     if (feature_count == 0) return;
 
@@ -1251,7 +1251,7 @@ fn wantSegmentMerge(
 /// section id + fixed leb contents size + fixed leb vector length
 const vec_section_header_size = section_header_size + size_header_size;
 
-fn reserveVecSectionHeader(bw: *std.io.BufferedWriter) anyerror!u32 {
+fn reserveVecSectionHeader(bw: *std.io.BufferedWriter) std.io.Writer.Error!u32 {
     const offset = bw.count;
     _ = try bw.writableSlice(vec_section_header_size);
     bw.advance(vec_section_header_size);
@@ -1272,7 +1272,7 @@ fn replaceVecSectionHeader(
 
 const section_header_size = 1 + size_header_size;
 
-fn reserveSectionHeader(bw: *std.io.BufferedWriter) anyerror!u32 {
+fn reserveSectionHeader(bw: *std.io.BufferedWriter) std.io.Writer.Error!u32 {
     const offset = bw.count;
     _ = try bw.writableSlice(section_header_size);
     bw.advance(section_header_size);
@@ -1287,7 +1287,7 @@ fn replaceSectionHeader(aw: *std.io.AllocatingWriter, offset: u32, section: u8)
 
 const size_header_size = 5;
 
-fn reserveSizeHeader(bw: *std.io.BufferedWriter) anyerror!u32 {
+fn reserveSizeHeader(bw: *std.io.BufferedWriter) std.io.Writer.Error!u32 {
     const offset = bw.count;
     _ = try bw.writableSlice(size_header_size);
     bw.advance(size_header_size);
@@ -1299,7 +1299,7 @@ fn replaceSizeHeader(aw: *std.io.AllocatingWriter, offset: u32) void {
     std.leb.writeUnsignedFixed(5, header[0..5], @intCast(aw.buffered_writer.count - offset - size_header_size));
 }
 
-fn emitLimits(bw: *std.io.BufferedWriter, limits: std.wasm.Limits) anyerror!void {
+fn emitLimits(bw: *std.io.BufferedWriter, limits: std.wasm.Limits) std.io.Writer.Error!void {
     try bw.writeByte(@bitCast(limits.flags));
     try bw.writeLeb128(limits.min);
     if (limits.flags.has_max) try bw.writeLeb128(limits.max);
@@ -1310,7 +1310,7 @@ fn emitMemoryImport(
     bw: *std.io.BufferedWriter,
     name_index: String,
     memory_import: *const Wasm.MemoryImport,
-) anyerror!void {
+) std.io.Writer.Error!void {
     const module_name = memory_import.module_name.slice(wasm);
     try bw.writeLeb128(module_name.len);
     try bw.writeAll(module_name);
@@ -1323,7 +1323,7 @@ fn emitMemoryImport(
     try emitLimits(bw, memory_import.limits());
 }
 
-pub fn emitInit(bw: *std.io.BufferedWriter, init_expr: std.wasm.InitExpression) anyerror!void {
+pub fn emitInit(bw: *std.io.BufferedWriter, init_expr: std.wasm.InitExpression) std.io.Writer.Error!void {
     switch (init_expr) {
         inline else => |val, tag| {
             try bw.writeByte(@intFromEnum(@field(std.wasm.Opcode, @tagName(tag))));
@@ -1341,12 +1341,12 @@ pub fn emitInit(bw: *std.io.BufferedWriter, init_expr: std.wasm.InitExpression)
     try bw.writeByte(@intFromEnum(std.wasm.Opcode.end));
 }
 
-pub fn emitExpr(wasm: *const Wasm, bw: *std.io.BufferedWriter, expr: Wasm.Expr) anyerror!void {
+pub fn emitExpr(wasm: *const Wasm, bw: *std.io.BufferedWriter, expr: Wasm.Expr) std.io.Writer.Error!void {
     const slice = expr.slice(wasm);
     try bw.writeAll(slice[0 .. slice.len + 1]); // +1 to include end opcode
 }
 
-fn emitSegmentInfo(wasm: *Wasm, aw: *std.io.BufferedWriter) anyerror!void {
+fn emitSegmentInfo(wasm: *Wasm, aw: *std.io.BufferedWriter) std.io.Writer.Error!void {
     const bw = &aw.buffered_writer;
     const header_offset = try reserveSectionHeader(bw);
     defer replaceSectionHeader(aw, header_offset, @intFromEnum(Wasm.SubsectionType.segment_info));
@@ -1371,7 +1371,7 @@ fn emitTagNameTable(
     tag_name_bytes: []const u8,
     base: u32,
     comptime Int: type,
-) anyerror!void {
+) std.io.Writer.Error!void {
     for (tag_name_offs) |off| {
         const name_len: u32 = @intCast(mem.indexOfScalar(u8, tag_name_bytes[off..], 0).?);
         try bw.writeInt(Int, base + off, .little);
@@ -1539,7 +1539,7 @@ fn reloc_leb_type(code: []u8, index: FuncTypeIndex) void {
     std.leb.writeUnsignedFixed(5, code[0..5], @intFromEnum(index));
 }
 
-fn emitCallCtorsFunction(wasm: *const Wasm, bw: *std.io.BufferedWriter) anyerror!void {
+fn emitCallCtorsFunction(wasm: *const Wasm, bw: *std.io.BufferedWriter) std.io.Writer.Error!void {
     try bw.writeUleb128(0); // no locals
     for (wasm.object_init_funcs.items) |init_func| {
         const func = init_func.function_index.ptr(wasm);
@@ -1558,7 +1558,7 @@ fn emitCallCtorsFunction(wasm: *const Wasm, bw: *std.io.BufferedWriter) anyerror
     try bw.writeByte(@intFromEnum(std.wasm.Opcode.end)); // end function body
 }
 
-fn emitInitMemoryFunction(wasm: *const Wasm, bw: *std.io.BufferedWriter, virtual_addrs: *const VirtualAddrs) anyerror!void {
+fn emitInitMemoryFunction(wasm: *const Wasm, bw: *std.io.BufferedWriter, virtual_addrs: *const VirtualAddrs) std.io.Writer.Error!void {
     const comp = wasm.base.comp;
     const shared_memory = comp.config.shared_memory;
 
@@ -1710,7 +1710,7 @@ fn emitInitMemoryFunction(wasm: *const Wasm, bw: *std.io.BufferedWriter, virtual
     try bw.writeByte(@intFromEnum(std.wasm.Opcode.end));
 }
 
-fn emitInitTlsFunction(wasm: *const Wasm, bw: *std.io.BufferedWriter) anyerror!void {
+fn emitInitTlsFunction(wasm: *const Wasm, bw: *std.io.BufferedWriter) std.io.Writer.Error!void {
     const comp = wasm.base.comp;
     assert(comp.config.shared_memory);
 
@@ -1888,7 +1888,7 @@ fn emitTagNameFunction(
     try bw.writeByte(@intFromEnum(std.wasm.Opcode.end));
 }
 
-fn appendGlobal(bw: *std.io.BufferedWriter, mutable: bool, val: u32) anyerror!void {
+fn appendGlobal(bw: *std.io.BufferedWriter, mutable: bool, val: u32) std.io.Writer.Error!void {
     try bw.writeAll(&.{
         @intFromEnum(std.wasm.Valtype.i32),
         @intFromBool(mutable),
diff --git a/src/link/Wasm/Object.zig b/src/link/Wasm/Object.zig
index 2f7d409390767c70b0d73558729962bbcef839ac..a630453548f5111e2b297aed3667da2ab45fe30c 100644
--- a/src/link/Wasm/Object.zig
+++ b/src/link/Wasm/Object.zig
@@ -259,7 +259,7 @@ pub fn parse(
     ss: *ScratchSpace,
     must_link: bool,
     gc_sections: bool,
-) anyerror!Object {
+) !Object {
     const comp = wasm.base.comp;
     const gpa = comp.gpa;
     const diags = &comp.link_diags;
@@ -1402,7 +1402,7 @@ pub fn parse(
 /// Based on the "features" custom section, parses it into a list of
 /// features that tell the linker what features were enabled and may be mandatory
 /// to be able to link.
-fn parseFeatures(wasm: *Wasm, br: *std.io.BufferedReader, path: Path) anyerror!Wasm.Feature.Set {
+fn parseFeatures(wasm: *Wasm, br: *std.io.BufferedReader, path: Path) error{ OutOfMemory, LinkFailure }!Wasm.Feature.Set {
     const gpa = wasm.base.comp.gpa;
     const diags = &wasm.base.comp.link_diags;
     const features_len = try br.takeLeb128(u32);
@@ -1430,7 +1430,7 @@ fn parseFeatures(wasm: *Wasm, br: *std.io.BufferedReader, path: Path) anyerror!W
     return .fromString(try wasm.internString(@ptrCast(feature_buffer)));
 }
 
-fn readLimits(br: *std.io.BufferedReader) anyerror!std.wasm.Limits {
+fn readLimits(br: *std.io.BufferedReader) std.io.Reader.Error!std.wasm.Limits {
     const flags: std.wasm.Limits.Flags = @bitCast(try br.takeByte());
     const min = try br.takeLeb128(u32);
     const max = if (flags.has_max) try br.takeLeb128(u32) else 0;
@@ -1441,13 +1441,13 @@ fn readLimits(br: *std.io.BufferedReader) anyerror!std.wasm.Limits {
     };
 }
 
-fn readInit(wasm: *Wasm, br: *std.io.BufferedReader) anyerror!Wasm.Expr {
+fn readInit(wasm: *Wasm, br: *std.io.BufferedReader) std.io.Reader.Error!Wasm.Expr {
     const start = br.seek;
     try skipInit(br); // one after the end opcode
     return wasm.addExpr(br.storageBuffer()[start..br.seek]);
 }
 
-pub fn skipInit(br: *std.io.BufferedReader) anyerror!void {
+pub fn skipInit(br: *std.io.BufferedReader) std.io.Reader.Error!void {
     switch (try br.takeEnum(std.wasm.Opcode, .little)) {
         .i32_const => _ = try br.takeLeb128(i32),
         .i64_const => _ = try br.takeLeb128(i64),
diff --git a/src/link/riscv.zig b/src/link/riscv.zig
index c45d9efb72757116aa650c7a59e2bee2d1b67130..a6bd107881ce8cc6266ecff8546df5b1c7fb8835 100644
--- a/src/link/riscv.zig
+++ b/src/link/riscv.zig
@@ -1,4 +1,4 @@
-pub fn writeSetSub6(comptime op: enum { set, sub }, addend: anytype, bw: *std.io.BufferedWriter) anyerror!void {
+pub fn writeSetSub6(comptime op: enum { set, sub }, addend: anytype, bw: *std.io.BufferedWriter) std.io.Writer.Error!void {
     const mask: u8 = 0b11_000000;
     const actual: i8 = @truncate(addend);
     const old_value = (try bw.writableSlice(1))[0];
@@ -9,7 +9,7 @@ pub fn writeSetSub6(comptime op: enum { set, sub }, addend: anytype, bw: *std.io
     try bw.writeByte(new_value);
 }
 
-pub fn writeSetSubUleb(comptime op: enum { set, sub }, addend: i64, bw: *std.io.BufferedWriter) anyerror!void {
+pub fn writeSetSubUleb(comptime op: enum { set, sub }, addend: i64, bw: *std.io.BufferedWriter) std.io.Writer.Error!void {
     switch (op) {
         .set => try overwriteUleb(@intCast(addend), bw),
         .sub => {
@@ -21,7 +21,7 @@ pub fn writeSetSubUleb(comptime op: enum { set, sub }, addend: i64, bw: *std.io.
     }
 }
 
-fn overwriteUleb(new_value: u64, bw: *std.io.BufferedWriter) anyerror!void {
+fn overwriteUleb(new_value: u64, bw: *std.io.BufferedWriter) std.io.Writer.Error!void {
     var value: u64 = new_value;
     while (true) {
         const byte = (try bw.writableSlice(1))[0];
@@ -36,7 +36,7 @@ pub fn writeAddend(
     comptime op: enum { add, sub },
     value: anytype,
     bw: *std.io.BufferedWriter,
-) anyerror!void {
+) std.io.Writer.Error!void {
     const n = @divExact(@bitSizeOf(Int), 8);
     var V: Int = mem.readInt(Int, (try bw.writableSlice(n))[0..n], .little);
     const addend: Int = @truncate(value);
diff --git a/src/link/table_section.zig b/src/link/table_section.zig
index 0309acd3f0581fe3bf545e147fd7703299cfb2d9..ae2ccb7fbedc6665f3437574bb05ec36971bc8a1 100644
--- a/src/link/table_section.zig
+++ b/src/link/table_section.zig
@@ -39,7 +39,7 @@ pub fn TableSection(comptime Entry: type) type {
             return self.entries.items.len;
         }
 
-        pub fn format(self: Self, bw: *std.io.BufferedWriter, comptime unused_format_string: []const u8) anyerror!void {
+        pub fn format(self: Self, bw: *std.io.BufferedWriter, comptime unused_format_string: []const u8) std.io.Writer.Error!void {
             comptime assert(unused_format_string.len == 0);
             try bw.writeAll("TableSection:\n");
             for (self.entries.items, 0..) |entry, i| {
diff --git a/src/print_targets.zig b/src/print_targets.zig
index 4af544cf89251b249a5c87f2a7d8a38e0b2a26cf..b089fae024bc151ff23dddb34a897e7eef09ed44 100644
--- a/src/print_targets.zig
+++ b/src/print_targets.zig
@@ -11,7 +11,7 @@ const assert = std.debug.assert;
 const glibc = @import("libs/glibc.zig");
 const introspect = @import("introspect.zig");
 
-pub fn cmdTargets(arena: Allocator, args: []const []const u8) anyerror!void {
+pub fn cmdTargets(arena: Allocator, args: []const []const u8) !void {
     _ = args;
     const host = std.zig.resolveTargetQueryOrFatal(.{});
     var buffer: [1024]u8 = undefined;
@@ -20,7 +20,7 @@ pub fn cmdTargets(arena: Allocator, args: []const []const u8) anyerror!void {
     try bw.flush();
 }
 
-fn print(arena: Allocator, output: *std.io.BufferedWriter, host: *const Target) anyerror!void {
+fn print(arena: Allocator, output: *std.io.BufferedWriter, host: *const Target) std.io.Writer.Error!void {
     var zig_lib_directory = introspect.findZigLibDir(arena) catch |err| {
         fatal("unable to find zig installation directory: {s}\n", .{@errorName(err)});
     };
diff --git a/src/print_value.zig b/src/print_value.zig
index 6abcbc39aeb521bdcf500659d3997c27be7ba067..c8f2b09e7ae323532260ba1dffc0a7bb84dfc11b 100644
--- a/src/print_value.zig
+++ b/src/print_value.zig
@@ -20,7 +20,7 @@ pub const FormatContext = struct {
     depth: u8,
 };
 
-pub fn formatSema(ctx: FormatContext, bw: *std.io.BufferedWriter, comptime fmt: []const u8) anyerror!void {
+pub fn formatSema(ctx: FormatContext, bw: *std.io.BufferedWriter, comptime fmt: []const u8) std.io.Writer.Error!void {
     const sema = ctx.opt_sema.?;
     comptime std.debug.assert(fmt.len == 0);
     return print(ctx.val, bw, ctx.depth, ctx.pt, sema) catch |err| switch (err) {
@@ -31,7 +31,7 @@ pub fn formatSema(ctx: FormatContext, bw: *std.io.BufferedWriter, comptime fmt:
     };
 }
 
-pub fn format(ctx: FormatContext, bw: *std.io.BufferedWriter, comptime fmt: []const u8) anyerror!void {
+pub fn format(ctx: FormatContext, bw: *std.io.BufferedWriter, comptime fmt: []const u8) std.io.Writer.Error!void {
     std.debug.assert(ctx.opt_sema == null);
     comptime std.debug.assert(fmt.len == 0);
     return print(ctx.val, bw, ctx.depth, ctx.pt, null) catch |err| switch (err) {
@@ -47,7 +47,7 @@ pub fn print(
     level: u8,
     pt: Zcu.PerThread,
     opt_sema: ?*Sema,
-) anyerror!void {
+) std.io.Writer.Error!void {
     const zcu = pt.zcu;
     const ip = &zcu.intern_pool;
     switch (ip.indexToKey(val.toIntern())) {
@@ -190,7 +190,7 @@ fn printAggregate(
     level: u8,
     pt: Zcu.PerThread,
     opt_sema: ?*Sema,
-) anyerror!void {
+) std.io.Writer.Error!void {
     if (level == 0) {
         if (is_ref) try bw.writeByte('&');
         return bw.writeAll(".{ ... }");
@@ -276,7 +276,7 @@ fn printPtr(
     level: u8,
     pt: Zcu.PerThread,
     opt_sema: ?*Sema,
-) anyerror!void {
+) std.io.Writer.Error!void {
     const ptr = switch (pt.zcu.intern_pool.indexToKey(ptr_val.toIntern())) {
         .undef => return bw.writeAll("undefined"),
         .ptr => |ptr| ptr,
@@ -336,7 +336,7 @@ pub fn printPtrDerivation(
     /// The maximum recursion depth. We can never recurse infinitely here, but the depth can be arbitrary,
     /// so at this depth we just write "..." to prevent stack overflow.
     ptr_depth: u8,
-) anyerror!Value.PointerDeriveStep {
+) std.io.Writer.Error!Value.PointerDeriveStep {
     const zcu = pt.zcu;
     const ip = &zcu.intern_pool;
 
diff --git a/src/print_zir.zig b/src/print_zir.zig
index d26057845bdf580b73e1e491c35dfd248b9540ea..f65f54a4d6389e17982264deefba504741bcc6a1 100644
--- a/src/print_zir.zig
+++ b/src/print_zir.zig
@@ -10,7 +10,7 @@ const Zcu = @import("Zcu.zig");
 const LazySrcLoc = Zcu.LazySrcLoc;
 
 /// Write human-readable, debug formatted ZIR code.
-pub fn renderAsText(gpa: Allocator, tree: ?Ast, zir: Zir, bw: *std.io.BufferedWriter) anyerror!void {
+pub fn renderAsText(gpa: Allocator, tree: ?Ast, zir: Zir, bw: *std.io.BufferedWriter) !void {
     var arena = std.heap.ArenaAllocator.init(gpa);
     defer arena.deinit();
 
@@ -176,11 +176,13 @@ const Writer = struct {
         }
     } = .{},
 
+    const Error = std.io.Writer.Error;
+
     fn writeInstToStream(
         self: *Writer,
         stream: *std.io.BufferedWriter,
         inst: Zir.Inst.Index,
-    ) anyerror!void {
+    ) Error!void {
         const tags = self.code.instructions.items(.tag);
         const tag = tags[@intFromEnum(inst)];
         try stream.print("= {s}(", .{@tagName(tags[@intFromEnum(inst)])});
@@ -633,7 +635,7 @@ const Writer = struct {
         self: *Writer,
         stream: *std.io.BufferedWriter,
         inst: Zir.Inst.Index,
-    ) anyerror!void {
+    ) Error!void {
         const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].un_node;
         try self.writeInstRef(stream, inst_data.operand);
         try stream.writeAll(") ");
@@ -644,7 +646,7 @@ const Writer = struct {
         self: *Writer,
         stream: *std.io.BufferedWriter,
         inst: Zir.Inst.Index,
-    ) anyerror!void {
+    ) Error!void {
         const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].un_tok;
         try self.writeInstRef(stream, inst_data.operand);
         try stream.writeAll(") ");
@@ -655,7 +657,7 @@ const Writer = struct {
         self: *Writer,
         stream: *std.io.BufferedWriter,
         inst: Zir.Inst.Index,
-    ) anyerror!void {
+    ) Error!void {
         const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;
         const extra = self.code.extraData(Zir.Inst.ValidateDestructure, inst_data.payload_index).data;
         try self.writeInstRef(stream, extra.operand);
@@ -669,7 +671,7 @@ const Writer = struct {
         self: *Writer,
         stream: *std.io.BufferedWriter,
         inst: Zir.Inst.Index,
-    ) anyerror!void {
+    ) Error!void {
         const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;
         const extra = self.code.extraData(Zir.Inst.ArrayInit, inst_data.payload_index).data;
         try self.writeInstRef(stream, extra.ty);
@@ -681,7 +683,7 @@ const Writer = struct {
         self: *Writer,
         stream: *std.io.BufferedWriter,
         inst: Zir.Inst.Index,
-    ) anyerror!void {
+    ) Error!void {
         const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;
         const extra = self.code.extraData(Zir.Inst.ArrayTypeSentinel, inst_data.payload_index).data;
         try self.writeInstRef(stream, extra.len);
@@ -697,7 +699,7 @@ const Writer = struct {
         self: *Writer,
         stream: *std.io.BufferedWriter,
         inst: Zir.Inst.Index,
-    ) anyerror!void {
+    ) Error!void {
         const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].ptr_type;
         const str_allowzero = if (inst_data.flags.is_allowzero) "allowzero, " else "";
         const str_const = if (!inst_data.flags.is_mutable) "const, " else "";
@@ -780,7 +782,7 @@ const Writer = struct {
         self: *Writer,
         stream: *std.io.BufferedWriter,
         inst: Zir.Inst.Index,
-    ) anyerror!void {
+    ) Error!void {
         const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].str;
         const str = inst_data.get(self.code);
         try stream.print("\"{f}\")", .{std.zig.fmtEscapes(str)});
@@ -1185,7 +1187,7 @@ const Writer = struct {
         self: *Writer,
         stream: *std.io.BufferedWriter,
         inst: Zir.Inst.Index,
-    ) anyerror!void {
+    ) Error!void {
         const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].inst_node;
         try self.writeInstIndex(stream, inst_data.inst);
         try stream.writeAll(") ");
@@ -2238,7 +2240,7 @@ const Writer = struct {
         self: *Writer,
         stream: *std.io.BufferedWriter,
         inst: Zir.Inst.Index,
-    ) anyerror!void {
+    ) Error!void {
         const src_node = self.code.instructions.items(.data)[@intFromEnum(inst)].node;
         try stream.writeAll(") ");
         try self.writeSrcNode(stream, src_node);
@@ -2248,7 +2250,7 @@ const Writer = struct {
         self: *Writer,
         stream: *std.io.BufferedWriter,
         inst: Zir.Inst.Index,
-    ) anyerror!void {
+    ) Error!void {
         const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].str_tok;
         const str = inst_data.get(self.code);
         try stream.print("\"{f}\") ", .{std.zig.fmtEscapes(str)});
diff --git a/src/print_zoir.zig b/src/print_zoir.zig
index a9118fc632587b1dc4edeead36fe4321f1daa087..69ce6f5b05380ccd2868e36fbdd19f9a65109a9d 100644
--- a/src/print_zoir.zig
+++ b/src/print_zoir.zig
@@ -1,4 +1,4 @@
-pub fn renderToWriter(zoir: Zoir, arena: Allocator, w: *std.io.BufferedWriter) anyerror!void {
+pub fn renderToWriter(zoir: Zoir, arena: Allocator, w: *std.io.BufferedWriter) error{ WriteFailed, OutOfMemory }!void {
     assert(!zoir.hasCompileErrors());
 
     const bytes_per_node = comptime n: {
@@ -37,7 +37,7 @@ pub fn renderToWriter(zoir: Zoir, arena: Allocator, w: *std.io.BufferedWriter) a
         .indent = 0,
     };
 
-    return @errorCast(pz.renderRoot());
+    return pz.renderRoot();
 }
 
 const PrintZon = struct {
@@ -46,12 +46,14 @@ const PrintZon = struct {
     zoir: Zoir,
     indent: u32,
 
-    fn renderRoot(pz: *PrintZon) anyerror!void {
+    const Error = std.io.Writer.Error;
+
+    fn renderRoot(pz: *PrintZon) Error!void {
         try pz.renderNode(.root);
         try pz.w.writeByte('\n');
     }
 
-    fn renderNode(pz: *PrintZon, node: Zoir.Node.Index) anyerror!void {
+    fn renderNode(pz: *PrintZon, node: Zoir.Node.Index) Error!void {
         const zoir = pz.zoir;
         try pz.w.print("%{d} = ", .{@intFromEnum(node)});
         switch (node.get(zoir)) {