Merge pull request #13907 from Vexu/call-merge

Remove `stack` option from `@call`

Author: andrewrk

doc/langref.html.in

@@ -4270,7 +4270,7 @@ test "using @typeInfo with runtime values" {
 }
 
 // Calls to `isFieldOptional` on `Struct1` get unrolled to an equivalent
-// of this function: 
+// of this function:
 fn isFieldOptionalUnrolled(field_index: usize) !bool {
     return switch (field_index) {
         0 => false,
@@ -7801,15 +7801,15 @@ comptime {
       {#header_close#}
 
       {#header_open|@call#}
-      <pre>{#syntax#}@call(options: std.builtin.CallOptions, function: anytype, args: anytype) anytype{#endsyntax#}</pre>
+      <pre>{#syntax#}@call(modifier: std.builtin.CallModifier, function: anytype, args: anytype) anytype{#endsyntax#}</pre>
       <p>
       Calls a function, in the same way that invoking an expression with parentheses does:
       </p>
       {#code_begin|test|call#}
 const expect = @import("std").testing.expect;
 
 test "noinline function call" {
-    try expect(@call(.{}, add, .{3, 9}) == 12);
+    try expect(@call(.auto, add, .{3, 9}) == 12);
 }
 
 fn add(a: i32, b: i32) i32 {
@@ -7818,48 +7818,41 @@ fn add(a: i32, b: i32) i32 {
       {#code_end#}
       <p>
       {#syntax#}@call{#endsyntax#} allows more flexibility than normal function call syntax does. The
-      {#syntax#}CallOptions{#endsyntax#} struct is reproduced here:
+      {#syntax#}CallModifier{#endsyntax#} enum is reproduced here:
       </p>
-      {#syntax_block|zig|builtin.CallOptions struct#}
-pub const CallOptions = struct {
-    modifier: Modifier = .auto,
-
-    /// Only valid when `Modifier` is `Modifier.async_kw`.
-    stack: ?[]align(std.Target.stack_align) u8 = null,
-
-    pub const Modifier = enum {
-        /// Equivalent to function call syntax.
-        auto,
+      {#syntax_block|zig|builtin.CallModifier struct#}
+pub const CallModifier = enum {
+    /// Equivalent to function call syntax.
+    auto,
 
-        /// Equivalent to async keyword used with function call syntax.
-        async_kw,
+    /// Equivalent to async keyword used with function call syntax.
+    async_kw,
 
-        /// Prevents tail call optimization. This guarantees that the return
-        /// address will point to the callsite, as opposed to the callsite's
-        /// callsite. If the call is otherwise required to be tail-called
-        /// or inlined, a compile error is emitted instead.
-        never_tail,
+    /// Prevents tail call optimization. This guarantees that the return
+    /// address will point to the callsite, as opposed to the callsite's
+    /// callsite. If the call is otherwise required to be tail-called
+    /// or inlined, a compile error is emitted instead.
+    never_tail,
 
-        /// Guarantees that the call will not be inlined. If the call is
-        /// otherwise required to be inlined, a compile error is emitted instead.
-        never_inline,
+    /// Guarantees that the call will not be inlined. If the call is
+    /// otherwise required to be inlined, a compile error is emitted instead.
+    never_inline,
 
-        /// Asserts that the function call will not suspend. This allows a
-        /// non-async function to call an async function.
-        no_async,
+    /// Asserts that the function call will not suspend. This allows a
+    /// non-async function to call an async function.
+    no_async,
 
-        /// Guarantees that the call will be generated with tail call optimization.
-        /// If this is not possible, a compile error is emitted instead.
-        always_tail,
+    /// Guarantees that the call will be generated with tail call optimization.
+    /// If this is not possible, a compile error is emitted instead.
+    always_tail,
 
-        /// Guarantees that the call will inlined at the callsite.
-        /// If this is not possible, a compile error is emitted instead.
-        always_inline,
+    /// Guarantees that the call will inlined at the callsite.
+    /// If this is not possible, a compile error is emitted instead.
+    always_inline,
 
-        /// Evaluates the call at compile-time. If the call cannot be completed at
-        /// compile-time, a compile error is emitted instead.
-        compile_time,
-    };
+    /// Evaluates the call at compile-time. If the call cannot be completed at
+    /// compile-time, a compile error is emitted instead.
+    compile_time,
 };
       {#end_syntax_block#}
       {#header_close#}

lib/compiler_rt/stack_probe.zig

@@ -236,27 +236,27 @@ fn win_probe_stack_adjust_sp() void {
 
 pub fn _chkstk() callconv(.Naked) void {
     @setRuntimeSafety(false);
-    @call(.{ .modifier = .always_inline }, win_probe_stack_adjust_sp, .{});
+    @call(.always_inline, win_probe_stack_adjust_sp, .{});
 }
 pub fn __chkstk() callconv(.Naked) void {
     @setRuntimeSafety(false);
     if (comptime arch.isAARCH64()) {
-        @call(.{ .modifier = .always_inline }, win_probe_stack_only, .{});
+        @call(.always_inline, win_probe_stack_only, .{});
     } else switch (arch) {
-        .x86 => @call(.{ .modifier = .always_inline }, win_probe_stack_adjust_sp, .{}),
-        .x86_64 => @call(.{ .modifier = .always_inline }, win_probe_stack_only, .{}),
+        .x86 => @call(.always_inline, win_probe_stack_adjust_sp, .{}),
+        .x86_64 => @call(.always_inline, win_probe_stack_only, .{}),
         else => unreachable,
     }
 }
 pub fn ___chkstk() callconv(.Naked) void {
     @setRuntimeSafety(false);
-    @call(.{ .modifier = .always_inline }, win_probe_stack_adjust_sp, .{});
+    @call(.always_inline, win_probe_stack_adjust_sp, .{});
 }
 pub fn __chkstk_ms() callconv(.Naked) void {
     @setRuntimeSafety(false);
-    @call(.{ .modifier = .always_inline }, win_probe_stack_only, .{});
+    @call(.always_inline, win_probe_stack_only, .{});
 }
 pub fn ___chkstk_ms() callconv(.Naked) void {
     @setRuntimeSafety(false);
-    @call(.{ .modifier = .always_inline }, win_probe_stack_only, .{});
+    @call(.always_inline, win_probe_stack_only, .{});
 }

lib/std/Thread.zig

@@ -387,18 +387,18 @@ fn callFn(comptime f: anytype, args: anytype) switch (Impl) {
 
     switch (@typeInfo(@typeInfo(@TypeOf(f)).Fn.return_type.?)) {
         .NoReturn => {
-            @call(.{}, f, args);
+            @call(.auto, f, args);
         },
         .Void => {
-            @call(.{}, f, args);
+            @call(.auto, f, args);
             return default_value;
         },
         .Int => |info| {
             if (info.bits != 8) {
                 @compileError(bad_fn_ret);
             }
 
-            const status = @call(.{}, f, args);
+            const status = @call(.auto, f, args);
             if (Impl != PosixThreadImpl) {
                 return status;
             }
@@ -411,7 +411,7 @@ fn callFn(comptime f: anytype, args: anytype) switch (Impl) {
                 @compileError(bad_fn_ret);
             }
 
-            @call(.{}, f, args) catch |err| {
+            @call(.auto, f, args) catch |err| {
                 std.debug.print("error: {s}\n", .{@errorName(err)});
                 if (@errorReturnTrace()) |trace| {
                     std.debug.dumpStackTrace(trace.*);

lib/std/builtin.zig

@@ -591,45 +591,38 @@ fn testVersionParse() !void {
 
 /// This data structure is used by the Zig language code generation and
 /// therefore must be kept in sync with the compiler implementation.
-pub const CallOptions = struct {
-    modifier: Modifier = .auto,
-
-    /// Only valid when `Modifier` is `Modifier.async_kw`.
-    stack: ?[]align(std.Target.stack_align) u8 = null,
-
-    pub const Modifier = enum {
-        /// Equivalent to function call syntax.
-        auto,
-
-        /// Equivalent to async keyword used with function call syntax.
-        async_kw,
-
-        /// Prevents tail call optimization. This guarantees that the return
-        /// address will point to the callsite, as opposed to the callsite's
-        /// callsite. If the call is otherwise required to be tail-called
-        /// or inlined, a compile error is emitted instead.
-        never_tail,
-
-        /// Guarantees that the call will not be inlined. If the call is
-        /// otherwise required to be inlined, a compile error is emitted instead.
-        never_inline,
-
-        /// Asserts that the function call will not suspend. This allows a
-        /// non-async function to call an async function.
-        no_async,
-
-        /// Guarantees that the call will be generated with tail call optimization.
-        /// If this is not possible, a compile error is emitted instead.
-        always_tail,
-
-        /// Guarantees that the call will inlined at the callsite.
-        /// If this is not possible, a compile error is emitted instead.
-        always_inline,
-
-        /// Evaluates the call at compile-time. If the call cannot be completed at
-        /// compile-time, a compile error is emitted instead.
-        compile_time,
-    };
+pub const CallModifier = enum {
+    /// Equivalent to function call syntax.
+    auto,
+
+    /// Equivalent to async keyword used with function call syntax.
+    async_kw,
+
+    /// Prevents tail call optimization. This guarantees that the return
+    /// address will point to the callsite, as opposed to the callsite's
+    /// callsite. If the call is otherwise required to be tail-called
+    /// or inlined, a compile error is emitted instead.
+    never_tail,
+
+    /// Guarantees that the call will not be inlined. If the call is
+    /// otherwise required to be inlined, a compile error is emitted instead.
+    never_inline,
+
+    /// Asserts that the function call will not suspend. This allows a
+    /// non-async function to call an async function.
+    no_async,
+
+    /// Guarantees that the call will be generated with tail call optimization.
+    /// If this is not possible, a compile error is emitted instead.
+    always_tail,
+
+    /// Guarantees that the call will inlined at the callsite.
+    /// If this is not possible, a compile error is emitted instead.
+    always_inline,
+
+    /// Evaluates the call at compile-time. If the call cannot be completed at
+    /// compile-time, a compile error is emitted instead.
+    compile_time,
 };
 
 /// This data structure is used by the Zig language code generation and

lib/std/crypto/siphash.zig

@@ -78,12 +78,10 @@ fn SipHashStateless(comptime T: type, comptime c_rounds: usize, comptime d_round
         pub fn update(self: *Self, b: []const u8) void {
             std.debug.assert(b.len % 8 == 0);
 
-            const inl = std.builtin.CallOptions{ .modifier = .always_inline };
-
             var off: usize = 0;
             while (off < b.len) : (off += 8) {
                 const blob = b[off..][0..8].*;
-                @call(inl, round, .{ self, blob });
+                @call(.always_inline, round, .{ self, blob });
             }
 
             self.msg_len +%= @truncate(u8, b.len);
@@ -105,12 +103,9 @@ fn SipHashStateless(comptime T: type, comptime c_rounds: usize, comptime d_round
                 self.v2 ^= 0xff;
             }
 
-            // TODO this is a workaround, should be able to supply the value without a separate variable
-            const inl = std.builtin.CallOptions{ .modifier = .always_inline };
-
             comptime var i: usize = 0;
             inline while (i < d_rounds) : (i += 1) {
-                @call(inl, sipRound, .{self});
+                @call(.always_inline, sipRound, .{self});
             }
 
             const b1 = self.v0 ^ self.v1 ^ self.v2 ^ self.v3;
@@ -122,7 +117,7 @@ fn SipHashStateless(comptime T: type, comptime c_rounds: usize, comptime d_round
 
             comptime var j: usize = 0;
             inline while (j < d_rounds) : (j += 1) {
-                @call(inl, sipRound, .{self});
+                @call(.always_inline, sipRound, .{self});
             }
 
             const b2 = self.v0 ^ self.v1 ^ self.v2 ^ self.v3;
@@ -133,11 +128,9 @@ fn SipHashStateless(comptime T: type, comptime c_rounds: usize, comptime d_round
             const m = mem.readIntLittle(u64, b[0..8]);
             self.v3 ^= m;
 
-            // TODO this is a workaround, should be able to supply the value without a separate variable
-            const inl = std.builtin.CallOptions{ .modifier = .always_inline };
             comptime var i: usize = 0;
             inline while (i < c_rounds) : (i += 1) {
-                @call(inl, sipRound, .{self});
+                @call(.always_inline, sipRound, .{self});
             }
 
             self.v0 ^= m;
@@ -163,8 +156,8 @@ fn SipHashStateless(comptime T: type, comptime c_rounds: usize, comptime d_round
         pub fn hash(msg: []const u8, key: *const [key_length]u8) T {
             const aligned_len = msg.len - (msg.len % 8);
             var c = Self.init(key);
-            @call(.{ .modifier = .always_inline }, c.update, .{msg[0..aligned_len]});
-            return @call(.{ .modifier = .always_inline }, c.final, .{msg[aligned_len..]});
+            @call(.always_inline, c.update, .{msg[0..aligned_len]});
+            return @call(.always_inline, c.final, .{msg[aligned_len..]});
         }
     };
 }

lib/std/dynamic_library.zig

@@ -381,7 +381,7 @@ pub const DlDynlib = struct {
     pub fn lookup(self: *DlDynlib, comptime T: type, name: [:0]const u8) ?T {
         // dlsym (and other dl-functions) secretly take shadow parameter - return address on stack
         // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=66826
-        if (@call(.{ .modifier = .never_tail }, system.dlsym, .{ self.handle, name.ptr })) |symbol| {
+        if (@call(.never_tail, system.dlsym, .{ self.handle, name.ptr })) |symbol| {
             return @ptrCast(T, symbol);
         } else {
             return null;

lib/std/hash/auto_hash.zig

@@ -66,7 +66,7 @@ pub fn hash(hasher: anytype, key: anytype, comptime strat: HashStrategy) void {
     const Key = @TypeOf(key);
 
     if (strat == .Shallow and comptime meta.trait.hasUniqueRepresentation(Key)) {
-        @call(.{ .modifier = .always_inline }, hasher.update, .{mem.asBytes(&key)});
+        @call(.always_inline, hasher.update, .{mem.asBytes(&key)});
         return;
     }
 
@@ -89,12 +89,12 @@ pub fn hash(hasher: anytype, key: anytype, comptime strat: HashStrategy) void {
         // TODO Check if the situation is better after #561 is resolved.
         .Int => {
             if (comptime meta.trait.hasUniqueRepresentation(Key)) {
-                @call(.{ .modifier = .always_inline }, hasher.update, .{std.mem.asBytes(&key)});
+                @call(.always_inline, hasher.update, .{std.mem.asBytes(&key)});
             } else {
                 // Take only the part containing the key value, the remaining
                 // bytes are undefined and must not be hashed!
                 const byte_size = comptime std.math.divCeil(comptime_int, @bitSizeOf(Key), 8) catch unreachable;
-                @call(.{ .modifier = .always_inline }, hasher.update, .{std.mem.asBytes(&key)[0..byte_size]});
+                @call(.always_inline, hasher.update, .{std.mem.asBytes(&key)[0..byte_size]});
             }
         },
 
@@ -103,7 +103,7 @@ pub fn hash(hasher: anytype, key: anytype, comptime strat: HashStrategy) void {
         .ErrorSet => hash(hasher, @errorToInt(key), strat),
         .AnyFrame, .Fn => hash(hasher, @ptrToInt(key), strat),
 
-        .Pointer => @call(.{ .modifier = .always_inline }, hashPointer, .{ hasher, key, strat }),
+        .Pointer => @call(.always_inline, hashPointer, .{ hasher, key, strat }),
 
         .Optional => if (key) |k| hash(hasher, k, strat),
 

lib/std/hash/cityhash.zig

@@ -185,7 +185,7 @@ pub const CityHash64 = struct {
     }
 
     fn hashLen16(u: u64, v: u64) u64 {
-        return @call(.{ .modifier = .always_inline }, hash128To64, .{ u, v });
+        return @call(.always_inline, hash128To64, .{ u, v });
     }
 
     fn hashLen16Mul(low: u64, high: u64, mul: u64) u64 {
@@ -198,7 +198,7 @@ pub const CityHash64 = struct {
     }
 
     fn hash128To64(low: u64, high: u64) u64 {
-        return @call(.{ .modifier = .always_inline }, hashLen16Mul, .{ low, high, 0x9ddfea08eb382d69 });
+        return @call(.always_inline, hashLen16Mul, .{ low, high, 0x9ddfea08eb382d69 });
     }
 
     fn hashLen0To16(str: []const u8) u64 {
@@ -279,7 +279,7 @@ pub const CityHash64 = struct {
     }
 
     fn weakHashLen32WithSeeds(ptr: [*]const u8, a: u64, b: u64) WeakPair {
-        return @call(.{ .modifier = .always_inline }, weakHashLen32WithSeedsHelper, .{
+        return @call(.always_inline, weakHashLen32WithSeedsHelper, .{
             fetch64(ptr, 0),
             fetch64(ptr, 8),
             fetch64(ptr, 16),
@@ -334,7 +334,7 @@ pub const CityHash64 = struct {
     }
 
     pub fn hashWithSeed(str: []const u8, seed: u64) u64 {
-        return @call(.{ .modifier = .always_inline }, Self.hashWithSeeds, .{ str, k2, seed });
+        return @call(.always_inline, Self.hashWithSeeds, .{ str, k2, seed });
     }
 
     pub fn hashWithSeeds(str: []const u8, seed0: u64, seed1: u64) u64 {