remove async and await keywords

Also remove `@frameSize`, closing #3654.

While the other machinery might remain depending on #23446, it is
settled that there will not be `async`/ `await` keywords in the
language.

Author: andrewrk

doc/langref.html.in

@@ -4279,16 +4279,9 @@ pub fn print(self: *Writer, arg0: []const u8, arg1: i32) !void {
       {#header_close#}
 
       {#header_open|Async Functions#}
-      <p>Async functions regressed with the release of 0.11.0. Their future in
-      the Zig language is unclear due to multiple unsolved problems:</p>
-      <ul>
-        <li>LLVM's lack of ability to optimize them.</li>
-        <li>Third-party debuggers' lack of ability to debug them.</li>
-        <li><a href="https://github.com/ziglang/zig/issues/5913">The cancellation problem</a>.</li>
-        <li>Async function pointers preventing the stack size from being known.</li>
-      </ul>
-      <p>These problems are surmountable, but it will take time. The Zig team
-      is currently focused on other priorities.</p>
+      <p>Async functions regressed with the release of 0.11.0. The current plan is to
+      reintroduce them as a lower level primitive that powers I/O implementations.</p>
+      <p>Tracking issue: <a href="https://github.com/ziglang/zig/issues/23446">Proposal: stackless coroutines as low-level primitives</a></p>
       {#header_close#}
 
       {#header_open|Builtin Functions|2col#}
@@ -7372,29 +7365,6 @@ fn readU32Be() u32 {}
             </ul>
           </td>
         </tr>
-        <tr>
-          <th scope="row">
-            <pre>{#syntax#}async{#endsyntax#}</pre>
-          </th>
-          <td>
-            {#syntax#}async{#endsyntax#} can be used before a function call to get a pointer to the function's frame when it suspends.
-            <ul>
-              <li>See also {#link|Async Functions#}</li>
-            </ul>
-          </td>
-        </tr>
-        <tr>
-          <th scope="row">
-            <pre>{#syntax#}await{#endsyntax#}</pre>
-          </th>
-          <td>
-            {#syntax#}await{#endsyntax#} can be used to suspend the current function until the frame provided after the {#syntax#}await{#endsyntax#} completes.
-            {#syntax#}await{#endsyntax#} copies the value returned from the target function's frame to the caller.
-            <ul>
-              <li>See also {#link|Async Functions#}</li>
-            </ul>
-          </td>
-        </tr>
         <tr>
           <th scope="row">
             <pre>{#syntax#}break{#endsyntax#}</pre>
@@ -8006,8 +7976,7 @@ TypeExpr <- PrefixTypeOp* ErrorUnionExpr
 ErrorUnionExpr <- SuffixExpr (EXCLAMATIONMARK TypeExpr)?
 
 SuffixExpr
-    <- KEYWORD_async PrimaryTypeExpr SuffixOp* FnCallArguments
-     / PrimaryTypeExpr (SuffixOp / FnCallArguments)*
+    <- PrimaryTypeExpr (SuffixOp / FnCallArguments)*
 
 PrimaryTypeExpr
     <- BUILTINIDENTIFIER FnCallArguments
@@ -8183,7 +8152,6 @@ PrefixOp
      / MINUSPERCENT
      / AMPERSAND
      / KEYWORD_try
-     / KEYWORD_await
 
 PrefixTypeOp
     <- QUESTIONMARK
@@ -8404,8 +8372,6 @@ KEYWORD_and         <- 'and'         end_of_word
 KEYWORD_anyframe    <- 'anyframe'    end_of_word
 KEYWORD_anytype     <- 'anytype'     end_of_word
 KEYWORD_asm         <- 'asm'         end_of_word
-KEYWORD_async       <- 'async'       end_of_word
-KEYWORD_await       <- 'await'       end_of_word
 KEYWORD_break       <- 'break'       end_of_word
 KEYWORD_callconv    <- 'callconv'    end_of_word
 KEYWORD_catch       <- 'catch'       end_of_word
@@ -8448,8 +8414,8 @@ KEYWORD_volatile    <- 'volatile'    end_of_word
 KEYWORD_while       <- 'while'       end_of_word
 
 keyword <- KEYWORD_addrspace / KEYWORD_align / KEYWORD_allowzero / KEYWORD_and
-         / KEYWORD_anyframe / KEYWORD_anytype / KEYWORD_asm / KEYWORD_async
-         / KEYWORD_await / KEYWORD_break / KEYWORD_callconv / KEYWORD_catch
+         / KEYWORD_anyframe / KEYWORD_anytype / KEYWORD_asm
+         / KEYWORD_break / KEYWORD_callconv / KEYWORD_catch
          / KEYWORD_comptime / KEYWORD_const / KEYWORD_continue / KEYWORD_defer
          / KEYWORD_else / KEYWORD_enum / KEYWORD_errdefer / KEYWORD_error / KEYWORD_export
          / KEYWORD_extern / KEYWORD_fn / KEYWORD_for / KEYWORD_if

lib/compiler/reduce/Walk.zig

@@ -335,7 +335,6 @@ fn walkExpression(w: *Walk, node: Ast.Node.Index) Error!void {
         .address_of,
         .@"try",
         .@"resume",
-        .@"await",
         .deref,
         => {
             return walkExpression(w, ast.nodeData(node).node);
@@ -379,12 +378,8 @@ fn walkExpression(w: *Walk, node: Ast.Node.Index) Error!void {
 
         .call_one,
         .call_one_comma,
-        .async_call_one,
-        .async_call_one_comma,
         .call,
         .call_comma,
-        .async_call,
-        .async_call_comma,
         => {
             var buf: [1]Ast.Node.Index = undefined;
             return walkCall(w, ast.fullCall(&buf, node).?);

lib/docs/wasm/Walk.zig

@@ -238,12 +238,8 @@ pub const File = struct {
 
                 .call_one,
                 .call_one_comma,
-                .async_call_one,
-                .async_call_one_comma,
                 .call,
                 .call_comma,
-                .async_call,
-                .async_call_comma,
                 => {
                     var buf: [1]Ast.Node.Index = undefined;
                     return categorize_call(file_index, node, ast.fullCall(&buf, node).?);
@@ -743,7 +739,6 @@ fn expr(w: *Walk, scope: *Scope, parent_decl: Decl.Index, node: Ast.Node.Index)
         .@"comptime",
         .@"nosuspend",
         .@"suspend",
-        .@"await",
         .@"resume",
         .@"try",
         => try expr(w, scope, parent_decl, ast.nodeData(node).node),
@@ -806,12 +801,8 @@ fn expr(w: *Walk, scope: *Scope, parent_decl: Decl.Index, node: Ast.Node.Index)
 
         .call_one,
         .call_one_comma,
-        .async_call_one,
-        .async_call_one_comma,
         .call,
         .call_comma,
-        .async_call,
-        .async_call_comma,
         => {
             var buf: [1]Ast.Node.Index = undefined;
             const full = ast.fullCall(&buf, node).?;

lib/docs/wasm/html_render.zig

@@ -101,8 +101,6 @@ pub fn fileSourceHtml(
             .keyword_align,
             .keyword_and,
             .keyword_asm,
-            .keyword_async,
-            .keyword_await,
             .keyword_break,
             .keyword_catch,
             .keyword_comptime,

lib/std/builtin.zig

@@ -199,8 +199,6 @@ pub const CallingConvention = union(enum(u8)) {
     pub const C: CallingConvention = .c;
     /// Deprecated; use `.naked`.
     pub const Naked: CallingConvention = .naked;
-    /// Deprecated; use `.@"async"`.
-    pub const Async: CallingConvention = .@"async";
     /// Deprecated; use `.@"inline"`.
     pub const Inline: CallingConvention = .@"inline";
     /// Deprecated; use `.x86_64_interrupt`, `.x86_interrupt`, or `.avr_interrupt`.
@@ -866,32 +864,23 @@ pub const WasiExecModel = enum {
 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,
-
+    no_suspend,
     /// 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 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,

lib/std/zig/Ast.zig

@@ -606,7 +606,6 @@ pub fn firstToken(tree: Ast, node: Node.Index) TokenIndex {
         .negation_wrap,
         .address_of,
         .@"try",
-        .@"await",
         .optional_type,
         .@"switch",
         .switch_comma,
@@ -763,20 +762,6 @@ pub fn firstToken(tree: Ast, node: Node.Index) TokenIndex {
             return main_token - end_offset;
         },
 
-        .async_call_one,
-        .async_call_one_comma,
-        => {
-            end_offset += 1; // async token
-            n = tree.nodeData(n).node_and_opt_node[0];
-        },
-
-        .async_call,
-        .async_call_comma,
-        => {
-            end_offset += 1; // async token
-            n = tree.nodeData(n).node_and_extra[0];
-        },
-
         .container_field_init,
         .container_field_align,
         .container_field,
@@ -903,7 +888,6 @@ pub fn lastToken(tree: Ast, node: Node.Index) TokenIndex {
         .negation_wrap,
         .address_of,
         .@"try",
-        .@"await",
         .optional_type,
         .@"suspend",
         .@"resume",
@@ -1022,7 +1006,7 @@ pub fn lastToken(tree: Ast, node: Node.Index) TokenIndex {
             };
         },
 
-        .call, .async_call => {
+        .call => {
             _, const extra_index = tree.nodeData(n).node_and_extra;
             const params = tree.extraData(extra_index, Node.SubRange);
             assert(params.start != params.end);
@@ -1041,7 +1025,6 @@ pub fn lastToken(tree: Ast, node: Node.Index) TokenIndex {
             }
         },
         .call_comma,
-        .async_call_comma,
         .tagged_union_enum_tag_trailing,
         => {
             _, const extra_index = tree.nodeData(n).node_and_extra;
@@ -1122,7 +1105,6 @@ pub fn lastToken(tree: Ast, node: Node.Index) TokenIndex {
             n = @enumFromInt(tree.extra_data[@intFromEnum(range.end) - 1]); // last member
         },
         .call_one,
-        .async_call_one,
         => {
             _, const first_param = tree.nodeData(n).node_and_opt_node;
             end_offset += 1; // for the rparen
@@ -1271,7 +1253,6 @@ pub fn lastToken(tree: Ast, node: Node.Index) TokenIndex {
             n = first_element;
         },
         .call_one_comma,
-        .async_call_one_comma,
         .struct_init_one_comma,
         => {
             _, const first_field = tree.nodeData(n).node_and_opt_node;
@@ -1988,21 +1969,21 @@ pub fn forFull(tree: Ast, node: Node.Index) full.For {
 pub fn callOne(tree: Ast, buffer: *[1]Node.Index, node: Node.Index) full.Call {
     const fn_expr, const first_param = tree.nodeData(node).node_and_opt_node;
     const params = loadOptionalNodesIntoBuffer(1, buffer, .{first_param});
-    return tree.fullCallComponents(.{
+    return .{ .ast = .{
         .lparen = tree.nodeMainToken(node),
         .fn_expr = fn_expr,
         .params = params,
-    });
+    } };
 }
 
 pub fn callFull(tree: Ast, node: Node.Index) full.Call {
     const fn_expr, const extra_index = tree.nodeData(node).node_and_extra;
     const params = tree.extraDataSlice(tree.extraData(extra_index, Node.SubRange), Node.Index);
-    return tree.fullCallComponents(.{
+    return .{ .ast = .{
         .lparen = tree.nodeMainToken(node),
         .fn_expr = fn_expr,
         .params = params,
-    });
+    } };
 }
 
 fn fullVarDeclComponents(tree: Ast, info: full.VarDecl.Components) full.VarDecl {
@@ -2336,18 +2317,6 @@ fn fullForComponents(tree: Ast, info: full.For.Components) full.For {
     return result;
 }
 
-fn fullCallComponents(tree: Ast, info: full.Call.Components) full.Call {
-    var result: full.Call = .{
-        .ast = info,
-        .async_token = null,
-    };
-    const first_token = tree.firstToken(info.fn_expr);
-    if (tree.isTokenPrecededByTags(first_token, &.{.keyword_async})) {
-        result.async_token = first_token - 1;
-    }
-    return result;
-}
-
 pub fn fullVarDecl(tree: Ast, node: Node.Index) ?full.VarDecl {
     return switch (tree.nodeTag(node)) {
         .global_var_decl => tree.globalVarDecl(node),
@@ -2488,8 +2457,8 @@ pub fn fullAsm(tree: Ast, node: Node.Index) ?full.Asm {
 
 pub fn fullCall(tree: Ast, buffer: *[1]Ast.Node.Index, node: Node.Index) ?full.Call {
     return switch (tree.nodeTag(node)) {
-        .call, .call_comma, .async_call, .async_call_comma => tree.callFull(node),
-        .call_one, .call_one_comma, .async_call_one, .async_call_one_comma => tree.callOne(buffer, node),
+        .call, .call_comma => tree.callFull(node),
+        .call_one, .call_one_comma => tree.callOne(buffer, node),
         else => null,
     };
 }
@@ -2882,7 +2851,6 @@ pub const full = struct {
 
     pub const Call = struct {
         ast: Components,
-        async_token: ?TokenIndex,
 
         pub const Components = struct {
             lparen: TokenIndex,
@@ -3301,8 +3269,6 @@ pub const Node = struct {
         address_of,
         /// `try expr`. The `main_token` field is the `try` token.
         @"try",
-        /// `await expr`. The `main_token` field is the `await` token.
-        @"await",
         /// `?expr`. The `main_token` field is the `?` token.
         optional_type,
         /// `[lhs]rhs`. The `main_token` field is the `[` token.
@@ -3498,17 +3464,6 @@ pub const Node = struct {
         /// Same as `call_one` except there is known to be a trailing comma
         /// before the final rparen.
         call_one_comma,
-        /// `async a(b)`, `async a()`.
-        ///
-        /// The `data` field is a `.node_and_opt_node`:
-        ///   1. a `Node.Index` to the function expression.
-        ///   2. a `Node.OptionalIndex` to the first argument, if any.
-        ///
-        /// The `main_token` field is the `(` token.
-        async_call_one,
-        /// Same as `async_call_one` except there is known to be a trailing
-        /// comma before the final rparen.
-        async_call_one_comma,
         /// `a(b, c, d)`.
         ///
         /// The `data` field is a `.node_and_extra`:
@@ -3521,18 +3476,6 @@ pub const Node = struct {
         /// Same as `call` except there is known to be a trailing comma before
         /// the final rparen.
         call_comma,
-        /// `async a(b, c, d)`.
-        ///
-        /// The `data` field is a `.node_and_extra`:
-        ///   1. a `Node.Index` to the function expression.
-        ///   2. a `ExtraIndex` to a `SubRange` that stores a `Node.Index` for
-        ///      each argument.
-        ///
-        /// The `main_token` field is the `(` token.
-        async_call,
-        /// Same as `async_call` except there is known to be a trailing comma
-        /// before the final rparen.
-        async_call_comma,
         /// `switch(a) {}`.
         ///
         /// The `data` field is a `.node_and_extra`: