Implement await and async for the js-ast.

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

 // Copyright (c) 2014, 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 js;
 
 class TemplateManager {
   Map<String, Template> expressionTemplates = new Map<String, Template>();
   Map<String, Template> statementTemplates = new Map<String, Template>();
 
@@ skipping 70 matching lines @@
     generator.compile(ast);
     return generator.analysis.count == 0;
   }
 
   void _compile() {
     InstantiatorGeneratorVisitor generator =
         new InstantiatorGeneratorVisitor(forceCopy);
     instantiator = generator.compile(ast);
     positionalArgumentCount = generator.analysis.count;
     Set<String> names = generator.analysis.holeNames;
-    holeNames = names.isEmpty ? null : names.toList(growable:false);
+    holeNames = names.toList(growable:false);
   }
 
   /// Instantiates the template with the given [arguments].
   ///
   /// This method fills in the holes with the given arguments. The [arguments]
   /// must be either a [List] or a [Map].
   Node instantiate(var arguments) {
     if (arguments is List) {
       if (arguments.length != positionalArgumentCount) {
         throw 'Wrong number of template arguments, given ${arguments.length}, '
@@ skipping 299 matching lines @@
           makeLeftHandSide(arguments),
           makeObject(arguments),
           makeBody(arguments));
     };
   }
 
   TODO(String name) {
     throw new UnimplementedError('$this.$name');
   }
 
-  Instantiator visitWhile(While node) => TODO('visitWhile');
-  Instantiator visitDo(Do node) => TODO('visitDo');
+  Instantiator visitWhile(While node) {
+    Instantiator makeCondition = visit(node.condition);
+    Instantiator makeBody = visit(node.body);
+    return (arguments) {
+      return new While(makeCondition(arguments), makeBody(arguments));
+    };
+  }
+
+  Instantiator visitDo(Do node) {
+    Instantiator makeBody = visit(node.body);
+    Instantiator makeCondition = visit(node.condition);
+    return (arguments) {
+      return new Do(makeBody(arguments), makeCondition(arguments));
+    };
+  }
 
   Instantiator visitContinue(Continue node) =>
       (arguments) => new Continue(node.targetLabel);
 
   Instantiator visitBreak(Break node) =>
       (arguments) => new Break(node.targetLabel);
 
   Instantiator visitReturn(Return node) {
     Instantiator makeExpression = visitNullable(node.value);
     return (arguments) => new Return(makeExpression(arguments));
   }
 
   Instantiator visitThrow(Throw node) {
     Instantiator makeExpression = visit(node.expression);
     return (arguments) => new Throw(makeExpression(arguments));
   }
 
-
   Instantiator visitTry(Try node) {
     Instantiator makeBody = visit(node.body);
     Instantiator makeCatch = visitNullable(node.catchPart);
     Instantiator makeFinally = visitNullable(node.finallyPart);
     return (arguments) => new Try(
         makeBody(arguments), makeCatch(arguments), makeFinally(arguments));
   }
 
   Instantiator visitCatch(Catch node) {
     Instantiator makeDeclaration = visit(node.declaration);
     Instantiator makeBody = visit(node.body);
     return (arguments) => new Catch(
         makeDeclaration(arguments), makeBody(arguments));
   }
 
-  Instantiator visitSwitch(Switch node) => TODO('visitSwitch');
-  Instantiator visitCase(Case node) => TODO('visitCase');
-  Instantiator visitDefault(Default node) => TODO('visitDefault');
+  Instantiator visitSwitch(Switch node) {
+    Instantiator makeKey = visit(node.key);
+    Iterable<Instantiator> makeCases = node.cases.map(visit);
+    return (arguments) {
+      return new Switch(makeKey(arguments),
+          makeCases.map((Instantiator makeCase) => makeCase(arguments))
+                   .toList());
+    };
+  }
+
+  Instantiator visitCase(Case node) {
+    Instantiator makeExpression = visit(node.expression);
+    Instantiator makeBody = visit(node.body);
+    return (arguments) {
+      return new Case(makeExpression(arguments), makeBody(arguments));
+    };
+  }
+
+  Instantiator visitDefault(Default node) {
+    Instantiator makeBody = visit(node.body);
+    return (arguments) {
+      return new Default(makeBody(arguments));
+    };
+  }
 
   Instantiator visitFunctionDeclaration(FunctionDeclaration node) {
     Instantiator makeName = visit(node.name);
     Instantiator makeFunction = visit(node.function);
     return (arguments) =>
         new FunctionDeclaration(makeName(arguments), makeFunction(arguments));
   }
 
   Instantiator visitLabeledStatement(LabeledStatement node) =>
       TODO('visitLabeledStatement');
@@ skipping 192 matching lines @@
     Instantiator makeValue = visit(node.value);
     return (arguments) {
       return new Property(makeName(arguments), makeValue(arguments));
     };
   }
 
   Instantiator visitRegExpLiteral(RegExpLiteral node) =>
       (arguments) => new RegExpLiteral(node.pattern);
 
   Instantiator visitComment(Comment node) => TODO('visitComment');
+
+  Instantiator visitAwait(Await node) {
+    Instantiator makeExpression = visit(node.expression);
+    return (arguments) {
+      return new Await(makeExpression(arguments));
+    };
+  }
 }
 
 /**
  * InterpolatedNodeAnalysis extract [InterpolatedNode]s from AST.
  */
 class InterpolatedNodeAnalysis extends BaseVisitor {
   final Setlet<Node> containsInterpolatedNode = new Setlet<Node>();
   final List<InterpolatedNode> interpolatedNodes = <InterpolatedNode>[];
   final Setlet<String> holeNames = new Setlet<String>();
   int count = 0;
@@ skipping 14 matching lines @@
     return null;
   }
 
   visitInterpolatedNode(InterpolatedNode node) {
     interpolatedNodes.add(node);
     containsInterpolatedNode.add(node);
     if (node.isNamed) holeNames.add(node.nameOrPosition);
     ++count;
   }
 }