fix(zig): resolve v0.9 compilation issues

compiler/builtins/bitcode/build.zig

@@ -55,8 +55,8 @@ fn generateLlvmIrFile(
     const obj = b.addObject(object_name, main_path);
     obj.setBuildMode(mode);
     obj.strip = true;
-    obj.emit_llvm_ir = true;
-    obj.emit_bin = false;
+    obj.emit_llvm_ir = .emit;
+    obj.emit_bin = .no_emit;
     obj.target = target;
 
     const ir = b.step(step_name, "Build LLVM ir");

compiler/builtins/bitcode/src/list.zig

@@ -1347,7 +1347,6 @@ pub fn listFindUnsafe(
     data: Opaque,
     inc_n_data: IncN,
     data_is_owned: bool,
-    alignment: u32,
     element_width: usize,
     inc: Inc,
     dec: Dec,

compiler/builtins/bitcode/src/num.zig

@@ -24,7 +24,7 @@ pub fn exportParseInt(comptime T: type, comptime name: []const u8) void {
             const radix = 0;
             if (std.fmt.parseInt(T, buf.asSlice(), radix)) |success| {
                 return .{ .errorcode = 0, .value = success };
-            } else |err| {
+            } else |_| {
                 return .{ .errorcode = 1, .value = 0 };
             }
         }
@@ -37,7 +37,7 @@ pub fn exportParseFloat(comptime T: type, comptime name: []const u8) void {
         fn func(buf: RocStr) callconv(.C) NumParseResult(T) {
             if (std.fmt.parseFloat(T, buf.asSlice())) |success| {
                 return .{ .errorcode = 0, .value = success };
-            } else |err| {
+            } else |_| {
                 return .{ .errorcode = 1, .value = 0 };
             }
         }

compiler/builtins/bitcode/src/str.zig

@@ -218,7 +218,7 @@ pub const RocStr = extern struct {
     }
 
     pub fn isEmpty(self: RocStr) bool {
-        comptime const empty_len = RocStr.empty().str_len;
+        const empty_len = comptime RocStr.empty().str_len;
         return self.str_len == empty_len;
     }
 
@@ -2037,7 +2037,7 @@ test "ReverseUtf8View: empty" {
     const original_bytes = "";
 
     var iter = ReverseUtf8View.initUnchecked(original_bytes).iterator();
-    while (iter.nextCodepoint()) |codepoint| {
+    while (iter.nextCodepoint()) |_| {
         try expect(false);
     }
 }

compiler/builtins/bitcode/src/utils.zig

@@ -6,17 +6,17 @@ pub fn WithOverflow(comptime T: type) type {
 }
 
 // If allocation fails, this must cxa_throw - it must not return a null pointer!
-extern fn roc_alloc(size: usize, alignment: u32) callconv(.C) ?*c_void;
+extern fn roc_alloc(size: usize, alignment: u32) callconv(.C) ?*anyopaque;
 
 // This should never be passed a null pointer.
 // If allocation fails, this must cxa_throw - it must not return a null pointer!
-extern fn roc_realloc(c_ptr: *c_void, new_size: usize, old_size: usize, alignment: u32) callconv(.C) ?*c_void;
+extern fn roc_realloc(c_ptr: *anyopaque, new_size: usize, old_size: usize, alignment: u32) callconv(.C) ?*anyopaque;
 
 // This should never be passed a null pointer.
-extern fn roc_dealloc(c_ptr: *c_void, alignment: u32) callconv(.C) void;
+extern fn roc_dealloc(c_ptr: *anyopaque, alignment: u32) callconv(.C) void;
 
 // Signals to the host that the program has panicked
-extern fn roc_panic(c_ptr: *c_void, tag_id: u32) callconv(.C) void;
+extern fn roc_panic(c_ptr: *anyopaque, tag_id: u32) callconv(.C) void;
 
 comptime {
     const builtin = @import("builtin");
@@ -29,24 +29,24 @@ comptime {
     }
 }
 
-fn testing_roc_alloc(size: usize, _: u32) callconv(.C) ?*c_void {
-    return @ptrCast(?*c_void, std.testing.allocator.alloc(u8, size) catch unreachable);
+fn testing_roc_alloc(size: usize, _: u32) callconv(.C) ?*anyopaque {
+    return @ptrCast(?*anyopaque, std.testing.allocator.alloc(u8, size) catch unreachable);
 }
 
-fn testing_roc_realloc(c_ptr: *c_void, new_size: usize, old_size: usize, _: u32) callconv(.C) ?*c_void {
+fn testing_roc_realloc(c_ptr: *anyopaque, new_size: usize, old_size: usize, _: u32) callconv(.C) ?*anyopaque {
     const ptr = @ptrCast([*]u8, @alignCast(16, c_ptr));
     const slice = ptr[0..old_size];
 
-    return @ptrCast(?*c_void, std.testing.allocator.realloc(slice, new_size) catch unreachable);
+    return @ptrCast(?*anyopaque, std.testing.allocator.realloc(slice, new_size) catch unreachable);
 }
 
-fn testing_roc_dealloc(c_ptr: *c_void, _: u32) callconv(.C) void {
+fn testing_roc_dealloc(c_ptr: *anyopaque, _: u32) callconv(.C) void {
     const ptr = @ptrCast([*]u8, @alignCast(16, c_ptr));
 
     std.testing.allocator.destroy(ptr);
 }
 
-fn testing_roc_panic(c_ptr: *c_void, tag_id: u32) callconv(.C) void {
+fn testing_roc_panic(c_ptr: *anyopaque, tag_id: u32) callconv(.C) void {
     _ = c_ptr;
     _ = tag_id;
 
@@ -66,13 +66,13 @@ pub fn dealloc(c_ptr: [*]u8, alignment: u32) void {
 }
 
 // must export this explicitly because right now it is not used from zig code
-pub fn panic(c_ptr: *c_void, alignment: u32) callconv(.C) void {
+pub fn panic(c_ptr: *anyopaque, alignment: u32) callconv(.C) void {
     return @call(.{ .modifier = always_inline }, roc_panic, .{ c_ptr, alignment });
 }
 
 // indirection because otherwise zig creates an alias to the panic function which our LLVM code
 // does not know how to deal with
-pub fn test_panic(c_ptr: *c_void, alignment: u32) callconv(.C) void {
+pub fn test_panic(c_ptr: *anyopaque, alignment: u32) callconv(.C) void {
     _ = c_ptr;
     _ = alignment;
     // const cstr = @ptrCast([*:0]u8, c_ptr);

compiler/gen_llvm/src/llvm/build_list.rs

@@ -933,7 +933,6 @@ pub fn list_find_unsafe<'a, 'ctx, 'env>(
             pass_as_opaque(env, roc_function_call.data),
             roc_function_call.inc_n_data.into(),
             roc_function_call.data_is_owned.into(),
-            env.alignment_intvalue(element_layout),
             layout_width(env, element_layout),
             inc_element_fn.as_global_value().as_pointer_value().into(),
             dec_element_fn.as_global_value().as_pointer_value().into(),