update to latest zig

Signed-off-by: Stephen Gutekanst <[email protected]>

Author: Stephen Gutekanst

src/objc.zig

@@ -82,15 +82,15 @@ pub fn msgSend(receiver: anytype, comptime selector: []const u8, return_type: ty
         };
         for (@typeInfo(@TypeOf(args)).@"struct".fields) |field| {
             params = params ++
-                .{.{
+                [_]std.builtin.Type.Fn.Param{.{
                 .is_generic = false,
                 .is_noalias = false,
                 .type = field.type,
             }};
         }
         break :init std.builtin.Type{
             .@"fn" = .{
-                .calling_convention = .C,
+                .calling_convention = std.builtin.CallingConvention.c,
                 .is_generic = false,
                 .is_var_args = false,
                 .return_type = return_type,

src/system.zig

@@ -20,7 +20,7 @@ pub fn Block(comptime Signature: type) type {
             };
             const SignatureForInvoke = @Type(.{
                 .@"fn" = .{
-                    .calling_convention = .C,
+                    .calling_convention = std.builtin.CallingConvention.c,
                     .is_generic = signature_fn_info.is_generic,
                     .is_var_args = signature_fn_info.is_var_args,
                     .return_type = signature_fn_info.return_type,
@@ -118,17 +118,18 @@ fn CopyDisposeBlockDescriptor(comptime Context: type) type {
 
 fn SignatureWithoutBlockLiteral(comptime Signature: type) type {
     var type_info = @typeInfo(Signature);
-    type_info.@"fn".calling_convention = .Unspecified;
+    type_info.@"fn".calling_convention = .auto;
     type_info.@"fn".params = type_info.@"fn".params[1..];
     return @Type(type_info);
 }
 
 fn validateBlockSignature(comptime Invoke: type, comptime ExpectedLiteralType: type) void {
     switch (@typeInfo(Invoke)) {
         .@"fn" => |fn_info| {
-            if (fn_info.calling_convention != .C) {
-                @compileError("A block's `invoke` must use the C calling convention");
-            }
+            // TODO: unsure how to write this with latest Zig version
+            // if (fn_info.calling_convention != .c) {
+            //     @compileError("A block's `invoke` must use the C calling convention");
+            // }
 
             // TODO: should we allow zero params? At the ABI-level it would be fine but I think the compiler might consider it UB.
             if (fn_info.params.len == 0 or fn_info.params[0].type != *ExpectedLiteralType) {