use js_ast instead of strings to generate JS

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_ast;
 
 
 class JavaScriptPrintingOptions {
   final bool shouldCompressOutput;
   final bool minifyLocalVariables;
   final bool preferSemicolonToNewlineInMinifiedOutput;
+  final bool avoidKeywordsInIdentifiers;
 
   JavaScriptPrintingOptions(
       {this.shouldCompressOutput: false,
        this.minifyLocalVariables: false,
-       this.preferSemicolonToNewlineInMinifiedOutput: false});
+       this.preferSemicolonToNewlineInMinifiedOutput: false,
+       this.avoidKeywordsInIdentifiers: false});
 }
 
 
 /// An environment in which JavaScript printing is done.  Provides emitting of
 /// text and pre- and post-visit callbacks.
 abstract class JavaScriptPrintingContext {
   /// Signals an error.  This should happen only for serious internal errors.
   void error(String message) { throw message; }
 
   /// Adds [string] to the output.
@@ skipping 310 matching lines @@
     visitNestedExpression(loop.leftHandSide, EXPRESSION,
                           newInForInit: true, newAtStatementBegin: false);
     out(" in");
     pendingSpace = true;
     visitNestedExpression(loop.object, EXPRESSION,
                           newInForInit: false, newAtStatementBegin: false);
     out(")");
     blockBody(loop.body, needsSeparation: false, needsNewline: true);
   }
 
+  visitForOf(ForOf loop) {
+    outIndent("for");
+    spaceOut();
+    out("(");
+    visitNestedExpression(loop.leftHandSide, EXPRESSION,
+    newInForInit: true, newAtStatementBegin: false);
+    out(" of");
+    pendingSpace = true;
+    visitNestedExpression(loop.iterable, EXPRESSION,
+    newInForInit: false, newAtStatementBegin: false);
+    out(")");
+    blockBody(loop.body, needsSeparation: false, needsNewline: true);
+  }
+
   visitWhile(While loop) {
     outIndent("while");
     spaceOut();
     out("(");
     visitNestedExpression(loop.condition, EXPRESSION,
                           newInForInit: false, newAtStatementBegin: false);
     out(")");
     blockBody(loop.body, needsSeparation: false, needsNewline: true);
   }
 
