Merge pull request #15643 from Vexu/fixes

make `@call` compile errors match regular calls

Author: Vexu

lib/std/os/linux/x86.zig

@@ -108,7 +108,7 @@ pub fn syscall6(
     );
 }
 
-pub fn socketcall(call: usize, args: [*]usize) usize {
+pub fn socketcall(call: usize, args: [*]const usize) usize {
     return asm volatile ("int $0x80"
         : [ret] "={eax}" (-> usize),
         : [number] "{eax}" (@enumToInt(SYS.socketcall)),

src/Module.zig

@@ -6098,7 +6098,7 @@ pub const PeerTypeCandidateSrc = union(enum) {
     none: void,
     /// When we want to know the the src of candidate i, look up at
     /// index i in this slice
-    override: []?LazySrcLoc,
+    override: []const ?LazySrcLoc,
     /// resolvePeerTypes originates from a @TypeOf(...) call
     typeof_builtin_call_node_offset: i32,
 

src/Sema.zig

@@ -116,7 +116,7 @@ pub fn addRelocation(macho_file: *MachO, atom_index: Index, reloc: Relocation) !
     return addRelocations(macho_file, atom_index, &[_]Relocation{reloc});
 }
 
-pub fn addRelocations(macho_file: *MachO, atom_index: Index, relocs: []Relocation) !void {
+pub fn addRelocations(macho_file: *MachO, atom_index: Index, relocs: []const Relocation) !void {
     const gpa = macho_file.base.allocator;
     const gop = try macho_file.relocs.getOrPut(gpa, atom_index);
     if (!gop.found_existing) {

src/link/MachO/Atom.zig

@@ -917,7 +917,6 @@ const Writer = struct {
 
         try s.writeAll("\n");
         try s.writeByteNTimes(' ', old_indent);
-        try s.writeAll("}");
     }
 
     fn writeWasmMemorySize(w: *Writer, s: anytype, inst: Air.Inst.Index) @TypeOf(s).Error!void {

src/print_air.zig

@@ -696,7 +696,7 @@ test "array init of container level array variable" {
 test "runtime initialized sentinel-terminated array literal" {
     var c: u16 = 300;
     const f = &[_:0x9999]u16{c};
-    const g = @ptrCast(*[4]u8, f);
+    const g = @ptrCast(*const [4]u8, f);
     try std.testing.expect(g[2] == 0x99);
     try std.testing.expect(g[3] == 0x99);
 }

test/behavior/array.zig

@@ -1200,3 +1200,10 @@ test "arrays and vectors with big integers" {
         try expect(b[0] == comptime std.math.maxInt(Int));
     }
 }
+
+test "pointer to struct literal with runtime field is constant" {
+    const S = struct { data: usize };
+    var runtime_zero: usize = 0;
+    const ptr = &S{ .data = runtime_zero };
+    try expect(@typeInfo(@TypeOf(ptr)).Pointer.is_const);
+}

test/behavior/basic.zig

@@ -705,22 +705,6 @@ test "error union payload is properly aligned" {
     if (blk.a != 1) unreachable;
 }
 
-test "ret_ptr doesn't cause own inferred error set to be resolved" {
-    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-
-    const S = struct {
-        fn foo() !void {}
-
-        fn doTheTest() !void {
-            errdefer @compileError("bad");
-
-            return try @This().foo();
-        }
-    };
-    try S.doTheTest();
-}
-
 test "simple else prong allowed even when all errors handled" {
     if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
@@ -928,3 +912,28 @@ test "optional error set return type" {
     try expect(null == S.foo(true));
     try expect(E.A == S.foo(false).?);
 }
+
+test "try used in recursive function with inferred error set" {
+    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
+
+    const Value = union(enum) {
+        values: []const @This(),
+        b,
+
+        fn x(value: @This()) !void {
+            switch (value.values[0]) {
+                .values => return try x(value.values[0]),
+                .b => return error.a,
+            }
+        }
+    };
+    const a = Value{
+        .values = &[1]Value{
+            .{
+                .values = &[1]Value{.{ .b = {} }},
+            },
+        },
+    };
+    try expectError(error.a, Value.x(a));
+}

test/behavior/error.zig

@@ -6,10 +6,16 @@ pub export fn entry() void {
     var s: S = undefined;
     s.foo(true);
 }
+pub export fn entry2() void {
+    var s: S = undefined;
+    @call(.auto, s.foo, .{true});
+}
 
 // error
 // backend=stage2
 // target=native
 //
 // :7:6: error: member function expected 2 argument(s), found 1
 // :3:5: note: function declared here
+// :11:19: error: member function expected 2 argument(s), found 1
+// :3:5: note: function declared here

test/cases/compile_errors/member_function_arg_mismatch.zig

@@ -0,0 +1,18 @@
+fn foo(a: anytype) !void {
+    if (a == 0) return error.A;
+    return error.B;
+}
+const Error = error{ A, B };
+export fn entry() void {
+    const info = @typeInfo(@TypeOf(foo));
+    const ret_type = info.Fn.return_type.?;
+    const error_set = @typeInfo(ret_type).ErrorUnion.error_set;
+    _ = Error || error_set;
+}
+
+// error
+// backend=stage2
+// target=native
+//
+// :10:15: error: unable to resolve inferred error set of generic function
+// :1:1: note: generic function declared here

test/cases/compile_errors/resolve_inferred_error_set_of_generic_fn.zig

@@ -0,0 +1,10 @@
+pub export fn entry(param: usize) usize {
+    return struct{ param };
+}
+
+// error
+// backend=stage2
+// target=native
+//
+// :2:12: error: expected type 'usize', found 'type'
+// :1:35: note: function return type declared here