fix code broken from previous commit

31 files changed, 260 insertions, 48 deletions

diff --git a/src/AstGen.zig b/src/AstGen.zig
index 84f06e5423..ec6f9518b1 100644
--- a/src/AstGen.zig
+++ b/src/AstGen.zig
@@ -925,6 +925,7 @@ fn suspendExpr(
     rl: ResultLoc,
     node: ast.Node.Index,
 ) InnerError!Zir.Inst.Ref {
+    _ = rl;
     const astgen = gz.astgen;
     const gpa = astgen.gpa;
     const tree = astgen.tree;
@@ -1208,6 +1209,7 @@ fn arrayInitExprRlNone(
     elements: []const ast.Node.Index,
     tag: Zir.Inst.Tag,
 ) InnerError!Zir.Inst.Ref {
+    _ = rl;
     const astgen = gz.astgen;
     const gpa = astgen.gpa;
     const elem_list = try gpa.alloc(Zir.Inst.Ref, elements.len);
@@ -1233,6 +1235,9 @@ fn arrayInitExprRlTy(
     elem_ty_inst: Zir.Inst.Ref,
     tag: Zir.Inst.Tag,
 ) InnerError!Zir.Inst.Ref {
+    _ = rl;
+    _ = array_ty_inst;
+    _ = elem_ty_inst;
     const astgen = gz.astgen;
     const gpa = astgen.gpa;
 
@@ -1259,6 +1264,7 @@ fn arrayInitExprRlPtr(
     elements: []const ast.Node.Index,
     result_ptr: Zir.Inst.Ref,
 ) InnerError!Zir.Inst.Ref {
+    _ = rl;
     const astgen = gz.astgen;
     const gpa = astgen.gpa;
 
@@ -1368,6 +1374,7 @@ fn structInitExprRlNone(
     struct_init: ast.full.StructInit,
     tag: Zir.Inst.Tag,
 ) InnerError!Zir.Inst.Ref {
+    _ = rl;
     const astgen = gz.astgen;
     const gpa = astgen.gpa;
     const tree = astgen.tree;
@@ -1403,6 +1410,7 @@ fn structInitExprRlPtr(
     struct_init: ast.full.StructInit,
     result_ptr: Zir.Inst.Ref,
 ) InnerError!Zir.Inst.Ref {
+    _ = rl;
     const astgen = gz.astgen;
     const gpa = astgen.gpa;
     const tree = astgen.tree;
@@ -1439,6 +1447,7 @@ fn structInitExprRlTy(
     ty_inst: Zir.Inst.Ref,
     tag: Zir.Inst.Tag,
 ) InnerError!Zir.Inst.Ref {
+    _ = rl;
     const astgen = gz.astgen;
     const gpa = astgen.gpa;
     const tree = astgen.tree;
@@ -1781,6 +1790,7 @@ fn blockExprStmts(
     node: ast.Node.Index,
     statements: []const ast.Node.Index,
 ) !void {
+    _ = node;
     const astgen = gz.astgen;
     const tree = astgen.tree;
     const node_tags = tree.nodes.items(.tag);
@@ -2117,6 +2127,7 @@ fn genDefers(
     inner_scope: *Scope,
     err_code: Zir.Inst.Ref,
 ) InnerError!void {
+    _ = err_code;
     const astgen = gz.astgen;
     const tree = astgen.tree;
     const node_datas = tree.nodes.items(.data);
@@ -2201,6 +2212,7 @@ fn deferStmt(
     block_arena: *Allocator,
     scope_tag: Scope.Tag,
 ) InnerError!*Scope {
+    _ = gz;
     const defer_scope = try block_arena.create(Scope.Defer);
     defer_scope.* = .{
         .base = .{ .tag = scope_tag },
@@ -4703,6 +4715,8 @@ fn finishThenElseBlock(
     then_break_block: Zir.Inst.Index,
     break_tag: Zir.Inst.Tag,
 ) InnerError!Zir.Inst.Ref {
+    _ = then_src;
+    _ = else_src;
     // We now have enough information to decide whether the result instruction should
     // be communicated via result location pointer or break instructions.
     const strat = rl.strategy(block_scope);
@@ -4886,7 +4900,7 @@ fn ifExpr(
         inst: Zir.Inst.Ref,
         bool_bit: Zir.Inst.Ref,
     } = c: {
-        if (if_full.error_token) |error_token| {
+        if (if_full.error_token) |_| {
             const cond_rl: ResultLoc = if (payload_is_ref) .ref else .none;
             const err_union = try expr(&block_scope, &block_scope.base, cond_rl, if_full.ast.cond_expr);
             const tag: Zir.Inst.Tag = if (payload_is_ref) .is_err_ptr else .is_err;
@@ -4894,7 +4908,7 @@ fn ifExpr(
                 .inst = err_union,
                 .bool_bit = try block_scope.addUnNode(tag, err_union, node),
             };
-        } else if (if_full.payload_token) |payload_token| {
+        } else if (if_full.payload_token) |_| {
             const cond_rl: ResultLoc = if (payload_is_ref) .ref else .none;
             const optional = try expr(&block_scope, &block_scope.base, cond_rl, if_full.ast.cond_expr);
             const tag: Zir.Inst.Tag = if (payload_is_ref) .is_non_null_ptr else .is_non_null;
@@ -5146,7 +5160,7 @@ fn whileExpr(
         inst: Zir.Inst.Ref,
         bool_bit: Zir.Inst.Ref,
     } = c: {
-        if (while_full.error_token) |error_token| {
+        if (while_full.error_token) |_| {
             const cond_rl: ResultLoc = if (payload_is_ref) .ref else .none;
             const err_union = try expr(&continue_scope, &continue_scope.base, cond_rl, while_full.ast.cond_expr);
             const tag: Zir.Inst.Tag = if (payload_is_ref) .is_err_ptr else .is_err;
@@ -5154,7 +5168,7 @@ fn whileExpr(
                 .inst = err_union,
                 .bool_bit = try continue_scope.addUnNode(tag, err_union, node),
             };
-        } else if (while_full.payload_token) |payload_token| {
+        } else if (while_full.payload_token) |_| {
             const cond_rl: ResultLoc = if (payload_is_ref) .ref else .none;
             const optional = try expr(&continue_scope, &continue_scope.base, cond_rl, while_full.ast.cond_expr);
             const tag: Zir.Inst.Tag = if (payload_is_ref) .is_non_null_ptr else .is_non_null;
@@ -6665,6 +6679,7 @@ fn unionInitRlPtr(
     union_type: Zir.Inst.Ref,
     field_name: Zir.Inst.Ref,
 ) InnerError!Zir.Inst.Ref {
+    _ = rl;
     const union_init_ptr = try parent_gz.addPlNode(.union_init_ptr, node, Zir.Inst.UnionInitPtr{
         .result_ptr = result_ptr,
         .union_type = union_type,
@@ -6753,6 +6768,8 @@ fn bitCastRlPtr(
     result_ptr: Zir.Inst.Ref,
     rhs: ast.Node.Index,
 ) InnerError!Zir.Inst.Ref {
+    _ = rl;
+    _ = scope;
     const casted_result_ptr = try gz.addPlNode(.bitcast_result_ptr, node, Zir.Inst.Bin{
         .lhs = dest_type,
         .rhs = result_ptr,
@@ -8013,6 +8030,7 @@ fn rvalue(
     result: Zir.Inst.Ref,
     src_node: ast.Node.Index,
 ) InnerError!Zir.Inst.Ref {
+    _ = scope;
     switch (rl) {
         .none, .none_or_ref => return result,
         .discard => {
diff --git a/src/Compilation.zig b/src/Compilation.zig
index f73d9410f2..ec8b0c79bb 100644
--- a/src/Compilation.zig
+++ b/src/Compilation.zig
@@ -523,6 +523,7 @@ pub const AllErrors = struct {
         errors: *std.ArrayList(Message),
         msg: []const u8,
     ) !void {
+        _ = arena;
         try errors.append(.{ .plain = .{ .msg = msg } });
     }
 
diff --git a/src/Module.zig b/src/Module.zig
index f2462e704c..e6bed16bbb 100644
--- a/src/Module.zig
+++ b/src/Module.zig
@@ -774,7 +774,10 @@ pub const Fn = struct {
         ir.dumpFn(mod, func);
     }
 
-    pub fn deinit(func: *Fn, gpa: *Allocator) void {}
+    pub fn deinit(func: *Fn, gpa: *Allocator) void {
+        _ = func;
+        _ = gpa;
+    }
 };
 
 pub const Var = struct {
@@ -2209,6 +2212,7 @@ comptime {
 }
 
 pub fn astGenFile(mod: *Module, file: *Scope.File, prog_node: *std.Progress.Node) !void {
+    _ = prog_node;
     const tracy = trace(@src());
     defer tracy.end();
 
@@ -3128,6 +3132,7 @@ pub const ImportFileResult = struct {
 };
 
 pub fn importPkg(mod: *Module, cur_pkg: *Package, pkg: *Package) !ImportFileResult {
+    _ = cur_pkg;
     const gpa = mod.gpa;
 
     // The resolved path is used as the key in the import table, to detect if
@@ -3384,7 +3389,7 @@ fn scanDecl(iter: *ScanDeclIter, decl_sub_index: usize, flags: u4) InnerError!vo
     decl.has_align = has_align;
     decl.has_linksection = has_linksection;
     decl.zir_decl_index = @intCast(u32, decl_sub_index);
-    if (decl.getFunction()) |func| {
+    if (decl.getFunction()) |_| {
         switch (mod.comp.bin_file.tag) {
             .coff => {
                 // TODO Implement for COFF
@@ -3753,6 +3758,7 @@ pub fn analyzeExport(
     errdefer de_gop.value_ptr.* = mod.gpa.shrink(de_gop.value_ptr.*, de_gop.value_ptr.len - 1);
 }
 pub fn constInst(mod: *Module, arena: *Allocator, src: LazySrcLoc, typed_value: TypedValue) !*ir.Inst {
+    _ = mod;
     const const_inst = try arena.create(ir.Inst.Constant);
     const_inst.* = .{
         .base = .{
@@ -4121,6 +4127,7 @@ pub fn floatAdd(
     lhs: Value,
     rhs: Value,
 ) !Value {
+    _ = src;
     switch (float_type.tag()) {
         .f16 => {
             @panic("TODO add __trunctfhf2 to compiler-rt");
@@ -4154,6 +4161,7 @@ pub fn floatSub(
     lhs: Value,
     rhs: Value,
 ) !Value {
+    _ = src;
     switch (float_type.tag()) {
         .f16 => {
             @panic("TODO add __trunctfhf2 to compiler-rt");
@@ -4187,6 +4195,7 @@ pub fn floatDiv(
     lhs: Value,
     rhs: Value,
 ) !Value {
+    _ = src;
     switch (float_type.tag()) {
         .f16 => {
             @panic("TODO add __trunctfhf2 to compiler-rt");
@@ -4220,6 +4229,7 @@ pub fn floatMul(
     lhs: Value,
     rhs: Value,
 ) !Value {
+    _ = src;
     switch (float_type.tag()) {
         .f16 => {
             @panic("TODO add __trunctfhf2 to compiler-rt");
@@ -4253,6 +4263,7 @@ pub fn simplePtrType(
     mutable: bool,
     size: std.builtin.TypeInfo.Pointer.Size,
 ) Allocator.Error!Type {
+    _ = mod;
     if (!mutable and size == .Slice and elem_ty.eql(Type.initTag(.u8))) {
         return Type.initTag(.const_slice_u8);
     }
@@ -4287,6 +4298,7 @@ pub fn ptrType(
     @"volatile": bool,
     size: std.builtin.TypeInfo.Pointer.Size,
 ) Allocator.Error!Type {
+    _ = mod;
     assert(host_size == 0 or bit_offset < host_size * 8);
 
     // TODO check if type can be represented by simplePtrType
@@ -4304,6 +4316,7 @@ pub fn ptrType(
 }
 
 pub fn optionalType(mod: *Module, arena: *Allocator, child_type: Type) Allocator.Error!Type {
+    _ = mod;
     switch (child_type.tag()) {
         .single_const_pointer => return Type.Tag.optional_single_const_pointer.create(
             arena,
@@ -4324,6 +4337,7 @@ pub fn arrayType(
     sentinel: ?Value,
     elem_type: Type,
 ) Allocator.Error!Type {
+    _ = mod;
     if (elem_type.eql(Type.initTag(.u8))) {
         if (sentinel) |some| {
             if (some.eql(Value.initTag(.zero))) {
@@ -4354,6 +4368,7 @@ pub fn errorUnionType(
     error_set: Type,
     payload: Type,
 ) Allocator.Error!Type {
+    _ = mod;
     assert(error_set.zigTypeTag() == .ErrorSet);
     if (error_set.eql(Type.initTag(.anyerror)) and payload.eql(Type.initTag(.void))) {
         return Type.initTag(.anyerror_void_error_union);
diff --git a/src/Sema.zig b/src/Sema.zig
index 73a1cdf27e..ce00578142 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -702,6 +702,7 @@ fn zirBitcastResultPtr(sema: *Sema, block: *Scope.Block, inst: Zir.Inst.Index) I
 }
 
 fn zirCoerceResultPtr(sema: *Sema, block: *Scope.Block, inst: Zir.Inst.Index) InnerError!*Inst {
+    _ = inst;
     const tracy = trace(@src());
     defer tracy.end();
     return sema.mod.fail(&block.base, sema.src, "TODO implement zirCoerceResultPtr", .{});
@@ -776,6 +777,7 @@ fn zirStructDecl(
 }
 
 fn createTypeName(sema: *Sema, block: *Scope.Block, name_strategy: Zir.Inst.NameStrategy) ![:0]u8 {
+    _ = block;
     switch (name_strategy) {
         .anon => {
             // It would be neat to have "struct:line:column" but this name has
@@ -1067,6 +1069,7 @@ fn zirOpaqueDecl(
     inst: Zir.Inst.Index,
     name_strategy: Zir.Inst.NameStrategy,
 ) InnerError!*Inst {
+    _ = name_strategy;
     const tracy = trace(@src());
     defer tracy.end();
 
@@ -1242,6 +1245,7 @@ fn zirArg(sema: *Sema, block: *Scope.Block, inst: Zir.Inst.Index) InnerError!*In
     // TODO check if arg_name shadows a Decl
 
     if (block.inlining) |inlining| {
+        _ = inlining;
         return sema.param_inst_list[arg_index];
     }
 
@@ -1640,6 +1644,7 @@ fn zirStr(sema: *Sema, block: *Scope.Block, inst: Zir.Inst.Index) InnerError!*In
 }
 
 fn zirInt(sema: *Sema, block: *Scope.Block, inst: Zir.Inst.Index) InnerError!*Inst {
+    _ = block;
     const tracy = trace(@src());
     defer tracy.end();
 
@@ -1648,6 +1653,7 @@ fn zirInt(sema: *Sema, block: *Scope.Block, inst: Zir.Inst.Index) InnerError!*In
 }
 
 fn zirIntBig(sema: *Sema, block: *Scope.Block, inst: Zir.Inst.Index) InnerError!*Inst {
+    _ = block;
     const tracy = trace(@src());
     defer tracy.end();
 
@@ -1665,6 +1671,7 @@ fn zirIntBig(sema: *Sema, block: *Scope.Block, inst: Zir.Inst.Index) InnerError!
 }
 
 fn zirFloat(sema: *Sema, block: *Scope.Block, inst: Zir.Inst.Index) InnerError!*Inst {
+    _ = block;
     const arena = sema.arena;
     const inst_data = sema.code.instructions.items(.data)[inst].float;
     const src = inst_data.src();
@@ -1677,6 +1684,7 @@ fn zirFloat(sema: *Sema, block: *Scope.Block, inst: Zir.Inst.Index) InnerError!*
 }
 
 fn zirFloat128(sema: *Sema, block: *Scope.Block, inst: Zir.Inst.Index) InnerError!*Inst {
+    _ = block;
     const arena = sema.arena;
     const inst_data = sema.code.instructions.items(.data)[inst].pl_node;
     const extra = sema.code.extraData(Zir.Inst.Float128, inst_data.payload_index).data;
@@ -2358,6 +2366,7 @@ fn analyzeCall(
 }
 
 fn zirIntType(sema: *Sema, block: *Scope.Block, inst: Zir.Inst.Index) InnerError!*Inst {
+    _ = block;
     const tracy = trace(@src());
     defer tracy.end();
 
@@ -2466,6 +2475,7 @@ fn zirErrorUnionType(sema: *Sema, block: *Scope.Block, inst: Zir.Inst.Index) Inn
 }
 
 fn zirErrorValue(sema: *Sema, block: *Scope.Block, inst: Zir.Inst.Index) InnerError!*Inst {
+    _ = block;
     const tracy = trace(@src());
     defer tracy.end();
 
@@ -2626,6 +2636,7 @@ fn zirMergeErrorSets(sema: *Sema, block: *Scope.Block, inst: Zir.Inst.Index) Inn
 }
 
 fn zirEnumLiteral(sema: *Sema, block: *Scope.Block, inst: Zir.Inst.Index) InnerError!*Inst {
+    _ = block;
     const tracy = trace(@src());
     defer tracy.end();
 
@@ -3056,6 +3067,7 @@ fn funcCommon(
     src_locs: Zir.Inst.Func.SrcLocs,
     opt_lib_name: ?[]const u8,
 ) InnerError!*Inst {
+    _ = inferred_error_set;
     const src: LazySrcLoc = .{ .node_offset = src_node_offset };
     const ret_ty_src: LazySrcLoc = .{ .node_offset_fn_type_ret_ty = src_node_offset };
     const return_type = try sema.resolveType(block, ret_ty_src, zir_return_type);
@@ -3492,6 +3504,8 @@ fn zirSwitchCapture(
     is_multi: bool,
     is_ref: bool,
 ) InnerError!*Inst {
+    _ = is_ref;
+    _ = is_multi;
     const tracy = trace(@src());
     defer tracy.end();
 
@@ -3509,6 +3523,7 @@ fn zirSwitchCaptureElse(
     inst: Zir.Inst.Index,
     is_ref: bool,
 ) InnerError!*Inst {
+    _ = is_ref;
     const tracy = trace(@src());
     defer tracy.end();
 
@@ -4511,12 +4526,15 @@ fn zirImport(sema: *Sema, block: *Scope.Block, inst: Zir.Inst.Index) InnerError!
 }
 
 fn zirShl(sema: *Sema, block: *Scope.Block, inst: Zir.Inst.Index) InnerError!*Inst {
+    _ = block;
+    _ = inst;
     const tracy = trace(@src());
     defer tracy.end();
     return sema.mod.fail(&block.base, sema.src, "TODO implement zirShl", .{});
 }
 
 fn zirShr(sema: *Sema, block: *Scope.Block, inst: Zir.Inst.Index) InnerError!*Inst {
+    _ = inst;
     const tracy = trace(@src());
     defer tracy.end();
     return sema.mod.fail(&block.base, sema.src, "TODO implement zirShr", .{});
@@ -4586,18 +4604,21 @@ fn zirBitwise(
 }
 
 fn zirBitNot(sema: *Sema, block: *Scope.Block, inst: Zir.Inst.Index) InnerError!*Inst {
+    _ = inst;
     const tracy = trace(@src());
     defer tracy.end();
     return sema.mod.fail(&block.base, sema.src, "TODO implement zirBitNot", .{});
 }
 
 fn zirArrayCat(sema: *Sema, block: *Scope.Block, inst: Zir.Inst.Index) InnerError!*Inst {
+    _ = inst;
     const tracy = trace(@src());
     defer tracy.end();
     return sema.mod.fail(&block.base, sema.src, "TODO implement zirArrayCat", .{});
 }
 
 fn zirArrayMul(sema: *Sema, block: *Scope.Block, inst: Zir.Inst.Index) InnerError!*Inst {
+    _ = inst;
     const tracy = trace(@src());
     defer tracy.end();
     return sema.mod.fail(&block.base, sema.src, "TODO implement zirArrayMul", .{});
@@ -5059,6 +5080,7 @@ fn zirTypeInfo(sema: *Sema, block: *Scope.Block, inst: Zir.Inst.Index) InnerErro
 }
 
 fn zirTypeof(sema: *Sema, block: *Scope.Block, inst: Zir.Inst.Index) InnerError!*Inst {
+    _ = block;
     const zir_datas = sema.code.instructions.items(.data);
     const inst_data = zir_datas[inst].un_node;
     const src = inst_data.src();
@@ -5067,6 +5089,7 @@ fn zirTypeof(sema: *Sema, block: *Scope.Block, inst: Zir.Inst.Index) InnerError!
 }
 
 fn zirTypeofElem(sema: *Sema, block: *Scope.Block, inst: Zir.Inst.Index) InnerError!*Inst {
+    _ = block;
     const inst_data = sema.code.instructions.items(.data)[inst].un_node;
     const src = inst_data.src();
     const operand_ptr = try sema.resolveInst(inst_data.operand);
@@ -5504,6 +5527,7 @@ fn zirUnionInitPtr(sema: *Sema, block: *Scope.Block, inst: Zir.Inst.Index) Inner
 }
 
 fn zirStructInit(sema: *Sema, block: *Scope.Block, inst: Zir.Inst.Index, is_ref: bool) InnerError!*Inst {
+    _ = is_ref;
     const mod = sema.mod;
     const gpa = sema.gpa;
     const zir_datas = sema.code.instructions.items(.data);
@@ -5613,18 +5637,21 @@ fn zirStructInit(sema: *Sema, block: *Scope.Block, inst: Zir.Inst.Index, is_ref:
 }
 
 fn zirStructInitAnon(sema: *Sema, block: *Scope.Block, inst: Zir.Inst.Index, is_ref: bool) InnerError!*Inst {
+    _ = is_ref;
     const inst_data = sema.code.instructions.items(.data)[inst].pl_node;
     const src = inst_data.src();
     return sema.mod.fail(&block.base, src, "TODO: Sema.zirStructInitAnon", .{});
 }
 
 fn zirArrayInit(sema: *Sema, block: *Scope.Block, inst: Zir.Inst.Index, is_ref: bool) InnerError!*Inst {
+    _ = is_ref;
     const inst_data = sema.code.instructions.items(.data)[inst].pl_node;
     const src = inst_data.src();
     return sema.mod.fail(&block.base, src, "TODO: Sema.zirArrayInit", .{});
 }
 
 fn zirArrayInitAnon(sema: *Sema, block: *Scope.Block, inst: Zir.Inst.Index, is_ref: bool) InnerError!*Inst {
+    _ = is_ref;
     const inst_data = sema.code.instructions.items(.data)[inst].pl_node;
     const src = inst_data.src();
     return sema.mod.fail(&block.base, src, "TODO: Sema.zirArrayInitAnon", .{});
@@ -6021,6 +6048,7 @@ fn zirAwait(
     inst: Zir.Inst.Index,
     is_nosuspend: bool,
 ) InnerError!*Inst {
+    _ = is_nosuspend;
     const inst_data = sema.code.instructions.items(.data)[inst].un_node;
     const src = inst_data.src();
     return sema.mod.fail(&block.base, src, "TODO: Sema.zirAwait", .{});
@@ -6302,6 +6330,8 @@ fn addSafetyCheck(sema: *Sema, parent_block: *Scope.Block, ok: *Inst, panic_id:
 }
 
 fn safetyPanic(sema: *Sema, block: *Scope.Block, src: LazySrcLoc, panic_id: PanicId) !Zir.Inst.Index {
+    _ = sema;
+    _ = panic_id;
     // TODO Once we have a panic function to call, call it here instead of breakpoint.
     _ = try block.addNoOp(src, Type.initTag(.void), .breakpoint);
     _ = try block.addNoOp(src, Type.initTag(.noreturn), .unreach);
@@ -6600,6 +6630,8 @@ fn elemPtrArray(
     elem_index: *Inst,
     elem_index_src: LazySrcLoc,
 ) InnerError!*Inst {
+    _ = elem_index;
+    _ = elem_index_src;
     if (array_ptr.value()) |array_ptr_val| {
         if (elem_index.value()) |index_val| {
             // Both array pointer and index are compile-time known.
@@ -7510,6 +7542,8 @@ fn resolveBuiltinTypeFields(
     ty: Type,
     name: []const u8,
 ) InnerError!Type {
+    _ = ty;
+    _ = name;
     const resolved_ty = try sema.getBuiltinType(block, src, name);
     return sema.resolveTypeFields(block, src, resolved_ty);
 }
diff --git a/src/Zir.zig b/src/Zir.zig
index e743adb3ed..ad96ff14b7 100644
--- a/src/Zir.zig
+++ b/src/Zir.zig
@@ -4433,6 +4433,7 @@ const Writer = struct {
     }
 
     fn writeInstIndex(self: *Writer, stream: anytype, inst: Inst.Index) !void {
+        _ = self;
         return stream.print("%{d}", .{inst});
     }
 
@@ -4453,6 +4454,7 @@ const Writer = struct {
         name: []const u8,
         flag: bool,
     ) !void {
+        _ = self;
         if (!flag) return;
         try stream.writeAll(name);
     }
diff --git a/src/air.zig b/src/air.zig
index 4731b847e6..37126f8153 100644
--- a/src/air.zig
+++ b/src/air.zig
@@ -304,9 +304,12 @@ pub const Inst = struct {
         base: Inst,
 
         pub fn operandCount(self: *const NoOp) usize {
+            _ = self;
             return 0;
         }
         pub fn getOperand(self: *const NoOp, index: usize) ?*Inst {
+            _ = self;
+            _ = index;
             return null;
         }
     };
@@ -316,6 +319,7 @@ pub const Inst = struct {
         operand: *Inst,
 
         pub fn operandCount(self: *const UnOp) usize {
+            _ = self;
             return 1;
         }
         pub fn getOperand(self: *const UnOp, index: usize) ?*Inst {
@@ -331,6 +335,7 @@ pub const Inst = struct {
         rhs: *Inst,
 
         pub fn operandCount(self: *const BinOp) usize {
+            _ = self;
             return 2;
         }
         pub fn getOperand(self: *const BinOp, index: usize) ?*Inst {
@@ -356,9 +361,12 @@ pub const Inst = struct {
         name: [*:0]const u8,
 
         pub fn operandCount(self: *const Arg) usize {
+            _ = self;
             return 0;
         }
         pub fn getOperand(self: *const Arg, index: usize) ?*Inst {
+            _ = self;
+            _ = index;
             return null;
         }
     };
@@ -391,9 +399,12 @@ pub const Inst = struct {
         body: Body,
 
         pub fn operandCount(self: *const Block) usize {
+            _ = self;
             return 0;
         }
         pub fn getOperand(self: *const Block, index: usize) ?*Inst {
+            _ = self;
+            _ = index;
             return null;
         }
     };
@@ -412,9 +423,12 @@ pub const Inst = struct {
         body: Body,
 
         pub fn operandCount(self: *const BrBlockFlat) usize {
+            _ = self;
             return 0;
         }
         pub fn getOperand(self: *const BrBlockFlat, index: usize) ?*Inst {
+            _ = self;
+            _ = index;
             return null;
         }
     };
@@ -427,9 +441,11 @@ pub const Inst = struct {
         operand: *Inst,
 
         pub fn operandCount(self: *const Br) usize {
+            _ = self;
             return 1;
         }
         pub fn getOperand(self: *const Br, index: usize) ?*Inst {
+            _ = self;
             if (index == 0)
                 return self.operand;
             return null;
@@ -443,9 +459,12 @@ pub const Inst = struct {
         block: *Block,
 
         pub fn operandCount(self: *const BrVoid) usize {
+            _ = self;
             return 0;
         }
         pub fn getOperand(self: *const BrVoid, index: usize) ?*Inst {
+            _ = self;
+            _ = index;
             return null;
         }
     };
@@ -490,6 +509,7 @@ pub const Inst = struct {
         else_death_count: u32 = 0,
 
         pub fn operandCount(self: *const CondBr) usize {
+            _ = self;
             return 1;
         }
         pub fn getOperand(self: *const CondBr, index: usize) ?*Inst {
@@ -516,9 +536,12 @@ pub const Inst = struct {
         val: Value,
 
         pub fn operandCount(self: *const Constant) usize {
+            _ = self;
             return 0;
         }
         pub fn getOperand(self: *const Constant, index: usize) ?*Inst {
+            _ = self;
+            _ = index;
             return null;
         }
     };
@@ -530,9 +553,12 @@ pub const Inst = struct {
         body: Body,
 
         pub fn operandCount(self: *const Loop) usize {
+            _ = self;
             return 0;
         }
         pub fn getOperand(self: *const Loop, index: usize) ?*Inst {
+            _ = self;
+            _ = index;
             return null;
         }
     };
@@ -544,9 +570,12 @@ pub const Inst = struct {
         variable: *Module.Var,
 
         pub fn operandCount(self: *const VarPtr) usize {
+            _ = self;
             return 0;
         }
         pub fn getOperand(self: *const VarPtr, index: usize) ?*Inst {
+            _ = self;
+            _ = index;
             return null;
         }
     };
@@ -559,9 +588,12 @@ pub const Inst = struct {
         field_index: usize,
 
         pub fn operandCount(self: *const StructFieldPtr) usize {
+            _ = self;
             return 1;
         }
         pub fn getOperand(self: *const StructFieldPtr, index: usize) ?*Inst {
+            _ = self;
+            _ = index;
             var i = index;
 
             if (i < 1)
@@ -593,6 +625,7 @@ pub const Inst = struct {
         };
 
         pub fn operandCount(self: *const SwitchBr) usize {
+            _ = self;
             return 1;
         }
         pub fn getOperand(self: *const SwitchBr, index: usize) ?*Inst {
@@ -621,9 +654,12 @@ pub const Inst = struct {
         column: u32,
 
         pub fn operandCount(self: *const DbgStmt) usize {
+            _ = self;
             return 0;
         }
         pub fn getOperand(self: *const DbgStmt, index: usize) ?*Inst {
+            _ = self;
+            _ = index;
             return null;
         }
     };
diff --git a/src/codegen.zig b/src/codegen.zig
index f2eec8cd8b..4b156c6289 100644
--- a/src/codegen.zig
+++ b/src/codegen.zig
@@ -564,7 +564,7 @@ fn Function(comptime arch: std.Target.Cpu.Arch) type {
                             .r11 = true, // fp
                             .r14 = true, // lr
                         };
-                        inline for (callee_preserved_regs) |reg, i| {
+                        inline for (callee_preserved_regs) |reg| {
                             if (self.register_manager.isRegAllocated(reg)) {
                                 @field(saved_regs, @tagName(reg)) = true;
                             }
@@ -602,7 +602,7 @@ fn Function(comptime arch: std.Target.Cpu.Arch) type {
                             } else {
                                 if (math.cast(i26, amt)) |offset| {
                                     writeInt(u32, self.code.items[jmp_reloc..][0..4], Instruction.b(.al, offset).toU32());
-                                } else |err| {
+                                } else |_| {
                                     return self.failSymbol("exitlude jump is too large", .{});
                                 }
                             }
@@ -675,7 +675,7 @@ fn Function(comptime arch: std.Target.Cpu.Arch) type {
                             } else {
                                 if (math.cast(i28, amt)) |offset| {
                                     writeInt(u32, self.code.items[jmp_reloc..][0..4], Instruction.b(offset).toU32());
-                                } else |err| {
+                                } else |_| {
                                     return self.failSymbol("exitlude jump is too large", .{});
                                 }
                             }
@@ -1497,6 +1497,7 @@ fn Function(comptime arch: std.Target.Cpu.Arch) type {
             swap_lhs_and_rhs: bool,
             op: ir.Inst.Tag,
         ) !void {
+            _ = src;
             assert(lhs_mcv == .register or rhs_mcv == .register);
 
             const op1 = if (swap_lhs_and_rhs) rhs_mcv.register else lhs_mcv.register;
@@ -1905,6 +1906,7 @@ fn Function(comptime arch: std.Target.Cpu.Arch) type {
                             try self.genX8664ModRMRegToStack(src, dst_ty, off, src_reg, mr + 0x1);
                         },
                         .immediate => |imm| {
+                            _ = imm;
                             return self.fail(src, "TODO implement x86 ADD/SUB/CMP source immediate", .{});
                         },
                         .embedded_in_code, .memory, .stack_offset => {
@@ -2054,6 +2056,7 @@ fn Function(comptime arch: std.Target.Cpu.Arch) type {
                             return self.genSetStack(src, dst_ty, off, MCValue{ .register = dst_reg });
                         },
                         .immediate => |imm| {
+                            _ = imm;
                             return self.fail(src, "TODO implement x86 multiply source immediate", .{});
                         },
                         .embedded_in_code, .memory, .stack_offset => {
@@ -2982,14 +2985,14 @@ fn Function(comptime arch: std.Target.Cpu.Arch) type {
                 .arm, .armeb => {
                     if (math.cast(i26, @intCast(i32, index) - @intCast(i32, self.code.items.len + 8))) |delta| {
                         writeInt(u32, try self.code.addManyAsArray(4), Instruction.b(.al, delta).toU32());
-                    } else |err| {
+                    } else |_| {
                         return self.fail(src, "TODO: enable larger branch offset", .{});
                     }
                 },
                 .aarch64, .aarch64_be, .aarch64_32 => {
                     if (math.cast(i28, @intCast(i32, index) - @intCast(i32, self.code.items.len + 8))) |delta| {
                         writeInt(u32, try self.code.addManyAsArray(4), Instruction.b(delta).toU32());
-                    } else |err| {
+                    } else |_| {
                         return self.fail(src, "TODO: enable larger branch offset", .{});
                     }
                 },
@@ -3307,16 +3310,18 @@ fn Function(comptime arch: std.Target.Cpu.Arch) type {
                         }
                     },
                     .compare_flags_unsigned => |op| {
+                        _ = op;
                         return self.fail(src, "TODO implement set stack variable with compare flags value (unsigned)", .{});
                     },
                     .compare_flags_signed => |op| {
+                        _ = op;
                         return self.fail(src, "TODO implement set stack variable with compare flags value (signed)", .{});
                     },
                     .immediate => {
                         const reg = try self.copyToTmpRegister(src, ty, mcv);
                         return self.genSetStack(src, ty, stack_offset, MCValue{ .register = reg });
                     },
-                    .embedded_in_code => |code_offset| {
+                    .embedded_in_code => {
                         return self.fail(src, "TODO implement set stack variable from embedded_in_code", .{});
                     },
                     .register => |reg| {
@@ -3352,7 +3357,7 @@ fn Function(comptime arch: std.Target.Cpu.Arch) type {
                             else => return self.fail(src, "TODO implement storing other types abi_size={}", .{abi_size}),
                         }
                     },
-                    .memory => |vaddr| {
+                    .memory => {
                         return self.fail(src, "TODO implement set stack variable from memory vaddr", .{});
                     },
                     .stack_offset => |off| {
@@ -3380,10 +3385,10 @@ fn Function(comptime arch: std.Target.Cpu.Arch) type {
                             else => return self.fail(src, "TODO implement memset", .{}),
                         }
                     },
-                    .compare_flags_unsigned => |op| {
+                    .compare_flags_unsigned => {
                         return self.fail(src, "TODO implement set stack variable with compare flags value (unsigned)", .{});
                     },
-                    .compare_flags_signed => |op| {
+                    .compare_flags_signed => {
                         return self.fail(src, "TODO implement set stack variable with compare flags value (signed)", .{});
                     },
                     .immediate => |x_big| {
@@ -3435,13 +3440,13 @@ fn Function(comptime arch: std.Target.Cpu.Arch) type {
                             },
                         }
                     },
-                    .embedded_in_code => |code_offset| {
+                    .embedded_in_code => {
                         return self.fail(src, "TODO implement set stack variable from embedded_in_code", .{});
                     },
                     .register => |reg| {
                         try self.genX8664ModRMRegToStack(src, ty, stack_offset, reg, 0x89);
                     },
-                    .memory => |vaddr| {
+                    .memory => {
                         return self.fail(src, "TODO implement set stack variable from memory vaddr", .{});
                     },
                     .stack_offset => |off| {
@@ -3469,17 +3474,17 @@ fn Function(comptime arch: std.Target.Cpu.Arch) type {
                             else => return self.fail(src, "TODO implement memset", .{}),
                         }
                     },
-                    .compare_flags_unsigned => |op| {
+                    .compare_flags_unsigned => {
                         return self.fail(src, "TODO implement set stack variable with compare flags value (unsigned)", .{});
                     },
-                    .compare_flags_signed => |op| {
+                    .compare_flags_signed => {
                         return self.fail(src, "TODO implement set stack variable with compare flags value (signed)", .{});
                     },
                     .immediate => {
                         const reg = try self.copyToTmpRegister(src, ty, mcv);
                         return self.genSetStack(src, ty, stack_offset, MCValue{ .register = reg });
                     },
-                    .embedded_in_code => |code_offset| {
+                    .embedded_in_code => {
                         return self.fail(src, "TODO implement set stack variable from embedded_in_code", .{});
                     },
                     .register => |reg| {
@@ -3511,7 +3516,7 @@ fn Function(comptime arch: std.Target.Cpu.Arch) type {
                             else => return self.fail(src, "TODO implement storing other types abi_size={}", .{abi_size}),
                         }
                     },
-                    .memory => |vaddr| {
+                    .memory => {
                         return self.fail(src, "TODO implement set stack variable from memory vaddr", .{});
                     },
                     .stack_offset => |off| {
@@ -3842,6 +3847,7 @@ fn Function(comptime arch: std.Target.Cpu.Arch) type {
                         );
                     },
                     .compare_flags_signed => |op| {
+                        _ = op;
                         return self.fail(src, "TODO set register with compare flags value (signed)", .{});
                     },
                     .immediate => |x| {
@@ -4460,6 +4466,7 @@ fn Function(comptime arch: std.Target.Cpu.Arch) type {
                     dummy,
 
                     pub fn allocIndex(self: Register) ?u4 {
+                        _ = self;
                         return null;
                     }
                 };
diff --git a/src/codegen/arm.zig b/src/codegen/arm.zig
index cc6abe2e52..891a9e100b 100644
--- a/src/codegen/arm.zig
+++ b/src/codegen/arm.zig
@@ -674,7 +674,7 @@ pub const Instruction = union(enum) {
         };
         const imm4h: u4 = switch (offset) {
             .immediate => |imm| @truncate(u4, imm >> 4),
-            .register => |reg| 0b0000,
+            .register => 0b0000,
         };
 
         return Instruction{
diff --git a/src/codegen/c.zig b/src/codegen/c.zig
index 1100626553..ae439693b8 100644
--- a/src/codegen/c.zig
+++ b/src/codegen/c.zig
@@ -47,6 +47,8 @@ fn formatTypeAsCIdentifier(
     options: std.fmt.FormatOptions,
     writer: anytype,
 ) !void {
+    _ = fmt;
+    _ = options;
     var buffer = [1]u8{0} ** 128;
     // We don't care if it gets cut off, it's still more unique than a number
     var buf = std.fmt.bufPrint(&buffer, "{}", .{data}) catch &buffer;
@@ -63,6 +65,8 @@ fn formatIdent(
     options: std.fmt.FormatOptions,
     writer: anytype,
 ) !void {
+    _ = fmt;
+    _ = options;
     for (ident) |c, i| {
         switch (c) {
             'a'...'z', 'A'...'Z', '_' => try writer.writeByte(c),
@@ -747,6 +751,7 @@ pub fn genBody(o: *Object, body: ir.Body) error{ AnalysisFail, OutOfMemory }!voi
 }
 
 fn genVarPtr(o: *Object, inst: *Inst.VarPtr) !CValue {
+    _ = o;
     return CValue{ .decl_ref = inst.variable.owner_decl };
 }
 
@@ -937,6 +942,8 @@ fn genCall(o: *Object, inst: *Inst.Call) !CValue {
 }
 
 fn genDbgStmt(o: *Object, inst: *Inst.DbgStmt) !CValue {
+    _ = o;
+    _ = inst;
     // TODO emit #line directive here with line number and filename
     return CValue.none;
 }
@@ -1016,11 +1023,13 @@ fn genBitcast(o: *Object, inst: *Inst.UnOp) !CValue {
 }
 
 fn genBreakpoint(o: *Object, inst: *Inst.NoOp) !CValue {
+    _ = inst;
     try o.writer().writeAll("zig_breakpoint();\n");
     return CValue.none;
 }
 
 fn genUnreach(o: *Object, inst: *Inst.NoOp) !CValue {
+    _ = inst;
     try o.writer().writeAll("zig_unreachable();\n");
     return CValue.none;
 }
diff --git a/src/codegen/llvm.zig b/src/codegen/llvm.zig
index 4e4621ca29..2baedf8c9d 100644
--- a/src/codegen/llvm.zig
+++ b/src/codegen/llvm.zig
@@ -154,6 +154,7 @@ pub const Object = struct {
     object_pathZ: [:0]const u8,
 
     pub fn create(allocator: *Allocator, sub_path: []const u8, options: link.Options) !*Object {
+        _ = sub_path;
         const self = try allocator.create(Object);
         errdefer allocator.destroy(self);
 
@@ -742,6 +743,7 @@ pub const FuncGen = struct {
     }
 
     fn genRetVoid(self: *FuncGen, inst: *Inst.NoOp) ?*const llvm.Value {
+        _ = inst;
         _ = self.builder.buildRetVoid();
         return null;
     }
@@ -873,6 +875,7 @@ pub const FuncGen = struct {
     }
 
     fn genUnreach(self: *FuncGen, inst: *Inst.NoOp) ?*const llvm.Value {
+        _ = inst;
         _ = self.builder.buildUnreachable();
         return null;
     }
@@ -1013,6 +1016,7 @@ pub const FuncGen = struct {
     }
 
     fn genBreakpoint(self: *FuncGen, inst: *Inst.NoOp) !?*const llvm.Value {
+        _ = inst;
         const llvn_fn = self.getIntrinsic("llvm.debugtrap");
         _ = self.builder.buildCall(llvn_fn, null, 0, "");
         return null;
diff --git a/src/codegen/wasm.zig b/src/codegen/wasm.zig
index a830ca36e0..39930e22b4 100644
--- a/src/codegen/wasm.zig
+++ b/src/codegen/wasm.zig
@@ -702,7 +702,7 @@ pub const Context = struct {
                 try writer.writeByte(wasm.valtype(.i32)); // error code is always an i32 integer.
                 try writer.writeByte(val_type);
             },
-            else => |ret_type| {
+            else => {
                 try leb.writeULEB128(writer, @as(u32, 1));
                 // Can we maybe get the source index of the return type?
                 const val_type = try self.genValtype(.{ .node_offset = 0 }, return_type);
@@ -721,7 +721,7 @@ pub const Context = struct {
                 // TODO: check for and handle death of instructions
                 const mod_fn = blk: {
                     if (typed_value.val.castTag(.function)) |func| break :blk func.data;
-                    if (typed_value.val.castTag(.extern_fn)) |ext_fn| return Result.appended; // don't need code body for extern functions
+                    if (typed_value.val.castTag(.extern_fn)) |_| return Result.appended; // don't need code body for extern functions
                     unreachable;
                 };
 
@@ -910,7 +910,7 @@ pub const Context = struct {
                 },
                 else => unreachable,
             },
-            .local => |local| {
+            .local => {
                 try self.emitWValue(rhs);
                 try writer.writeByte(wasm.opcode(.local_set));
                 try leb.writeULEB128(writer, lhs.local);
@@ -925,6 +925,7 @@ pub const Context = struct {
     }
 
     fn genArg(self: *Context, inst: *Inst.Arg) InnerError!WValue {
+        _ = inst;
         // arguments share the index with locals
         defer self.local_index += 1;
         return WValue{ .local = self.local_index };
@@ -1213,12 +1214,15 @@ pub const Context = struct {
     }
 
     fn genBreakpoint(self: *Context, breakpoint: *Inst.NoOp) InnerError!WValue {
+        _ = self;
+        _ = breakpoint;
         // unsupported by wasm itself. Can be implemented once we support DWARF
         // for wasm
         return .none;
     }
 
     fn genUnreachable(self: *Context, unreach: *Inst.NoOp) InnerError!WValue {
+        _ = unreach;
         try self.code.append(wasm.opcode(.@"unreachable"));
         return .none;
     }
diff --git a/src/link.zig b/src/link.zig
index d1508c29cd..bae468d075 100644
--- a/src/link.zig
+++ b/src/link.zig
@@ -517,7 +517,7 @@ pub const File = struct {
                     .target = base.options.target,
                     .output_mode = .Obj,
                 });
-                const o_directory = base.options.module.?.zig_cache_artifact_directory;
+                const o_directory = module.zig_cache_artifact_directory;
                 const full_obj_path = try o_directory.join(arena, &[_][]const u8{obj_basename});
                 break :blk full_obj_path;
             }
diff --git a/src/link/C.zig b/src/link/C.zig
index 6cb219db41..bf18710cf5 100644
--- a/src/link/C.zig
+++ b/src/link/C.zig
@@ -76,7 +76,12 @@ pub fn deinit(self: *C) void {
     self.decl_table.deinit(self.base.allocator);
 }
 
-pub fn allocateDeclIndexes(self: *C, decl: *Module.Decl) !void {}
+pub fn allocateDeclIndexes(self: *C, decl: *Module.Decl) !void {
+    if (false) {
+        self;
+        decl;
+    }
+}
 
 pub fn freeDecl(self: *C, decl: *Module.Decl) void {
     _ = self.decl_table.swapRemove(decl);
@@ -307,4 +312,11 @@ pub fn updateDeclExports(
     module: *Module,
     decl: *Module.Decl,
     exports: []const *Module.Export,
-) !void {}
+) !void {
+    if (false) {
+        exports;
+        decl;
+        module;
+        self;
+    }
+}
diff --git a/src/link/Coff.zig b/src/link/Coff.zig
index 9ab1c6d78a..b466cf9136 100644
--- a/src/link/Coff.zig
+++ b/src/link/Coff.zig
@@ -831,7 +831,7 @@ fn linkWithLLD(self: *Coff, comp: *Compilation) !void {
                 .target = self.base.options.target,
                 .output_mode = .Obj,
             });
-            const o_directory = self.base.options.module.?.zig_cache_artifact_directory;
+            const o_directory = module.zig_cache_artifact_directory;
             const full_obj_path = try o_directory.join(arena, &[_][]const u8{obj_basename});
             break :blk full_obj_path;
         }
@@ -1340,6 +1340,9 @@ pub fn getDeclVAddr(self: *Coff, decl: *const Module.Decl) u64 {
 }
 
 pub fn updateDeclLineNumber(self: *Coff, module: *Module, decl: *Module.Decl) !void {
+    _ = self;
+    _ = module;
+    _ = decl;
     // TODO Implement this
 }
 
diff --git a/src/link/Elf.zig b/src/link/Elf.zig
index 84068ffeca..f046e8104f 100644
--- a/src/link/Elf.zig
+++ b/src/link/Elf.zig
@@ -1262,7 +1262,7 @@ fn linkWithLLD(self: *Elf, comp: *Compilation) !void {
                 .target = self.base.options.target,
                 .output_mode = .Obj,
             });
-            const o_directory = self.base.options.module.?.zig_cache_artifact_directory;
+            const o_directory = module.zig_cache_artifact_directory;
             const full_obj_path = try o_directory.join(arena, &[_][]const u8{obj_basename});
             break :blk full_obj_path;
         }
@@ -1938,6 +1938,11 @@ fn freeTextBlock(self: *Elf, text_block: *TextBlock) void {
 }
 
 fn shrinkTextBlock(self: *Elf, text_block: *TextBlock, new_block_size: u64) void {
+    if (false) {
+        self;
+        text_block;
+        new_block_size;
+    }
     // TODO check the new capacity, and if it crosses the size threshold into a big enough
     // capacity, insert a free list node for it.
 }
@@ -2706,6 +2711,7 @@ pub fn updateDeclExports(
 
 /// Must be called only after a successful call to `updateDecl`.
 pub fn updateDeclLineNumber(self: *Elf, module: *Module, decl: *const Module.Decl) !void {
+    _ = module;
     const tracy = trace(@src());
     defer tracy.end();
 
@@ -2979,6 +2985,7 @@ fn dbgLineNeededHeaderBytes(self: Elf) u32 {
 }
 
 fn dbgInfoNeededHeaderBytes(self: Elf) u32 {
+    _ = self;
     return 120;
 }
 
@@ -3372,7 +3379,7 @@ const CsuObjects = struct {
                     if (result.crtend) |*obj| obj.* = try fs.path.join(arena, &[_][]const u8{ gcc_dir_path, obj.* });
                 },
                 else => {
-                    inline for (std.meta.fields(@TypeOf(result))) |f, i| {
+                    inline for (std.meta.fields(@TypeOf(result))) |f| {
                         if (@field(result, f.name)) |*obj| {
                             obj.* = try fs.path.join(arena, &[_][]const u8{ crt_dir_path, obj.* });
                         }
@@ -3380,7 +3387,7 @@ const CsuObjects = struct {
                 },
             }
         } else {
-            inline for (std.meta.fields(@TypeOf(result))) |f, i| {
+            inline for (std.meta.fields(@TypeOf(result))) |f| {
                 if (@field(result, f.name)) |*obj| {
                     if (comp.crt_files.get(obj.*)) |crtf| {
                         obj.* = crtf.full_object_path;
diff --git a/src/link/MachO.zig b/src/link/MachO.zig
index e82589f144..6e1996f9ff 100644
--- a/src/link/MachO.zig
+++ b/src/link/MachO.zig
@@ -441,6 +441,7 @@ pub fn flush(self: *MachO, comp: *Compilation) !void {
 }
 
 pub fn flushModule(self: *MachO, comp: *Compilation) !void {
+    _ = comp;
     const tracy = trace(@src());
     defer tracy.end();
 
@@ -533,7 +534,7 @@ fn linkWithLLD(self: *MachO, comp: *Compilation) !void {
                 .target = self.base.options.target,
                 .output_mode = .Obj,
             });
-            const o_directory = self.base.options.module.?.zig_cache_artifact_directory;
+            const o_directory = module.zig_cache_artifact_directory;
             const full_obj_path = try o_directory.join(arena, &[_][]const u8{obj_basename});
             break :blk full_obj_path;
         }
@@ -1254,6 +1255,9 @@ fn freeTextBlock(self: *MachO, text_block: *TextBlock) void {
 }
 
 fn shrinkTextBlock(self: *MachO, text_block: *TextBlock, new_block_size: u64) void {
+    _ = self;
+    _ = text_block;
+    _ = new_block_size;
     // TODO check the new capacity, and if it crosses the size threshold into a big enough
     // capacity, insert a free list node for it.
 }
diff --git a/src/link/MachO/DebugSymbols.zig b/src/link/MachO/DebugSymbols.zig
index 218911f7ab..2b10f3307b 100644
--- a/src/link/MachO/DebugSymbols.zig
+++ b/src/link/MachO/DebugSymbols.zig
@@ -899,6 +899,7 @@ fn writeStringTable(self: *DebugSymbols) !void {
 }
 
 pub fn updateDeclLineNumber(self: *DebugSymbols, module: *Module, decl: *const Module.Decl) !void {
+    _ = module;
     const tracy = trace(@src());
     defer tracy.end();
 
@@ -926,6 +927,8 @@ pub fn initDeclDebugBuffers(
     module: *Module,
     decl: *Module.Decl,
 ) !DeclDebugBuffers {
+    _ = self;
+    _ = module;
     const tracy = trace(@src());
     defer tracy.end();
 
@@ -1188,6 +1191,7 @@ fn addDbgInfoType(
     dbg_info_buffer: *std.ArrayList(u8),
     target: std.Target,
 ) !void {
+    _ = self;
     switch (ty.zigTypeTag()) {
         .Void => unreachable,
         .NoReturn => unreachable,
@@ -1364,6 +1368,7 @@ fn getRelocDbgInfoSubprogramHighPC() u32 {
 }
 
 fn dbgLineNeededHeaderBytes(self: DebugSymbols, module: *Module) u32 {
+    _ = self;
     const directory_entry_format_count = 1;
     const file_name_entry_format_count = 1;
     const directory_count = 1;
@@ -1378,6 +1383,7 @@ fn dbgLineNeededHeaderBytes(self: DebugSymbols, module: *Module) u32 {
 }
 
 fn dbgInfoNeededHeaderBytes(self: DebugSymbols) u32 {
+    _ = self;
     return 120;
 }
 
diff --git a/src/link/MachO/Zld.zig b/src/link/MachO/Zld.zig
index 4b19891c77..9d9a1315bb 100644
--- a/src/link/MachO/Zld.zig
+++ b/src/link/MachO/Zld.zig
@@ -108,6 +108,7 @@ const TlvOffset = struct {
     offset: u64,
 
     fn cmp(context: void, a: TlvOffset, b: TlvOffset) bool {
+        _ = context;
         return a.source_addr < b.source_addr;
     }
 };
@@ -437,7 +438,7 @@ fn updateMetadata(self: *Zld) !void {
         const data_seg = &self.load_commands.items[self.data_segment_cmd_index.?].Segment;
 
         // Create missing metadata
-        for (object.sections.items) |sect, sect_id| {
+        for (object.sections.items) |sect| {
             const segname = sect.segname();
             const sectname = sect.sectname();
 
@@ -1373,7 +1374,7 @@ fn allocateTentativeSymbols(self: *Zld) !void {
     }
 
     // Convert tentative definitions into regular symbols.
-    for (self.tentatives.values()) |sym, i| {
+    for (self.tentatives.values()) |sym| {
         const tent = sym.cast(Symbol.Tentative) orelse unreachable;
         const reg = try self.allocator.create(Symbol.Regular);
         errdefer self.allocator.destroy(reg);
@@ -1758,7 +1759,7 @@ fn resolveSymbolsInObject(self: *Zld, object: *Object) !void {
 
             t_sym.alias = sym;
             sym_ptr.* = sym;
-        } else if (sym.cast(Symbol.Unresolved)) |und| {
+        } else if (sym.cast(Symbol.Unresolved)) |_| {
             if (self.globals.get(sym.name)) |g_sym| {
                 sym.alias = g_sym;
                 continue;
diff --git a/src/link/MachO/bind.zig b/src/link/MachO/bind.zig
index d234fa8242..402e74d776 100644
--- a/src/link/MachO/bind.zig
+++ b/src/link/MachO/bind.zig
@@ -10,6 +10,7 @@ pub const Pointer = struct {
 };
 
 pub fn pointerCmp(context: void, a: Pointer, b: Pointer) bool {
+    _ = context;
     if (a.segment_id < b.segment_id) return true;
     if (a.segment_id == b.segment_id) {
         return a.offset < b.offset;
diff --git a/src/link/SpirV.zig b/src/link/SpirV.zig
index 9d64245bbb..c0b4e5ebcb 100644
--- a/src/link/SpirV.zig
+++ b/src/link/SpirV.zig
@@ -102,6 +102,7 @@ pub fn deinit(self: *SpirV) void {
 }
 
 pub fn updateDecl(self: *SpirV, module: *Module, decl: *Module.Decl) !void {
+    _ = module;
     // Keep track of all decls so we can iterate over them on flush().
     _ = try self.decl_table.getOrPut(self.base.allocator, decl);
 }
@@ -111,7 +112,14 @@ pub fn updateDeclExports(
     module: *Module,
     decl: *const Module.Decl,
     exports: []const *Module.Export,
-) !void {}
+) !void {
+    if (false) {
+        self;
+        module;
+        decl;
+        exports;
+    }
+}
 
 pub fn freeDecl(self: *SpirV, decl: *Module.Decl) void {
     assert(self.decl_table.swapRemove(decl));
diff --git a/src/link/Wasm.zig b/src/link/Wasm.zig
index 35da20291d..50b320d7f6 100644
--- a/src/link/Wasm.zig
+++ b/src/link/Wasm.zig
@@ -216,7 +216,7 @@ pub fn updateDecl(self: *Wasm, module: *Module, decl: *Module.Decl) !void {
             try module.failed_decls.put(module.gpa, decl, context.err_msg);
             return;
         },
-        else => |e| return err,
+        else => |e| return e,
     };
 
     const code: []const u8 = switch (result) {
@@ -258,7 +258,14 @@ pub fn updateDeclExports(
     module: *Module,
     decl: *const Module.Decl,
     exports: []const *Module.Export,
-) !void {}
+) !void {
+    if (false) {
+        self;
+        module;
+        decl;
+        exports;
+    }
+}
 
 pub fn freeDecl(self: *Wasm, decl: *Module.Decl) void {
     if (self.getFuncidx(decl)) |func_idx| {
@@ -300,6 +307,7 @@ pub fn flush(self: *Wasm, comp: *Compilation) !void {
 }
 
 pub fn flushModule(self: *Wasm, comp: *Compilation) !void {
+    _ = comp;
     const tracy = trace(@src());
     defer tracy.end();
 
@@ -557,7 +565,7 @@ fn linkWithLLD(self: *Wasm, comp: *Compilation) !void {
                 .target = self.base.options.target,
                 .output_mode = .Obj,
             });
-            const o_directory = self.base.options.module.?.zig_cache_artifact_directory;
+            const o_directory = module.zig_cache_artifact_directory;
             const full_obj_path = try o_directory.join(arena, &[_][]const u8{obj_basename});
             break :blk full_obj_path;
         }
diff --git a/src/main.zig b/src/main.zig
index 4540eaa397..4b7bff9555 100644
--- a/src/main.zig
+++ b/src/main.zig
@@ -500,7 +500,7 @@ const Emit = union(enum) {
 };
 
 fn optionalBoolEnvVar(arena: *Allocator, name: []const u8) !bool {
-    if (std.process.getEnvVarOwned(arena, name)) |value| {
+    if (std.process.getEnvVarOwned(arena, name)) |_| {
         return true;
     } else |err| switch (err) {
         error.EnvironmentVariableNotFound => return false,
@@ -2560,7 +2560,7 @@ pub const usage_init =
 ;
 
 pub fn cmdInit(
-    gpa: *Allocator,
+    _: *Allocator,
     arena: *Allocator,
     args: []const []const u8,
     output_mode: std.builtin.OutputMode,
diff --git a/src/print_env.zig b/src/print_env.zig
index d62e1f62fd..8c44e85e65 100644
--- a/src/print_env.zig
+++ b/src/print_env.zig
@@ -5,6 +5,7 @@ const Allocator = std.mem.Allocator;
 const fatal = @import("main.zig").fatal;
 
 pub fn cmdEnv(gpa: *Allocator, args: []const []const u8, stdout: std.fs.File.Writer) !void {
+    _ = args;
     const self_exe_path = try std.fs.selfExePathAlloc(gpa);
     defer gpa.free(self_exe_path);
 
diff --git a/src/print_targets.zig b/src/print_targets.zig
index e24a2294a1..d0a1d5167a 100644
--- a/src/print_targets.zig
+++ b/src/print_targets.zig
@@ -17,6 +17,7 @@ pub fn cmdTargets(
     stdout: anytype,
     native_target: Target,
 ) !void {
+    _ = args;
     var zig_lib_directory = introspect.findZigLibDir(allocator) catch |err| {
         fatal("unable to find zig installation directory: {s}\n", .{@errorName(err)});
     };
diff --git a/src/register_manager.zig b/src/register_manager.zig
index 6f42fd1ab1..96cf4f17b7 100644
--- a/src/register_manager.zig
+++ b/src/register_manager.zig
@@ -265,6 +265,8 @@ fn MockFunction(comptime Register: type) type {
         }
 
         pub fn spillInstruction(self: *Self, src: LazySrcLoc, reg: Register, inst: *ir.Inst) !void {
+            _ = src;
+            _ = inst;
             try self.spilled.append(self.allocator, reg);
         }
     };
diff --git a/src/stage1.zig b/src/stage1.zig
index 91e7cd8bed..46d70ea335 100644
--- a/src/stage1.zig
+++ b/src/stage1.zig
@@ -407,6 +407,8 @@ export fn stage2_add_link_lib(
     symbol_name_ptr: [*c]const u8,
     symbol_name_len: usize,
 ) ?[*:0]const u8 {
+    _ = symbol_name_len;
+    _ = symbol_name_ptr;
     const comp = @intToPtr(*Compilation, stage1.userdata);
     const lib_name = std.ascii.allocLowerString(comp.gpa, lib_name_ptr[0..lib_name_len]) catch return "out of memory";
     const target = comp.getTarget();
diff --git a/src/test.zig b/src/test.zig
index a7f11d93df..1d2a552662 100644
--- a/src/test.zig
+++ b/src/test.zig
@@ -70,6 +70,8 @@ const ErrorMsg = union(enum) {
         options: std.fmt.FormatOptions,
         writer: anytype,
     ) !void {
+        _ = fmt;
+        _ = options;
         switch (self) {
             .src => |src| {
                 return writer.print("{s}:{d}:{d}: {s}: {s}", .{
@@ -592,6 +594,7 @@ pub const TestContext = struct {
         thread_pool: *ThreadPool,
         global_cache_directory: Compilation.Directory,
     ) !void {
+        _ = self;
         const target_info = try std.zig.system.NativeTargetInfo.detect(allocator, case.target);
         const target = target_info.target;
 
diff --git a/src/tracy.zig b/src/tracy.zig
index 6f56a87ce6..9ea15d721b 100644
--- a/src/tracy.zig
+++ b/src/tracy.zig
@@ -28,7 +28,9 @@ pub const ___tracy_c_zone_context = extern struct {
 };
 
 pub const Ctx = if (enable) ___tracy_c_zone_context else struct {
-    pub fn end(self: Ctx) void {}
+    pub fn end(self: Ctx) void {
+        _ = self;
+    }
 };
 
 pub inline fn trace(comptime src: std.builtin.SourceLocation) Ctx {
diff --git a/src/translate_c.zig b/src/translate_c.zig
index 5f1db7fb20..a575c0d13f 100644
--- a/src/translate_c.zig
+++ b/src/translate_c.zig
@@ -206,6 +206,7 @@ const Scope = struct {
     }
 
     fn findBlockReturnType(inner: *Scope, c: *Context) clang.QualType {
+        _ = c;
         var scope = inner;
         while (true) {
             switch (scope.id) {
@@ -601,7 +602,7 @@ fn visitFnDecl(c: *Context, fn_decl: *const clang.FunctionDecl) Error!void {
     var scope = &block_scope.base;
 
     var param_id: c_uint = 0;
-    for (proto_node.data.params) |*param, i| {
+    for (proto_node.data.params) |*param| {
         const param_name = param.name orelse {
             proto_node.data.is_extern = true;
             proto_node.data.is_export = false;
@@ -785,7 +786,7 @@ const builtin_typedef_map = std.ComptimeStringMap([]const u8, .{
 });
 
 fn transTypeDef(c: *Context, scope: *Scope, typedef_decl: *const clang.TypedefNameDecl) Error!void {
-    if (c.decl_table.get(@ptrToInt(typedef_decl.getCanonicalDecl()))) |name|
+    if (c.decl_table.get(@ptrToInt(typedef_decl.getCanonicalDecl()))) |_|
         return; // Avoid processing this decl twice
     const toplevel = scope.id == .root;
     const bs: *Scope.Block = if (!toplevel) try scope.findBlockScope(c) else undefined;
@@ -935,7 +936,7 @@ fn hasFlexibleArrayField(c: *Context, record_def: *const clang.RecordDecl) bool
 }
 
 fn transRecordDecl(c: *Context, scope: *Scope, record_decl: *const clang.RecordDecl) Error!void {
-    if (c.decl_table.get(@ptrToInt(record_decl.getCanonicalDecl()))) |name|
+    if (c.decl_table.get(@ptrToInt(record_decl.getCanonicalDecl()))) |_|
         return; // Avoid processing this decl twice
     const record_loc = record_decl.getLocation();
     const toplevel = scope.id == .root;
@@ -1080,7 +1081,7 @@ fn transRecordDecl(c: *Context, scope: *Scope, record_decl: *const clang.RecordD
 }
 
 fn transEnumDecl(c: *Context, scope: *Scope, enum_decl: *const clang.EnumDecl) Error!void {
-    if (c.decl_table.get(@ptrToInt(enum_decl.getCanonicalDecl()))) |name|
+    if (c.decl_table.get(@ptrToInt(enum_decl.getCanonicalDecl()))) |_|
         return; // Avoid processing this decl twice
     const enum_loc = enum_decl.getLocation();
     const toplevel = scope.id == .root;
@@ -1312,6 +1313,7 @@ fn transConvertVectorExpr(
     source_loc: clang.SourceLocation,
     expr: *const clang.ConvertVectorExpr,
 ) TransError!Node {
+    _ = source_loc;
     const base_stmt = @ptrCast(*const clang.Stmt, expr);
 
     var block_scope = try Scope.Block.init(c, scope, true);
@@ -1433,6 +1435,7 @@ fn transSimpleOffsetOfExpr(
     scope: *Scope,
     expr: *const clang.OffsetOfExpr,
 ) TransError!Node {
+    _ = scope;
     assert(expr.getNumComponents() == 1);
     const component = expr.getComponent(0);
     if (component.getKind() == .Field) {
@@ -2269,6 +2272,7 @@ fn transStringLiteralInitializer(
 /// both operands resolve to addresses. The C standard requires that both operands
 /// point to elements of the same array object, but we do not verify that here.
 fn cIsPointerDiffExpr(c: *Context, stmt: *const clang.BinaryOperator) bool {
+    _ = c;
     const lhs = @ptrCast(*const clang.Stmt, stmt.getLHS());
     const rhs = @ptrCast(*const clang.Stmt, stmt.getRHS());
     return stmt.getOpcode() == .Sub and
@@ -2572,6 +2576,7 @@ fn transInitListExprVector(
     expr: *const clang.InitListExpr,
     ty: *const clang.Type,
 ) TransError!Node {
+    _ = ty;
     const qt = getExprQualType(c, @ptrCast(*const clang.Expr, expr));
     const vector_type = try transQualType(c, scope, qt, loc);
     const init_count = expr.getNumInits();
@@ -2721,6 +2726,7 @@ fn transImplicitValueInitExpr(
     expr: *const clang.Expr,
     used: ResultUsed,
 ) TransError!Node {
+    _ = used;
     const source_loc = expr.getBeginLoc();
     const qt = getExprQualType(c, expr);
     const ty = qt.getTypePtr();
@@ -3407,6 +3413,7 @@ fn transUnaryExprOrTypeTraitExpr(
     stmt: *const clang.UnaryExprOrTypeTraitExpr,
     result_used: ResultUsed,
 ) TransError!Node {
+    _ = result_used;
     const loc = stmt.getBeginLoc();
     const type_node = try transQualType(c, scope, stmt.getTypeOfArgument(), loc);
 
@@ -3893,6 +3900,7 @@ fn maybeSuppressResult(
     used: ResultUsed,
     result: Node,
 ) TransError!Node {
+    _ = scope;
     if (used == .used) return result;
     return Tag.discard.create(c.arena, result);
 }
@@ -4337,7 +4345,7 @@ fn transCreateNodeMacroFn(c: *Context, name: []const u8, ref: Node, proto_alias:
     var fn_params = std.ArrayList(ast.Payload.Param).init(c.gpa);
     defer fn_params.deinit();
 
-    for (proto_alias.data.params) |param, i| {
+    for (proto_alias.data.params) |param| {
         const param_name = param.name orelse
             try std.fmt.allocPrint(c.arena, "arg_{d}", .{c.getMangle()});
 
@@ -5653,6 +5661,7 @@ fn parseCSpecifierQualifierList(c: *Context, m: *MacroCtx, scope: *Scope, allow_
 }
 
 fn parseCNumericType(c: *Context, m: *MacroCtx, scope: *Scope) ParseError!Node {
+    _ = scope;
     const KwCounter = struct {
         double: u8 = 0,
         long: u8 = 0,
@@ -5754,6 +5763,7 @@ fn parseCNumericType(c: *Context, m: *MacroCtx, scope: *Scope) ParseError!Node {
 }
 
 fn parseCAbstractDeclarator(c: *Context, m: *MacroCtx, scope: *Scope, node: Node) ParseError!Node {
+    _ = scope;
     switch (m.next().?) {
         .Asterisk => {
             // last token of `node`
diff --git a/src/type.zig b/src/type.zig
index 0b30a3de02..853a4b7914 100644
--- a/src/type.zig
+++ b/src/type.zig
@@ -600,9 +600,11 @@ pub const Type = extern union {
 
     pub const HashContext = struct {
         pub fn hash(self: @This(), t: Type) u64 {
+            _ = self;
             return t.hash();
         }
         pub fn eql(self: @This(), a: Type, b: Type) bool {
+            _ = self;
             return a.eql(b);
         }
     };
@@ -777,6 +779,7 @@ pub const Type = extern union {
         options: std.fmt.FormatOptions,
         writer: anytype,
     ) @TypeOf(writer).Error!void {
+        _ = options;
         comptime assert(fmt.len == 0);
         var ty = start_type;
         while (true) {
diff --git a/src/value.zig b/src/value.zig
index 696f3d3d88..008cc3c2fe 100644
--- a/src/value.zig
+++ b/src/value.zig
@@ -626,6 +626,7 @@ pub const Value = extern union {
             return std.mem.dupe(allocator, u8, payload.data);
         }
         if (self.castTag(.repeated)) |payload| {
+            _ = payload;
             @panic("TODO implement toAllocatedBytes for this Value tag");
         }
         if (self.castTag(.decl_ref)) |payload| {
@@ -747,6 +748,7 @@ pub const Value = extern union {
 
     /// Asserts the type is an enum type.
     pub fn toEnum(val: Value, enum_ty: Type, comptime E: type) E {
+        _ = enum_ty;
         // TODO this needs to resolve other kinds of Value tags rather than
         // assuming the tag will be .enum_field_index.
         const field_index = val.castTag(.enum_field_index).?.data;
@@ -935,6 +937,7 @@ pub const Value = extern union {
     /// Converts an integer or a float to a float.
     /// Returns `error.Overflow` if the value does not fit in the new type.
     pub fn floatCast(self: Value, allocator: *Allocator, ty: Type, target: Target) !Value {
+        _ = target;
         switch (ty.tag()) {
             .f16 => {
                 @panic("TODO add __trunctfhf2 to compiler-rt");
@@ -1292,17 +1295,21 @@ pub const Value = extern union {
 
     pub const ArrayHashContext = struct {
         pub fn hash(self: @This(), v: Value) u32 {
+            _ = self;
             return v.hash_u32();
         }
         pub fn eql(self: @This(), a: Value, b: Value) bool {
+            _ = self;
             return a.eql(b);
         }
     };
     pub const HashContext = struct {
         pub fn hash(self: @This(), v: Value) u64 {
+            _ = self;
             return v.hash();
         }
         pub fn eql(self: @This(), a: Value, b: Value) bool {
+            _ = self;
             return a.eql(b);
         }
     };
@@ -1345,6 +1352,7 @@ pub const Value = extern union {
     }
 
     pub fn fieldValue(val: Value, allocator: *Allocator, index: usize) error{OutOfMemory}!Value {
+        _ = allocator;
         switch (val.tag()) {
             .@"struct" => {
                 const field_values = val.castTag(.@"struct").?.data;