@@ skipping 176 matching lines @@
                         {bool newInForInit, bool newAtStatementBegin}) {
     bool needsParentheses =
         // a - (b + c).
         (requiredPrecedence != EXPRESSION &&
          node.precedenceLevel < requiredPrecedence) ||
         // for (a = (x in o); ... ; ... ) { ... }
         (newInForInit && node is Binary && node.op == "in") ||
         // (function() { ... })().
         // ({a: 2, b: 3}.toString()).
         (newAtStatementBegin && (node is NamedFunction ||
-                                 node is Fun ||
+                                 node is FunctionExpression ||
                                  node is ObjectInitializer));
     if (needsParentheses) {
       inForInit = false;
       atStatementBegin = false;
       out("(");
       visit(node);
       out(")");
     } else {
       inForInit = newInForInit;
       atStatementBegin = newAtStatementBegin;
       visit(node);
     }
   }
 
   visitVariableDeclarationList(VariableDeclarationList list) {
-    out("var ");
+    out(list.keyword);
+    out(" ");
     visitCommaSeparated(list.declarations, ASSIGNMENT,
                         newInForInit: inForInit, newAtStatementBegin: false);
   }
 
   visitAssignment(Assignment assignment) {
     visitNestedExpression(assignment.leftHandSide, LEFT_HAND_SIDE,
                           newInForInit: inForInit,
                           newAtStatementBegin: atStatementBegin);
     if (assignment.value != null) {
       spaceOut();
@@ skipping 186 matching lines @@
   }
 
   visitVariableUse(VariableUse ref) {
     out(localNamer.getName(ref.name));
   }
 
   visitThis(This node) {
     out("this");
   }
 
+  visitSuper(Super node) {
+    out("super");
+  }
+
   visitVariableDeclaration(VariableDeclaration decl) {
     out(localNamer.getName(decl.name));
   }
 
   visitParameter(Parameter param) {
     out(localNamer.getName(param.name));
   }
 
   bool isDigit(int charCode) {
     return charCodes.$0 <= charCode && charCode <= charCodes.$9;
   }
 
   bool isValidJavaScriptId(String field) {
     if (field.length < 3) return false;
     // Ignore the leading and trailing string-delimiter.
     for (int i = 1; i < field.length - 1; i++) {
       // TODO(floitsch): allow more characters.
       int charCode = field.codeUnitAt(i);
       if (!(charCodes.$a <= charCode && charCode <= charCodes.$z ||
             charCodes.$A <= charCode && charCode <= charCodes.$Z ||
             charCode == charCodes.$$ ||
             charCode == charCodes.$_ ||
             i != 1 && isDigit(charCode))) {
         return false;
       }
     }
-    // TODO(floitsch): normally we should also check that the field is not a
-    // reserved word.  We don't generate fields with reserved word names except
-    // for 'super'.
-    if (field == '"super"') return false;
-    return true;
+
+    if (options.avoidKeywordsInIdentifiers) {
+      return !_isJsKeyword(field.substring(1, field.length - 1));
+    } else {
+      // TODO(floitsch): normally we should also check that the field is not a
+      // reserved word.  We don't generate fields with reserved word names except
+      // for 'super'.
+      return field != '"super"';
+    }
+  }
+
+  static bool _isJsKeyword(String keyword) {
+    switch (keyword) {
+      case "break":
+      case "case":
+      case "catch":
+      case "class":
+      case "const":
+      case "continue":
+      case "debugger":
+      case "default":
+      case "delete":
+      case "do":
+      case "else":
+      case "export":
+      case "extends":
+      case "finally":
+      case "for":
+      case "function":
+      case "if":
+      case "import":
+      case "in":
+      case "instanceof":
+      case "let":
+      case "new":
+      case "return":
+      case "static":
+      case "super":
+      case "switch":
+      case "this":
+      case "throw":
+      case "try":
+      case "typeof":
+      case "var":
+      case "void":
+      case "while":
+      case "with":
+      case "yield":
+        return true;
+    }
+    return false;
   }
 
   visitAccess(PropertyAccess access) {
     visitNestedExpression(access.receiver, CALL,
                           newInForInit: inForInit,
                           newAtStatementBegin: atStatementBegin);
     Node selector = access.selector;
     if (selector is LiteralString) {
       LiteralString selectorString = selector;
       String fieldWithQuotes = selectorString.value;
@@ skipping 15 matching lines @@
     vars.visitNamedFunction(namedFunction);
     functionOut(namedFunction.function, namedFunction.name, vars);
   }
 
   visitFun(Fun fun) {
     VarCollector vars = new VarCollector();
     vars.visitFun(fun);
     functionOut(fun, null, vars);
   }
 
+  visitArrowFun(ArrowFun fun) {
+    VarCollector vars = new VarCollector();
+    vars.visitArrowFun(fun);
+    localNamer.enterScope(vars);
+    out("(");
+    if (fun.params != null) {
+      visitCommaSeparated(fun.params, PRIMARY,
+          newInForInit: false, newAtStatementBegin: false);
+    }
+    out(")");
+    spaceOut();
+    out("=>");
+    if (fun.body is Expression) {
+      spaceOut();
+      fun.body.accept(this);
+    } else {
+      blockBody(fun.body, needsSeparation: false, needsNewline: false);
+    }
+    localNamer.leaveScope();
+  }
+
   visitLiteralBool(LiteralBool node) {
     out(node.value ? "true" : "false");
   }
 
   visitLiteralString(LiteralString node) {
     out(node.value);
   }
 
   visitLiteralNumber(LiteralNumber node) {
     int charCode = node.value.codeUnitAt(0);
@@ skipping 34 matching lines @@
     throw "Unreachable";
   }
 
   visitObjectInitializer(ObjectInitializer node) {
     // Print all the properties on one line until we see a function-valued
     // property.  Ideally, we would use a proper pretty-printer to make the
     // decision based on layout.
     List<Property> properties = node.properties;
     out("{");
     indentMore();
+
+    var isOneLiner = !properties.any((p) => p.value is FunctionExpression);
     for (int i = 0; i < properties.length; i++) {
-      Expression value = properties[i].value;
       if (i != 0) {
         out(",");
-        if (node.isOneLiner) spaceOut();
+        if (isOneLiner) spaceOut();
       }
-      if (!node.isOneLiner) {
+      if (!isOneLiner) {
         forceLine();
         indent();
       }
       visit(properties[i]);
     }
     indentLess();
-    if (!node.isOneLiner && !properties.isEmpty) {
+    if (!isOneLiner) {
       lineOut();
       indent();
     }
     out("}");
   }
 
   visitProperty(Property node) {
-    if (node.name is LiteralString) {
-      LiteralString nameString = node.name;
-      String name = nameString.value;
-      if (isValidJavaScriptId(name)) {
-        out(name.substring(1, name.length - 1));
-      } else {
-        out(name);
-      }
-    } else {
-      assert(node.name is LiteralNumber);
-      LiteralNumber nameNumber = node.name;
-      out(nameNumber.value);
-    }
+    propertyNameOut(node.name);
     out(":");
     spaceOut();
     visitNestedExpression(node.value, ASSIGNMENT,
                           newInForInit: false, newAtStatementBegin: false);
   }
 
   visitRegExpLiteral(RegExpLiteral node) {
     out(node.pattern);
   }
 
+  visitTemplateString(TemplateString node) {
+    out('`');
+    for (var element in node.elements) {
+      if (element is String) {
+        out(element);
+      } else {
+        out(r'${');
+        visit(element);
+        out('}');
+      }
+    }
+    out('`');
+  }
+
+  visitTaggedTemplate(TaggedTemplate node) {
+    visit(node.tag);
+    visit(node.template);
+  }
+
+  visitClassDeclaration(ClassDeclaration node) {
+    indent();
+    visit(node.classExpr);
+    lineOut();
+  }
+
+  visitClassExpression(ClassExpression node) {
+    out('class ');
+    visit(node.name);
+    if (node.heritage != null) {
+      out(' extends ');
+      visit(node.heritage);
+      spaceOut();
+    }
+    out('{');
+    lineOut();
+    indentMore();
+    for (var method in node.methods) {
+      indent();
+      visit(method);
+      lineOut();
+    }
+    indentLess();
+    indent();
+    out('}');
+  }
+
+  visitMethod(Method node) {
+    if (node.isStatic) {
+      out('static ');
+    }
+    if (node.isGetter) {
+      out('get ');
+    } else if (node.isSetter) {
+      out('set ');
+    }
+    var vars = new VarCollector();
+    vars.visitMethod(node);
+
+    propertyNameOut(node.name, inMethod: true);
+
+    localNamer.enterScope(vars);
+    out("(");
+    var fun = node.function;
+    if (fun.params != null) {
+      visitCommaSeparated(fun.params, PRIMARY,
+          newInForInit: false, newAtStatementBegin: false);
+    }
+    out(")");
+    // TODO(jmesserly): async modifiers
+    if (fun.body.statements.isEmpty) {
+      spaceOut();
+      out("{}");
+    } else {
+      blockBody(fun.body, needsSeparation: false, needsNewline: false);
+    }
+    localNamer.leaveScope();
+  }
+
+  visitPropertyName(PropertyName node) => propertyNameOut(node);
+
+  void propertyNameOut(Expression node, {bool inMethod: false}) {
+    inForInit = false;
+    atStatementBegin = false;
+
+    if (node is LiteralNumber) {
+      LiteralNumber nameNumber = node;
+      out(nameNumber.value);
+    } else {
+      String quotedName;
+      if (node is PropertyName) {
+        quotedName = "'${node.name}'";
+      } else if (node is LiteralString) {
+        quotedName = node.value;
+      }
+      if (quotedName != null) {
+        if (isValidJavaScriptId(quotedName)) {
+          out(quotedName.substring(1, quotedName.length - 1));
+        } else {
+          if (inMethod) out("[");
+          out(quotedName);
+          if (inMethod) out("]");
+        }
+      } else {
+        // ComputedPropertyName
+        out("[");
+        visit(node);
+        out("]");
+      }
+    }
+  }
+
   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) {
       context.error('Wrong number of arguments for JS: $template');
     }
     // Code that uses JS must take care of operator precedences, and
@@ skipping 18 matching lines @@
 
   visitInterpolatedLiteral(InterpolatedLiteral node) =>
       visitInterpolatedNode(node);
 
   visitInterpolatedParameter(InterpolatedParameter node) =>
       visitInterpolatedNode(node);
 
   visitInterpolatedSelector(InterpolatedSelector node) =>
       visitInterpolatedNode(node);
 
+  visitInterpolatedPropertyName(InterpolatedPropertyName node) =>
+      visitInterpolatedNode(node);
+
+  visitInterpolatedMethod(InterpolatedMethod node) =>
+      visitInterpolatedNode(node);
+
+  visitInterpolatedVariableDeclaration(InterpolatedVariableDeclaration node) =>
+      visitInterpolatedNode(node);
+
   visitInterpolatedStatement(InterpolatedStatement node) {
     outLn('#${node.nameOrPosition}');
   }
 
   void visitComment(Comment node) {
     if (shouldCompressOutput) return;
     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 visitCommentExpression(CommentExpression node) {
+    if (shouldCompressOutput) return;
+    String comment = node.comment.trim();
+    if (comment.isEmpty) return;
+    if (comment.startsWith('/*')) {
+      out(comment);
+    } else {
+      out('/* $comment */');
+    }
+    visit(node.expression);
+  }
+
   void visitAwait(Await node) {
     out("await ");
     visit(node.expression);
   }
 }
 
 
 class OrderedSet<T> {
   final Set<T> set;
   final List<T> list;
@@ skipping 19 matching lines @@
   final OrderedSet<String> vars;
   final OrderedSet<String> params;
 
   VarCollector() : nested = false,
                    vars = new OrderedSet<String>(),
                    params = new OrderedSet<String>();
 
   void forEachVar(void fn(String v)) => vars.forEach(fn);
   void forEachParam(void fn(String p)) => params.forEach(fn);
 
-  void collectVarsInFunction(Fun fun) {
+  void collectVarsInFunction(FunctionExpression fun) {
     if (!nested) {
       nested = true;
       if (fun.params != null) {
         for (int i = 0; i < fun.params.length; i++) {
           params.add(fun.params[i].name);
         }
       }
-      visitBlock(fun.body);
+      fun.body.accept(this);
       nested = false;
     }
   }
 
   void visitFunctionDeclaration(FunctionDeclaration declaration) {
     // Note that we don't bother collecting the name of the function.
     collectVarsInFunction(declaration.function);
   }
 
   void visitNamedFunction(NamedFunction namedFunction) {
     // Note that we don't bother collecting the name of the function.
     collectVarsInFunction(namedFunction.function);
   }
 
+  void visitMethod(Method declaration) {
+    // Note that we don't bother collecting the name of the function.
+    collectVarsInFunction(declaration.function);
+  }
+
   void visitFun(Fun fun) {
     collectVarsInFunction(fun);
   }
 
+  void visitArrowFun(ArrowFun fun) {
+    collectVarsInFunction(fun);
+  }
+
   void visitThis(This node) {}
 
   void visitVariableDeclaration(VariableDeclaration decl) {
     if (decl.allowRename) vars.add(decl.name);
   }
 }
 
 
 /**
  * Returns true, if the given node must be wrapped into braces when used
@@ skipping 13 matching lines @@
 
   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);
   }
   bool visitFor(For node) => node.body.accept(this);
   bool visitForIn(ForIn node) => node.body.accept(this);
+  bool visitForOf(ForOf node) => node.body.accept(this);
   bool visitWhile(While node) => node.body.accept(this);
   bool visitDo(Do node) => false;
   bool visitContinue(Continue node) => false;
   bool visitBreak(Break node) => false;
   bool visitReturn(Return node) => false;
   bool visitThrow(Throw node) => false;
   bool visitTry(Try node) {
     if (node.finallyPart != null) {
       return node.finallyPart.accept(this);
     } else {
       return node.catchPart.accept(this);
     }
   }
   bool visitCatch(Catch node) => node.body.accept(this);
   bool visitSwitch(Switch node) => false;
   bool visitCase(Case node) => false;
   bool visitDefault(Default node) => false;
   bool visitFunctionDeclaration(FunctionDeclaration node) => false;
   bool visitLabeledStatement(LabeledStatement node)
       => node.body.accept(this);
   bool visitLiteralStatement(LiteralStatement node) => true;
+  bool visitClassDeclaration(ClassDeclaration) => false;
 
   bool visitExpression(Expression node) => false;
 }
 
 
 abstract class LocalNamer {
   String getName(String oldName);
   String declareVariable(String oldName);
   String declareParameter(String oldName);
   void enterScope(VarCollector vars);
@@ skipping 123 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;
   }
 }