Support async/await in the dart2js frontend.

sdk/lib/_internal/compiler/implementation/scanner/parser.dart

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 part of scanner;
 
 class FormalParameterType {
   final String type;
   const FormalParameterType(this.type);
   bool get isRequired => this == REQUIRED;
@@ skipping 23 matching lines @@
  *
  * Parse methods are generally named parseGrammarProductionSuffix. The
  * suffix can be one of "opt", or "star". "opt" means zero or one
  * matches, "star" means zero or more matches. For example,
  * [parseMetadataStar] corresponds to this grammar snippet: [:
  * metadata* :], and [parseTypeOpt] corresponds to: [: type? :].
  */
 class Parser {
   final Listener listener;
   bool mayParseFunctionExpressions = true;
+  bool yieldIsKeyword = false;
+  bool awaitIsKeyword = false;
 
   Parser(this.listener);
 
   Token parseUnit(Token token) {
     listener.beginCompilationUnit(token);
     int count = 0;
     while (!identical(token.kind, EOF_TOKEN)) {
       token = parseTopLevelDeclaration(token);
       listener.endTopLevelDeclaration(token);
       count++;
@@ skipping 803 matching lines @@
     }
 
     if (type == null) {
       listener.handleNoType(name);
     } else {
       parseReturnTypeOpt(type);
     }
     Token token = parseIdentifier(name);
 
     token = parseFormalParametersOpt(token);
+    bool previousYieldIsKeyword = yieldIsKeyword;
+    bool previousAwaitIsKeyword = awaitIsKeyword;
+    token = parseAsyncModifier(token);
     token = parseFunctionBody(token, false, externalModifier != null);
+    yieldIsKeyword = previousYieldIsKeyword;
+    awaitIsKeyword = previousAwaitIsKeyword;
     listener.endTopLevelMethod(start, getOrSet, token);
     return token.next;
   }
 
   Link<Token> findMemberName(Token token) {
     Token start = token;
     Link<Token> identifiers = const Link<Token>();
     while (!identical(token.kind, EOF_TOKEN)) {
       String value = token.stringValue;
       if ((identical(value, '(')) || (identical(value, '{'))
@@ skipping 321 matching lines @@
             staticModifier, MessageKind.EXTRANEOUS_MODIFIER,
             {'modifier': staticModifier});
       }
     } else {
       token = parseIdentifier(name);
     }
 
     token = parseQualifiedRestOpt(token);
     token = parseFormalParametersOpt(token);
     token = parseInitializersOpt(token);
+    bool previousYieldIsKeyword = yieldIsKeyword;
+    bool previousAwaitIsKeyword = awaitIsKeyword;
+    token = parseAsyncModifier(token);
     if (optional('=', token)) {
       token = parseRedirectingFactoryBody(token);
     } else {
       token = parseFunctionBody(
           token, false, staticModifier == null || externalModifier != null);
     }
+    yieldIsKeyword = previousYieldIsKeyword;
+    awaitIsKeyword = previousAwaitIsKeyword;
     listener.endMethod(getOrSet, start, token);
     return token.next;
   }
 
   Token parseFactoryMethod(Token token) {
     assert(isFactoryDeclaration(token));
     Token start = token;
     Token externalModifier;
     if (identical(token.stringValue, 'external')) {
       externalModifier = token;
       token = token.next;
     }
     Token constKeyword = null;
     if (optional('const', token)) {
       constKeyword = token;
       token = token.next;
     }
     Token factoryKeyword = token;
     listener.beginFactoryMethod(factoryKeyword);
     token = token.next; // Skip 'factory'.
     token = parseConstructorReference(token);
     token = parseFormalParameters(token);
+    bool previousYieldIsKeyword = yieldIsKeyword;
+    bool previousAwaitIsKeyword = awaitIsKeyword;
+    token = parseAsyncModifier(token);
     if (optional('=', token)) {
       token = parseRedirectingFactoryBody(token);
     } else {
       token = parseFunctionBody(token, false, externalModifier != null);
     }
     listener.endFactoryMethod(start, token);
     return token.next;
   }
 
   Token parseOperatorName(Token token) {
@@ skipping 23 matching lines @@
       if (optional('operator', token)) {
         token = parseOperatorName(token);
       } else {
         token = parseIdentifier(token);
       }
     }
     token = parseQualifiedRestOpt(token);
     listener.endFunctionName(token);
     token = parseFormalParametersOpt(token);
     token = parseInitializersOpt(token);
+    bool previousYieldIsKeyword = yieldIsKeyword;
+    bool previousAwaitIsKeyword = awaitIsKeyword;
+    token = parseAsyncModifier(token);
     if (optional('=', token)) {
       token = parseRedirectingFactoryBody(token);
     } else {
       token = parseFunctionBody(token, false, true);
     }
+    yieldIsKeyword = previousYieldIsKeyword;
+    awaitIsKeyword = previousAwaitIsKeyword;
     listener.endFunction(getOrSet, token);
     return token.next;
   }
 
