Implement await and async for the js-ast.

pkg/compiler/lib/src/js/builder.dart

 // Copyright (c) 2013, 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.
 
 // Utilities for building JS ASTs at runtime.  Contains a builder class
 // and a parser that parses part of the language.
 
 part of js;
 
 
@@ skipping 498 matching lines @@
       '|': 12,
       '^': 11,
       '&': 10,
       '!=': 9, '==': 9, '!==': 9, '===': 9,
       '<': 8, '<=': 8, '>=': 8, '>': 8, 'in': 8, 'instanceof': 8,
       '<<': 7, '>>': 7, '>>>': 7,
       '+': 6, '-': 6,
       '*': 5, '/': 5, '%': 5
   };
   static final UNARY_OPERATORS =
-      ['++', '--', '+', '-', '~', '!', 'typeof', 'void', 'delete'].toSet();
+      ['++', '--', '+', '-', '~', '!', 'typeof', 'void', 'delete', 'await']
+        .toSet();
 
   static final OPERATORS_THAT_LOOK_LIKE_IDENTIFIERS =
-      ['typeof', 'void', 'delete', 'in', 'instanceof'].toSet();
+      ['typeof', 'void', 'delete', 'in', 'instanceof', 'await'].toSet();
 
   static int category(int code) {
     if (code >= CATEGORIES.length) return OTHER;
     return CATEGORIES[code];
   }
 
   String getDelimited(int startPosition) {
     position = startPosition;
     int delimiter = src.codeUnitAt(startPosition);
     int currentCode;
@@ skipping 253 matching lines @@
         } else {
           String argumentName = lastToken;
           expectCategory(ALPHA);
           params.add(new Parameter(argumentName));
         }
         if (acceptCategory(COMMA)) continue;
         expectCategory(RPAREN);
         break;
       }
     }
-
+    AsyncModifier asyncModifier;
+    if (acceptString('async')) {
+      if (acceptString('*')) {
+        asyncModifier = const AsyncModifier.asyncStar();
+      } else {
+        asyncModifier = const AsyncModifier.async();
+      }
+    } else if (acceptString('sync')) {
+      if (!acceptString('*')) error("Only sync* is valid - sync is implied");
+      asyncModifier = const AsyncModifier.syncStar();
+    } else {
+      asyncModifier = const AsyncModifier.sync();
+    }
     expectCategory(LBRACE);
     Block block = parseBlock();
