Merge branch 'master' into comment-in-array

1 files changed, 33 insertions, 71 deletions

diff --git a/src/parser.cpp b/src/parser.cpp
index 25541d5351..1e7e36d0bd 100644
--- a/src/parser.cpp
+++ b/src/parser.cpp
@@ -113,7 +113,6 @@ static AstNode *ast_parse_multiply_op(ParseContext *pc);
 static AstNode *ast_parse_prefix_op(ParseContext *pc);
 static AstNode *ast_parse_prefix_type_op(ParseContext *pc);
 static AstNode *ast_parse_suffix_op(ParseContext *pc);
-static AstNode *ast_parse_async_prefix(ParseContext *pc);
 static AstNode *ast_parse_fn_call_argumnets(ParseContext *pc);
 static AstNode *ast_parse_array_type_start(ParseContext *pc);
 static AstNode *ast_parse_ptr_type_start(ParseContext *pc);
@@ -282,8 +281,8 @@ static AstNode *ast_parse_prefix_op_expr(
             case NodeTypeAwaitExpr:
                 right = &prefix->data.await_expr.expr;
                 break;
-            case NodeTypePromiseType:
-                right = &prefix->data.promise_type.payload_type;
+            case NodeTypeAnyFrameType:
+                right = &prefix->data.anyframe_type.payload_type;
                 break;
             case NodeTypeArrayType:
                 right = &prefix->data.array_type.child_type;
@@ -671,14 +670,14 @@ static AstNode *ast_parse_top_level_decl(ParseContext *pc, VisibMod visib_mod) {
         return res;
     }
 
-    Token *use = eat_token_if(pc, TokenIdKeywordUsingNamespace);
-    if (use != nullptr) {
+    Token *usingnamespace = eat_token_if(pc, TokenIdKeywordUsingNamespace);
+    if (usingnamespace != nullptr) {
         AstNode *expr = ast_expect(pc, ast_parse_expr);
         expect_token(pc, TokenIdSemicolon);
 
-        AstNode *res = ast_create_node(pc, NodeTypeUse, use);
-        res->data.use.visib_mod = visib_mod;
-        res->data.use.expr = expr;
+        AstNode *res = ast_create_node(pc, NodeTypeUsingNamespace, usingnamespace);
+        res->data.using_namespace.visib_mod = visib_mod;
+        res->data.using_namespace.expr = expr;
         return res;
     }
 
@@ -1167,7 +1166,6 @@ static AstNode *ast_parse_prefix_expr(ParseContext *pc) {
 //     <- AsmExpr
 //      / IfExpr
 //      / KEYWORD_break BreakLabel? Expr?
-//      / KEYWORD_cancel Expr
 //      / KEYWORD_comptime Expr
 //      / KEYWORD_continue BreakLabel?
 //      / KEYWORD_resume Expr
@@ -1195,14 +1193,6 @@ static AstNode *ast_parse_primary_expr(ParseContext *pc) {
         return res;
     }
 
-    Token *cancel = eat_token_if(pc, TokenIdKeywordCancel);
-    if (cancel != nullptr) {
-        AstNode *expr = ast_expect(pc, ast_parse_expr);
-        AstNode *res = ast_create_node(pc, NodeTypeCancel, cancel);
-        res->data.cancel_expr.expr = expr;
-        return res;
-    }
-
     Token *comptime = eat_token_if(pc, TokenIdKeywordCompTime);
     if (comptime != nullptr) {
         AstNode *expr = ast_expect(pc, ast_parse_expr);
@@ -1398,22 +1388,18 @@ static AstNode *ast_parse_error_union_expr(ParseContext *pc) {
 }
 
 // SuffixExpr
-//     <- AsyncPrefix PrimaryTypeExpr SuffixOp* FnCallArguments
+//     <- KEYWORD_async PrimaryTypeExpr SuffixOp* FnCallArguments
 //      / PrimaryTypeExpr (SuffixOp / FnCallArguments)*
 static AstNode *ast_parse_suffix_expr(ParseContext *pc) {
-    AstNode *async_call = ast_parse_async_prefix(pc);
-    if (async_call != nullptr) {
+    Token *async_token = eat_token_if(pc, TokenIdKeywordAsync);
+    if (async_token != nullptr) {
         if (eat_token_if(pc, TokenIdKeywordFn) != nullptr) {
             // HACK: If we see the keyword `fn`, then we assume that
             //       we are parsing an async fn proto, and not a call.
             //       We therefore put back all tokens consumed by the async
             //       prefix...
-            // HACK: This loop is not actually enough to put back all the
-            //       tokens. Let's hope this is fine for most code right now
-            //       and wait till we get the async rework for a syntax update.
-            do {
-                put_back_token(pc);
-            } while (peek_token(pc)->id != TokenIdKeywordAsync);
+            put_back_token(pc);
+            put_back_token(pc);
 
             return ast_parse_primary_type_expr(pc);
         }
@@ -1455,10 +1441,14 @@ static AstNode *ast_parse_suffix_expr(ParseContext *pc) {
             ast_invalid_token_error(pc, peek_token(pc));
 
         assert(args->type == NodeTypeFnCallExpr);
-        async_call->data.fn_call_expr.fn_ref_expr = child;
-        async_call->data.fn_call_expr.params = args->data.fn_call_expr.params;
-        async_call->data.fn_call_expr.is_builtin = false;
-        return async_call;
+
+        AstNode *res = ast_create_node(pc, NodeTypeFnCallExpr, async_token);
+        res->data.fn_call_expr.is_async = true;
+        res->data.fn_call_expr.seen = false;
+        res->data.fn_call_expr.fn_ref_expr = child;
+        res->data.fn_call_expr.params = args->data.fn_call_expr.params;
+        res->data.fn_call_expr.is_builtin = false;
+        return res;
     }
 
     AstNode *res = ast_parse_primary_type_expr(pc);
@@ -1510,7 +1500,7 @@ static AstNode *ast_parse_suffix_expr(ParseContext *pc) {
 //     <- BUILTINIDENTIFIER FnCallArguments
 //      / CHAR_LITERAL
 //      / ContainerDecl
-//     / DOT IDENTIFIER
+//      / DOT IDENTIFIER
 //      / ErrorSetDecl
 //      / FLOAT
 //      / FnProto
@@ -1643,9 +1633,9 @@ static AstNode *ast_parse_primary_type_expr(ParseContext *pc) {
     if (null != nullptr)
         return ast_create_node(pc, NodeTypeNullLiteral, null);
 
-    Token *promise = eat_token_if(pc, TokenIdKeywordPromise);
-    if (promise != nullptr)
-        return ast_create_node(pc, NodeTypePromiseType, promise);
+    Token *anyframe = eat_token_if(pc, TokenIdKeywordAnyFrame);
+    if (anyframe != nullptr)
+        return ast_create_node(pc, NodeTypeAnyFrameType, anyframe);
 
     Token *true_token = eat_token_if(pc, TokenIdKeywordTrue);
     if (true_token != nullptr) {
@@ -2025,7 +2015,7 @@ static AstNode *ast_parse_link_section(ParseContext *pc) {
 //     <- KEYWORD_nakedcc
 //      / KEYWORD_stdcallcc
 //      / KEYWORD_extern
-//      / KEYWORD_async (LARROW TypeExpr RARROW)?
+//      / KEYWORD_async
 static Optional<AstNodeFnProto> ast_parse_fn_cc(ParseContext *pc) {
     AstNodeFnProto res = {};
     if (eat_token_if(pc, TokenIdKeywordNakedCC) != nullptr) {
@@ -2042,11 +2032,6 @@ static Optional<AstNodeFnProto> ast_parse_fn_cc(ParseContext *pc) {
     }
     if (eat_token_if(pc, TokenIdKeywordAsync) != nullptr) {
         res.cc = CallingConventionAsync;
-        if (eat_token_if(pc, TokenIdCmpLessThan) == nullptr)
-            return Optional<AstNodeFnProto>::some(res);
-
-        res.async_allocator_type = ast_expect(pc, ast_parse_type_expr);
-        expect_token(pc, TokenIdCmpGreaterThan);
         return Optional<AstNodeFnProto>::some(res);
     }
 
@@ -2522,7 +2507,7 @@ static AstNode *ast_parse_prefix_op(ParseContext *pc) {
 
 // PrefixTypeOp
 //     <- QUESTIONMARK
-//      / KEYWORD_promise MINUSRARROW
+//      / KEYWORD_anyframe MINUSRARROW
 //      / ArrayTypeStart (ByteAlign / KEYWORD_const / KEYWORD_volatile)*
 //      / PtrTypeStart (KEYWORD_align LPAREN Expr (COLON INTEGER COLON INTEGER)? RPAREN / KEYWORD_const / KEYWORD_volatile)*
 static AstNode *ast_parse_prefix_type_op(ParseContext *pc) {
@@ -2533,10 +2518,10 @@ static AstNode *ast_parse_prefix_type_op(ParseContext *pc) {
         return res;
     }
 
-    Token *promise = eat_token_if(pc, TokenIdKeywordPromise);
-    if (promise != nullptr) {
+    Token *anyframe = eat_token_if(pc, TokenIdKeywordAnyFrame);
+    if (anyframe != nullptr) {
         if (eat_token_if(pc, TokenIdArrow) != nullptr) {
-            AstNode *res = ast_create_node(pc, NodeTypePromiseType, promise);
+            AstNode *res = ast_create_node(pc, NodeTypeAnyFrameType, anyframe);
             return res;
         }
 
@@ -2671,24 +2656,6 @@ static AstNode *ast_parse_suffix_op(ParseContext *pc) {
     return nullptr;
 }
 
-// AsyncPrefix <- KEYWORD_async (LARROW PrefixExpr RARROW)?
-static AstNode *ast_parse_async_prefix(ParseContext *pc) {
-    Token *async = eat_token_if(pc, TokenIdKeywordAsync);
-    if (async == nullptr)
-        return nullptr;
-
-    AstNode *res = ast_create_node(pc, NodeTypeFnCallExpr, async);
-    res->data.fn_call_expr.is_async = true;
-    res->data.fn_call_expr.seen = false;
-    if (eat_token_if(pc, TokenIdCmpLessThan) != nullptr) {
-        AstNode *prefix_expr = ast_expect(pc, ast_parse_prefix_expr);
-        expect_token(pc, TokenIdCmpGreaterThan);
-        res->data.fn_call_expr.async_allocator = prefix_expr;
-    }
-
-    return res;
-}
-
 // FnCallArguments <- LPAREN ExprList RPAREN
 static AstNode *ast_parse_fn_call_argumnets(ParseContext *pc) {
     Token *paren = eat_token_if(pc, TokenIdLParen);
@@ -2858,7 +2825,6 @@ void ast_visit_node_children(AstNode *node, void (*visit)(AstNode **, void *cont
             visit_node_list(&node->data.fn_proto.params, visit, context);
             visit_field(&node->data.fn_proto.align_expr, visit, context);
             visit_field(&node->data.fn_proto.section_expr, visit, context);
-            visit_field(&node->data.fn_proto.async_allocator_type, visit, context);
             break;
         case NodeTypeFnDef:
             visit_field(&node->data.fn_def.fn_proto, visit, context);
@@ -2918,7 +2884,6 @@ void ast_visit_node_children(AstNode *node, void (*visit)(AstNode **, void *cont
         case NodeTypeFnCallExpr:
             visit_field(&node->data.fn_call_expr.fn_ref_expr, visit, context);
             visit_node_list(&node->data.fn_call_expr.params, visit, context);
-            visit_field(&node->data.fn_call_expr.async_allocator, visit, context);
             break;
         case NodeTypeArrayAccessExpr:
             visit_field(&node->data.array_access_expr.array_ref_expr, visit, context);
@@ -2938,8 +2903,8 @@ void ast_visit_node_children(AstNode *node, void (*visit)(AstNode **, void *cont
         case NodeTypeUnwrapOptional:
             visit_field(&node->data.unwrap_optional.expr, visit, context);
             break;
-        case NodeTypeUse:
-            visit_field(&node->data.use.expr, visit, context);
+        case NodeTypeUsingNamespace:
+            visit_field(&node->data.using_namespace.expr, visit, context);
             break;
         case NodeTypeBoolLiteral:
             // none
@@ -3034,8 +2999,8 @@ void ast_visit_node_children(AstNode *node, void (*visit)(AstNode **, void *cont
         case NodeTypeInferredArrayType:
             visit_field(&node->data.array_type.child_type, visit, context);
             break;
-        case NodeTypePromiseType:
-            visit_field(&node->data.promise_type.payload_type, visit, context);
+        case NodeTypeAnyFrameType:
+            visit_field(&node->data.anyframe_type.payload_type, visit, context);
             break;
         case NodeTypeErrorType:
             // none
@@ -3047,9 +3012,6 @@ void ast_visit_node_children(AstNode *node, void (*visit)(AstNode **, void *cont
         case NodeTypeErrorSetDecl:
             visit_node_list(&node->data.err_set_decl.decls, visit, context);
             break;
-        case NodeTypeCancel:
-            visit_field(&node->data.cancel_expr.expr, visit, context);
-            break;
         case NodeTypeResume:
             visit_field(&node->data.resume_expr.expr, visit, context);
             break;