-  Token parseUnamedFunction(Token token) {
-    listener.beginUnamedFunction(token);
+  Token parseUnnamedFunction(Token token) {
+    listener.beginUnnamedFunction(token);
     token = parseFormalParameters(token);
+    bool previousYieldIsKeyword = yieldIsKeyword;
+    bool previousAwaitIsKeyword = awaitIsKeyword;
+    token = parseAsyncModifier(token);
     bool isBlock = optional('{', token);
     token = parseFunctionBody(token, true, false);
-    listener.endUnamedFunction(token);
+    yieldIsKeyword = previousYieldIsKeyword;
+    awaitIsKeyword = previousAwaitIsKeyword;
+    listener.endUnnamedFunction(token);
     return isBlock ? token.next : token;
   }
 
   Token parseFunctionDeclaration(Token token) {
     listener.beginFunctionDeclaration(token);
     token = parseFunction(token, null);
     listener.endFunctionDeclaration(token);
     return token;
   }
 
   Token parseFunctionExpression(Token token) {
     listener.beginFunction(token);
     listener.handleModifiers(0);
     token = parseReturnTypeOpt(token);
     listener.beginFunctionName(token);
     token = parseIdentifier(token);
     listener.endFunctionName(token);
     token = parseFormalParameters(token);
     listener.handleNoInitializers();
+    bool previousYieldIsKeyword = yieldIsKeyword;
+    bool previousAwaitIsKeyword = awaitIsKeyword;
+    token = parseAsyncModifier(token);
     bool isBlock = optional('{', token);
     token = parseFunctionBody(token, true, false);
+    yieldIsKeyword = previousYieldIsKeyword;
+    awaitIsKeyword = previousAwaitIsKeyword;
     listener.endFunction(null, token);
     return isBlock ? token.next : token;
   }
 
   Token parseConstructorReference(Token token) {
     Token start = token;
     listener.beginConstructorReference(start);
     token = parseIdentifier(token);
     token = parseQualifiedRestOpt(token);
     token = parseTypeArgumentsOpt(token);
@@ skipping 45 matching lines @@
     token = token.next;
     while (notEofOrValue('}', token)) {
       token = parseStatement(token);
       ++statementCount;
     }
     listener.endFunctionBody(statementCount, begin, token);
     expect('}', token);
     return token;
   }
 
+  void checkStarredModifier(Token token, Token star, String name) {

[floitsch, 2014/11/03 17:55:54]

Add comment what exactly this checks.

[Johnni Winther, 2014/11/04 12:24:33]

Done.

+    if (star.charOffset > token.charOffset + token.charCount) {
+      listener.reportError(new TokenPair(token, star),
+          MessageKind.INVALID_STARRED_KEYWORD, {'keyword': name});
+    }
+  }
+
+  Token parseAsyncModifier(Token token) {
+    Token async;
+    Token star;
+    awaitIsKeyword = false;
+    yieldIsKeyword = false;
+    if (optional('async', token)) {
+      awaitIsKeyword = true;
+      async = token;
+      token = token.next;
+      if (optional('*', token)) {
+        yieldIsKeyword = true;
+        star = token;
+        token = token.next;
+        checkStarredModifier(async, star, 'async*');
+      }
+    } else if (optional('sync', token)) {
+      async = token;
+      token = token.next;
+      if (optional('*', token)) {
+        yieldIsKeyword = true;
+        star = token;
+        token = token.next;
+
+        checkStarredModifier(async, star, 'sync*');
+      } else {
+        listener.reportError(async,
+            MessageKind.INVALID_SYNC_MODIFIER);
+      }
+    }
+    listener.handleAsyncModifier(async, star);
+    return token;
+  }
+
   Token parseStatement(Token token) {
     final value = token.stringValue;
     if (identical(token.kind, IDENTIFIER_TOKEN)) {
       return parseExpressionStatementOrDeclaration(token);
     } else if (identical(value, '{')) {
       return parseBlock(token);
     } else if (identical(value, 'return')) {
       return parseReturnStatement(token);
     } else if (identical(value, 'var') || identical(value, 'final')) {
       return parseVariablesDeclaration(token);
     } else if (identical(value, 'if')) {
       return parseIfStatement(token);
+    } else if (awaitIsKeyword && identical(value, 'await')) {
+      if (identical(token.next.stringValue, 'for')) {
+        return parseForStatement(token, token.next);
+      } else {
+        return parseExpressionStatement(token);
+      }
     } else if (identical(value, 'for')) {
-      return parseForStatement(token);
+      return parseForStatement(null, token);
     } else if (identical(value, 'rethrow')) {
       return parseRethrowStatement(token);
     } else if (identical(value, 'throw') && optional(';', token.next)) {
       // TODO(kasperl): Stop dealing with throw here.
       return parseRethrowStatement(token);
     } else if (identical(value, 'void')) {
       return parseExpressionStatementOrDeclaration(token);
     } else if (identical(value, 'while')) {
       return parseWhileStatement(token);
     } else if (identical(value, 'do')) {
       return parseDoWhileStatement(token);
     } else if (identical(value, 'try')) {
       return parseTryStatement(token);
     } else if (identical(value, 'switch')) {
       return parseSwitchStatement(token);
     } else if (identical(value, 'break')) {
       return parseBreakStatement(token);
     } else if (identical(value, 'continue')) {
       return parseContinueStatement(token);
     } else if (identical(value, 'assert')) {
       return parseAssertStatement(token);
     } else if (identical(value, ';')) {
       return parseEmptyStatement(token);
+    } else if (yieldIsKeyword && identical(value, 'yield')) {
+      return parseYieldStatement(token);
     } else if (identical(value, 'const')) {
       return parseExpressionStatementOrConstDeclaration(token);
     } else if (token.isIdentifier()) {
       return parseExpressionStatementOrDeclaration(token);
     } else {
       return parseExpressionStatement(token);
     }
   }
 
+  Token parseYieldStatement(Token token) {
+    Token begin = token;
+    listener.beginYieldStatement(begin);
+    assert(identical('yield', token.stringValue));
+    token = token.next;
+    Token starToken;
+    if (optional('*', token)) {
+      starToken = token;
+      token = token.next;
+      checkStarredModifier(begin, starToken, 'yield*');
+    }
+    token = parseExpression(token);
+    listener.endYieldStatement(begin, starToken, token);
+    return expectSemicolon(token);
+  }
+
+
   Token parseReturnStatement(Token token) {
     Token begin = token;
     listener.beginReturnStatement(begin);
     assert(identical('return', token.stringValue));
     token = token.next;
     if (optional(';', token)) {
       listener.endReturnStatement(false, begin, token);
     } else {
       token = parseExpression(token);
       listener.endReturnStatement(true, begin, token);
@@ skipping 34 matching lines @@
       if (identical(afterIdKind, EQ_TOKEN) ||
           identical(afterIdKind, SEMICOLON_TOKEN) ||
           identical(afterIdKind, COMMA_TOKEN)) {
         // We are looking at "type identifier" followed by '=', ';', ','.
         return parseVariablesDeclaration(token);
       } else if (identical(afterIdKind, OPEN_PAREN_TOKEN)) {
         // We are looking at "type identifier '('".
         BeginGroupToken beginParen = afterId;
         Token endParen = beginParen.endGroup;
         Token afterParens = endParen.next;
-        if (optional('{', afterParens) || optional('=>', afterParens)) {
+        if (optional('{', afterParens) ||
+            optional('=>', afterParens) ||
+            optional('async', afterParens) ||
+            optional('sync', afterParens)) {
           // We are looking at "type identifier '(' ... ')'" followed
           // by '=>' or '{'.
           return parseFunctionDeclaration(token);
         }
       }
       // Fall-through to expression statement.
     } else {
       if (optional(':', token.next)) {
         return parseLabeledStatement(token);
       } else if (optional('(', token.next)) {
         BeginGroupToken begin = token.next;
         String afterParens = begin.endGroup.next.stringValue;
-        if (identical(afterParens, '{') || identical(afterParens, '=>')) {
+        if (identical(afterParens, '{') ||
+            identical(afterParens, '=>') ||
+            identical(afterParens, 'async') ||
+            identical(afterParens, 'sync')) {
           return parseFunctionDeclaration(token);
         }
       }
     }
     return parseExpressionStatement(token);
   }
 
   Token parseExpressionStatementOrConstDeclaration(Token token) {
     assert(identical(token.stringValue, 'const'));
     if (isModifier(token.next)) {
@@ skipping 160 matching lines @@
       token = parseExpressionWithoutCascade(token.next);
       listener.handleAssignmentExpression(assignment);
     }
     listener.endCascade();
     return token;
   }
 
   Token parseUnaryExpression(Token token, bool allowCascades) {
     String value = token.stringValue;
     // Prefix:
-    if (identical(value, '+')) {
+    if (awaitIsKeyword && optional('await', token)) {
+      return parseAwaitExpression(token, allowCascades);
+    } else if (identical(value, '+')) {
       // Dart no longer allows prefix-plus.
       listener.reportError(token, MessageKind.UNSUPPORTED_PREFIX_PLUS);
       return parseUnaryExpression(token.next, allowCascades);
     } else if ((identical(value, '!')) ||
                (identical(value, '-')) ||
                (identical(value, '~'))) {
       Token operator = token;
       // Right associative, so we recurse at the same precedence
       // level.
       token = parsePrecedenceExpression(token.next, POSTFIX_PRECEDENCE,
@@ skipping 74 matching lines @@
                (identical(kind, OPEN_CURLY_BRACKET_TOKEN)) ||
                identical(token.stringValue, '[]')) {
       return parseLiteralListOrMap(token);
     } else {
       return listener.expectedExpression(token);
     }
   }
 
   Token parseParenthesizedExpressionOrFunctionLiteral(Token token) {
     BeginGroupToken beginGroup = token;
-    int kind = beginGroup.endGroup.next.kind;
+    Token nextToken = beginGroup.endGroup.next;
+    int kind = nextToken.kind;
     if (mayParseFunctionExpressions &&
-        (identical(kind, FUNCTION_TOKEN)
-            || identical(kind, OPEN_CURLY_BRACKET_TOKEN))) {
-      return parseUnamedFunction(token);
+        (identical(kind, FUNCTION_TOKEN) ||
+         identical(kind, OPEN_CURLY_BRACKET_TOKEN) ||
+         (identical(kind, KEYWORD_TOKEN) &&
+             (nextToken.value == 'async' || nextToken.value == 'sync')))) {
+      return parseUnnamedFunction(token);
     } else {
       bool old = mayParseFunctionExpressions;
       mayParseFunctionExpressions = true;
       token = parseParenthesizedExpression(token);
       mayParseFunctionExpressions = old;
       return token;
     }
   }
 
   Token parseParenthesizedExpression(Token token) {
@@ skipping 101 matching lines @@
       return parseFunctionExpression(token);
     } else {
       return parseSend(token);
     }
   }
 
   bool isFunctionDeclaration(Token token) {
     if (optional('(', token)) {
       BeginGroupToken begin = token;
       String afterParens = begin.endGroup.next.stringValue;
-      if (identical(afterParens, '{') || identical(afterParens, '=>')) {
+      if (identical(afterParens, '{') ||
+          identical(afterParens, '=>') ||
+          identical(afterParens, 'async') ||
+          identical(afterParens, 'sync')) {
         return true;
       }
     }
     return false;
   }
 
   Token parseRequiredArguments(Token token) {
     if (optional('(', token)) {
       token = parseArguments(token);
     } else {
@@ skipping 237 matching lines @@
     token = parseStatement(token);
     Token elseToken = null;
     if (optional('else', token)) {
       elseToken = token;
       token = parseStatement(token.next);
     }
     listener.endIfStatement(ifToken, elseToken);
     return token;
   }
 
-  Token parseForStatement(Token token) {
+  Token parseForStatement(Token awaitToken, Token token) {
     Token forToken = token;
     listener.beginForStatement(forToken);
     token = expect('for', token);
     token = expect('(', token);
     token = parseVariablesDeclarationOrExpressionOpt(token);
     if (optional('in', token)) {
-      return parseForInRest(forToken, token);
+      return parseForInRest(awaitToken, forToken, token);
     } else {
+      if (awaitToken != null) {
+        listener.reportError(awaitToken, MessageKind.INVALID_AWAIT_FOR);
+      }
       return parseForRest(forToken, token);
     }
   }
 
   Token parseVariablesDeclarationOrExpressionOpt(Token token) {
     final String value = token.stringValue;
     if (identical(value, ';')) {
       listener.handleNoExpression(token);
       return token;
     } else if ((identical(value, 'var')) || (identical(value, 'final'))) {
@@ skipping 26 matching lines @@
       } else {
         break;
       }
     }
     token = expect(')', token);
     token = parseStatement(token);
     listener.endForStatement(expressionCount, forToken, token);
     return token;
   }
 
-  Token parseForInRest(Token forToken, Token token) {
+  Token parseForInRest(Token awaitToken, Token forToken, Token token) {
     assert(optional('in', token));
     Token inKeyword = token;
     token = parseExpression(token.next);
     token = expect(')', token);
     token = parseStatement(token);
-    listener.endForIn(forToken, inKeyword, token);
+    listener.endForIn(awaitToken, forToken, inKeyword, token);
     return token;
   }
 
   Token parseWhileStatement(Token token) {
     Token whileToken = token;
     listener.beginWhileStatement(whileToken);
     token = expect('while', token);
     token = parseParenthesizedExpression(token);
     token = parseStatement(token);
     listener.endWhileStatement(whileToken, token);
@@ skipping 18 matching lines @@
     int statementCount = 0;
     token = expect('{', token);
     while (notEofOrValue('}', token)) {
       token = parseStatement(token);
       ++statementCount;
     }
     listener.endBlock(statementCount, begin, token);
     return expect('}', token);
   }
 
+  Token parseAwaitExpression(Token token, bool allowCascades) {
+    Token awaitToken = token;
+    listener.beginAwaitExpression(awaitToken);
+    token = expect('await', token);
+    token = parseUnaryExpression(token, allowCascades);
+    listener.endAwaitExpression(awaitToken, token);
+    return token;
+  }
+
   Token parseThrowExpression(Token token, bool allowCascades) {
     Token throwToken = token;
     listener.beginThrowExpression(throwToken);
     token = expect('throw', token);
     token = allowCascades
         ? parseExpression(token)
         : parseExpressionWithoutCascade(token);
     listener.endThrowExpression(throwToken, token);
     return token;
   }
@@ skipping 182 matching lines @@
     }
     listener.handleContinueStatement(hasTarget, continueKeyword, token);
     return expectSemicolon(token);
   }
 
   Token parseEmptyStatement(Token token) {
     listener.handleEmptyStatement(token);
     return expectSemicolon(token);
   }
 }