-    return new Fun(params, block);
+    return new Fun(params, block, asyncModifier: asyncModifier);
   }
 
   Expression parseObjectInitializer() {
     List<Property> properties = <Property>[];
     for (;;) {
       if (acceptCategory(RBRACE)) break;
       // Limited subset: keys are identifiers, no 'get' or 'set' properties.
       Literal propertyName;
       String identifier = lastToken;
       if (acceptCategory(ALPHA)) {
@@ skipping 101 matching lines @@
     }
     // If we don't accept '++' or '--' due to skippedNewline a newline, no other
     // part of the parser will accept the token and we will get an error at the
     // whole expression level.
     return expression;
   }
 
   Expression parseUnaryHigh() {
     String operator = lastToken;
     if (lastCategory == SYMBOL && UNARY_OPERATORS.contains(operator) &&
-        (acceptString("++") || acceptString("--"))) {
+        (acceptString("++") || acceptString("--") || acceptString('await'))) {
+      if (operator == "await") return new Await(parsePostfix());
       return new Prefix(operator, parsePostfix());
     }
     return parsePostfix();
   }
 
   Expression parseUnaryLow() {
     String operator = lastToken;
     if (lastCategory == SYMBOL && UNARY_OPERATORS.contains(operator) &&
         operator != "++" && operator != "--") {
       expectCategory(SYMBOL);
+      if (operator == "await") return new Await(parsePostfix());
       return new Prefix(operator, parseUnaryLow());
     }
     return parseUnaryHigh();
   }
 
   Expression parseBinary(int maxPrecedence) {
     Expression lhs = parseUnaryLow();
     int minPrecedence;
     String lastSymbol;
     Expression rhs;  // This is null first time around.
@@ skipping 142 matching lines @@
       if (acceptString('function')) return parseFunctionDeclaration();
 
       if (acceptString('try')) return parseTry();
 
       if (acceptString('var')) {
         Expression declarations = parseVariableDeclarationList();
         expectSemicolon();
         return new ExpressionStatement(declarations);
       }
 
-      if (lastToken == 'case' ||
-          lastToken == 'do' ||
-          lastToken == 'while' ||
-          lastToken == 'switch' ||
-          lastToken == 'with') {
+      if (acceptString('while')) return parseWhile();
+
+      if (acceptString('do')) return parseDo();
+
+      if (acceptString('switch')) return parseSwitch();
+
+      if (lastToken == 'case') error("Case outside switch.");
+
+      if (lastToken == 'default') error("Default outside switch.");
+
+      if (lastToken == 'with') {
         error('Not implemented in mini parser');
       }
     }
 
-
-    // TODO:  label: statement
-
     bool checkForInterpolatedStatement = lastCategory == HASH;
 
     Expression expression = parseExpression();
+
+    if (expression is VariableUse && acceptCategory(COLON)) {
+      return new LabeledStatement(expression.name, parseStatement());
+    }
+
     expectSemicolon();
 
     if (checkForInterpolatedStatement) {
       // 'Promote' the interpolated expression `#;` to an interpolated
       // statement.
       if (expression is InterpolatedExpression) {
         assert(identical(interpolatedValues.last, expression));
         InterpolatedStatement statement =
             new InterpolatedStatement(expression.nameOrPosition);
         interpolatedValues[interpolatedValues.length - 1] = statement;
@@ skipping 109 matching lines @@
     Block finallyPart = null;
     if (acceptString('finally')) {
       expectCategory(LBRACE);
       finallyPart = parseBlock();
     } else {
       if (catchPart == null) error("expected 'finally'");
     }
     return new Try(body, catchPart, finallyPart);
   }
 
+  SwitchClause parseSwitchClause() {
+    Expression expression = null;
+    if (acceptString('case')) {
+      expression = parseExpression();
+      acceptCategory(COLON);

[asgerf, 2015/01/16 16:23:26]

I think this should be expectCategory

[sigurdm, 2015/01/20 07:54:56]

Done.

+    } else {
+      if (!acceptString('default')) {
+        error('expected case or default');
+      }
+      expectCategory(COLON);
+    }
+    List statements = new List<Statement>();
+    while (lastCategory != RBRACE &&
+           lastToken != 'case' &&
+           lastToken != 'default') {
+      statements.add(parseStatement());
+    }
+    return expression == null
+        ? new Default(new Block(statements))
+        : new Case(expression, new Block(statements));
+  }
+
+  Statement parseWhile() {
+    expectCategory(LPAREN);
+    Expression condition = parseExpression();
+    expectCategory(RPAREN);
+    Statement body = parseStatement();
+    return new While(condition, body);
+  }
+
+  Statement parseDo() {
+    Statement body = parseStatement();
+    getToken();
+    if (lastToken == "while") error("Missing while after do body.");

[asgerf, 2015/01/16 16:23:26]

lastToken != 'while'

[sigurdm, 2015/01/20 07:54:56]

Yes - thank you!

+    expectCategory(LPAREN);
+    Expression condition = parseExpression();
+    expectCategory(RPAREN);
+    expectSemicolon();
+    return new Do(body, condition);
+  }
+
+  Statement parseSwitch() {
+    expectCategory(LPAREN);
+    Expression key = parseExpression();
+    expectCategory(RPAREN);
+    expectCategory(LBRACE);
+    List<SwitchClause> clauses = new List<SwitchClause>();
+    while(lastCategory != RBRACE) {
+      clauses.add(parseSwitchClause());
+    }
+    expectCategory(RBRACE);
+    return new Switch(key, clauses);
+  }
+
   Catch parseCatch() {
     expectCategory(LPAREN);
     String identifier = lastToken;
     expectCategory(ALPHA);
     expectCategory(RPAREN);
     expectCategory(LBRACE);
     Block body = parseBlock();
     return new Catch(new VariableDeclaration(identifier), body);
   }
 }