Implement await and async for the js-ast.

pkg/compiler/lib/src/js/printer.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 js;
 
 class Printer extends Indentation implements NodeVisitor {
   final bool shouldCompressOutput;
-  leg.Compiler compiler;
+  leg.DiagnosticListener diagnosticListener;
   CodeBuffer outBuffer;
   bool inForInit = false;
   bool atStatementBegin = false;
   final DanglingElseVisitor danglingElseVisitor;
   final LocalNamer localNamer;
   bool pendingSemicolon = false;
   bool pendingSpace = false;
   DumpInfoTask monitor = null;
 
   static final identifierCharacterRegExp = new RegExp(r'^[a-zA-Z_0-9$]');
   static final expressionContinuationRegExp = new RegExp(r'^[-+([]');
 
-  Printer(leg.Compiler compiler, DumpInfoTask monitor,
-          { allowVariableMinification: true })
-      : shouldCompressOutput = compiler.enableMinification,
+  Printer(leg.DiagnosticListener diagnosticListener, DumpInfoTask monitor,
+          { bool enableMinification: false, allowVariableMinification: true })
+      : shouldCompressOutput = enableMinification,
         monitor = monitor,
-        this.compiler = compiler,
+        diagnosticListener = diagnosticListener,
         outBuffer = new CodeBuffer(),
-        danglingElseVisitor = new DanglingElseVisitor(compiler),
-        localNamer = determineRenamer(compiler.enableMinification,
+        danglingElseVisitor = new DanglingElseVisitor(diagnosticListener),
+        localNamer = determineRenamer(enableMinification,
                                       allowVariableMinification);
 
   static LocalNamer determineRenamer(bool shouldCompressOutput,
                                      bool allowVariableMinification) {
     return (shouldCompressOutput && allowVariableMinification)
         ? new MinifyRenamer() : new IdentityNamer();
   }
 
   /// Always emit a newline, even under `enableMinification`.
   void forceLine() {
@@ skipping 393 matching lines @@
       visitNestedExpression(name, PRIMARY,
                             newInForInit: false, newAtStatementBegin: false);
     }
     localNamer.enterScope(vars);
     out("(");
     if (fun.params != null) {
       visitCommaSeparated(fun.params, PRIMARY,
                           newInForInit: false, newAtStatementBegin: false);
     }
     out(")");
+    switch (fun.asyncModifier) {
+      case const AsyncModifier.sync():
+        break;
+      case const AsyncModifier.async():
+        out(' async');
+        break;
+      case const AsyncModifier.syncStar():
+        out(' sync*');
+        break;
+      case const AsyncModifier.asyncStar():
+        out(' async*');
+        break;
+    }
     blockBody(fun.body, needsSeparation: false, needsNewline: false);
     localNamer.leaveScope();
   }
 
   visitFunctionDeclaration(FunctionDeclaration declaration) {
     VarCollector vars = new VarCollector();
     vars.visitFunctionDeclaration(declaration);
     indent();
     functionOut(declaration.function, declaration.name, vars);
     lineOut();
@@ skipping 160 matching lines @@
         rightPrecedenceRequirement = MULTIPLICATIVE;
         break;
       case "*":
       case "/":
       case "%":
         leftPrecedenceRequirement = MULTIPLICATIVE;
         // We cannot remove parenthesis for "*" because of precision issues.
         rightPrecedenceRequirement = UNARY;
         break;
       default:
-        compiler.internalError(NO_LOCATION_SPANNABLE, "Forgot operator: $op");
+        diagnosticListener
+            .internalError(NO_LOCATION_SPANNABLE, "Forgot operator: $op");
     }
 
     visitNestedExpression(left, leftPrecedenceRequirement,
                           newInForInit: inForInit,
                           newAtStatementBegin: atStatementBegin);
 
     if (op == "in" || op == "instanceof") {
       // There are cases where the space is not required but without further
       // analysis we cannot know.
       out(" ");
@@ skipping 216 matching lines @@
     out(node.pattern);
   }
 
   visitLiteralExpression(LiteralExpression node) {
     String template = node.template;
     List<Expression> inputs = node.inputs;
 
     List<String> parts = template.split('#');
     int inputsLength = inputs == null ? 0 : inputs.length;
     if (parts.length != inputsLength + 1) {
-      compiler.internalError(NO_LOCATION_SPANNABLE,
+      diagnosticListener.internalError(NO_LOCATION_SPANNABLE,
           'Wrong number of arguments for JS: $template');
     }
     // Code that uses JS must take care of operator precedences, and
     // put parenthesis if needed.
     out(parts[0]);
     for (int i = 0; i < inputsLength; i++) {
       visit(inputs[i]);
       out(parts[i + 1]);
     }
   }
@@ skipping 27 matching lines @@
     String comment = node.comment.trim();
     if (comment.isEmpty) return;
     for (var line in comment.split('\n')) {
       if (comment.startsWith('//')) {
         outIndentLn(line.trim());
       } else {
         outIndentLn('// ${line.trim()}');
       }
     }
   }
+
+  void visitAwait(Await node) {
+    out("await ");
+    visit(node.expression);
+  }
 }
 
 
 class OrderedSet<T> {
   final Set<T> set;
   final List<T> list;
 
   OrderedSet() : set = new Set<T>(), list = <T>[];
 
   void add(T x) {
@@ skipping 55 matching lines @@
     if (decl.allowRename) vars.add(decl.name);
   }
 }
 
 
 /**
  * Returns true, if the given node must be wrapped into braces when used
  * as then-statement in an [If] that has an else branch.
  */
 class DanglingElseVisitor extends BaseVisitor<bool> {
-  leg.Compiler compiler;
+  leg.DiagnosticListener diagnosticListener;
 
-  DanglingElseVisitor(this.compiler);
+  DanglingElseVisitor(this.diagnosticListener);
 
   bool visitProgram(Program node) => false;
 
   bool visitNode(Statement node) {
-    compiler.internalError(NO_LOCATION_SPANNABLE, "Forgot node: $node");
+    diagnosticListener
+        .internalError(NO_LOCATION_SPANNABLE, "Forgot node: $node");
     return null;
   }
 
   bool visitBlock(Block node) => false;
   bool visitExpressionStatement(ExpressionStatement node) => false;
   bool visitEmptyStatement(EmptyStatement node) => false;
   bool visitIf(If node) {
     if (!node.hasElse) return true;
     return node.otherwise.accept(this);
   }
@@ skipping 23 matching lines @@
 
   bool visitExpression(Expression node) => false;
 }
 
 
 CodeBuffer prettyPrint(Node node, leg.Compiler compiler,
                        {DumpInfoTask monitor,
                         bool allowVariableMinification: true}) {
   Printer printer =
       new Printer(compiler, monitor,
+                  enableMinification: compiler.enableMinification,
                   allowVariableMinification: allowVariableMinification);
   printer.visit(node);
   return printer.outBuffer;
 }
 
 
 abstract class LocalNamer {
   String getName(String oldName);
   String declareVariable(String oldName);
   String declareParameter(String oldName);
@@ skipping 124 matching lines @@
         codes.add(nthLetter((n ~/ nameSpaceSize) % LETTERS));
       }
       codes.add(charCodes.$0 + digit);
       newName = new String.fromCharCodes(codes);
     }
     assert(new RegExp(r'[a-zA-Z][a-zA-Z0-9]*').hasMatch(newName));
     maps.last[oldName] = newName;
     return newName;
   }
 }