Steps towards making dart2js JS AST templates an indepentent library.

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 {
+
+class JavaScriptPrintingOptions {
   final bool shouldCompressOutput;
-  leg.DiagnosticListener diagnosticListener;
-  CodeBuffer outBuffer;
+  final bool minifyLocalVariables;
+  JavaScriptPrintingOptions(
+      {this.shouldCompressOutput: false,
+       this.minifyLocalVariables: false});
+}
+
+/**
+ * An environment in which JavaScript printing is done.
+ *
+ * The context contains

[floitsch, 2015/02/10 14:43:52]

nit: we tend to use "///" now (and this file seems to use it already).

[sra1, 2015/02/11 00:13:07]

Done. I prefer /**/ for longer comments, but /// looks OK to me for up to 2-3
lines.

+ */
+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.
+  void emit(String string);
+
+  void enterNode(Node node) {}
+  void exitNode(Node node) {}
+}
+
+
+class Printer implements NodeVisitor {
+  final JavaScriptPrintingOptions options;
+  final JavaScriptPrintingContext context;
+  final bool shouldCompressOutput;
+  final DanglingElseVisitor danglingElseVisitor;
+  final LocalNamer localNamer;
+
   bool inForInit = false;
   bool atStatementBegin = false;
-  final DanglingElseVisitor danglingElseVisitor;
-  final LocalNamer localNamer;
   bool pendingSemicolon = false;
   bool pendingSpace = false;
-  DumpInfoTask monitor = null;
+
+  // The current indentation level.
+  int _indentLevel = 0;
+  // A cache of all indentation strings used so far.
+  List<String> _indentList = <String>[""];
 
   static final identifierCharacterRegExp = new RegExp(r'^[a-zA-Z_0-9$]');
   static final expressionContinuationRegExp = new RegExp(r'^[-+([]');
 
-  Printer(leg.DiagnosticListener diagnosticListener, DumpInfoTask monitor,
-          { bool enableMinification: false, allowVariableMinification: true })
-      : shouldCompressOutput = enableMinification,
-        monitor = monitor,
-        diagnosticListener = diagnosticListener,
-        outBuffer = new CodeBuffer(),
-        danglingElseVisitor = new DanglingElseVisitor(diagnosticListener),
-        localNamer = determineRenamer(enableMinification,
-                                      allowVariableMinification);
+  Printer(JavaScriptPrintingOptions options,
+          JavaScriptPrintingContext context)
+      : options = options,
+        context = context,
+        shouldCompressOutput = options.shouldCompressOutput,
+        danglingElseVisitor = new DanglingElseVisitor(context),
+        localNamer = determineRenamer(options.shouldCompressOutput,
+                                      options.minifyLocalVariables);
 
   static LocalNamer determineRenamer(bool shouldCompressOutput,
                                      bool allowVariableMinification) {
     return (shouldCompressOutput && allowVariableMinification)
         ? new MinifyRenamer() : new IdentityNamer();
   }
 
+
+  // The current indentation string.
+  String get indentation {
+    // Lazily add new indentation strings as required.
+    while (_indentList.length <= _indentLevel) {
+      _indentList.add(_indentList.last + "  ");
+    }
+    return _indentList[_indentLevel];
+  }
+
+  void indentMore() {
+    _indentLevel++;
+  }
+
+  void indentLess() {
+    _indentLevel--;
+  }
+
+
   /// Always emit a newline, even under `enableMinification`.
   void forceLine() {
     out("\n");
   }
   /// Emits a newline for readability.
   void lineOut() {
     if (!shouldCompressOutput) forceLine();
   }
   void spaceOut() {
     if (!shouldCompressOutput) out(" ");
   }
 
   String lastAddedString = null;
   int get lastCharCode {
     if (lastAddedString == null) return 0;
     assert(lastAddedString.length != "");
     return lastAddedString.codeUnitAt(lastAddedString.length - 1);
   }
 
   void out(String str) {
     if (str != "") {
       if (pendingSemicolon) {
         if (!shouldCompressOutput) {
-          outBuffer.add(";");
+          context.emit(";");
         } else if (str != "}") {
           // We want to output newline instead of semicolon because it makes
           // the raw stack traces much easier to read and it also makes line-
           // based tools like diff work much better.  JavaScript will
           // automatically insert the semicolon at the newline if it means a
           // parsing error is avoided, so we can only do this trick if the
           // next line is not something that can be glued onto a valid
           // expression to make a new valid expression.
 
           // If we're using the new emitter where most pretty printed code
           // is escaped in strings, it is a lot easier to deal with semicolons
           // than newlines because the former doesn't need escaping.
+          // TODO(sra): This formatting choice via JavaScriptPrintingOptions.
           if (USE_NEW_EMITTER || expressionContinuationRegExp.hasMatch(str)) {
-            outBuffer.add(";");
+            context.emit(";");
           } else {
-            outBuffer.add("\n");
+            context.emit("\n");
           }
         }
       }
       if (pendingSpace &&
           (!shouldCompressOutput || identifierCharacterRegExp.hasMatch(str))) {
-        outBuffer.add(" ");
+        context.emit(" ");
       }
       pendingSpace = false;
       pendingSemicolon = false;
-      outBuffer.add(str);
+      context.emit(str);
       lastAddedString = str;
     }
   }
 
   void outLn(String str) {
     out(str);
     lineOut();
   }
 
   void outSemicolonLn() {
     if (shouldCompressOutput) {
       pendingSemicolon = true;
     } else {
       out(";");
       forceLine();
     }
   }
 
   void outIndent(String str) { indent(); out(str); }
   void outIndentLn(String str) { indent(); outLn(str); }
   void indent() {
     if (!shouldCompressOutput) {
       out(indentation);
     }
   }
 
-  void beginSourceRange(Node node) {
-    if (node.sourceInformation != null) {
-      node.sourceInformation.beginMapping(outBuffer);
-    }
-  }
-
-  void endSourceRange(Node node) {
-    if (node.sourceInformation != null) {
-      node.sourceInformation.endMapping(outBuffer);
-    }
-  }
-
   visit(Node node) {
-    beginSourceRange(node);
-    if (monitor != null) monitor.enteringAst(node, outBuffer.length);
-
+    context.enterNode(node);
     node.accept(this);
-
-    if (monitor != null) monitor.exitingAst(node, outBuffer.length);
-    endSourceRange(node);
+    context.exitNode(node);
   }
 
   visitCommaSeparated(List<Node> nodes, int hasRequiredType,
                       {bool newInForInit, bool newAtStatementBegin}) {
     for (int i = 0; i < nodes.length; i++) {
       if (i != 0) {
         atStatementBegin = false;
         out(",");
         spaceOut();
       }
       visitNestedExpression(nodes[i], hasRequiredType,
                             newInForInit: newInForInit,
                             newAtStatementBegin: newAtStatementBegin);
     }
   }
 
   visitAll(List<Node> nodes) {
     nodes.forEach(visit);
   }
 
   visitProgram(Program program) {
     visitAll(program.body);
   }
 
+  // TODO(sra): Remove unused Blob node.
   visitBlob(Blob node) {
-    outBuffer.addBuffer(node.buffer);
+    context.error('js.Blob node deprecated');
   }
 
   bool blockBody(Node body, {bool needsSeparation, bool needsNewline}) {
     if (body is Block) {
       spaceOut();
       blockOut(body, false, needsNewline);
       return true;
     }
     if (shouldCompressOutput && needsSeparation) {
       // If [shouldCompressOutput] is false, then the 'lineOut' will insert
       // the separation.
       out(" ");
     } else {
       lineOut();
     }
-    indentBlock(() => visit(body));
+    indentMore();
+    visit(body);
+    indentLess();
     return false;
   }
 
   void blockOutWithoutBraces(Node node) {
     if (node is Block) {
-      beginSourceRange(node);
+      context.enterNode(node);
       Block block = node;
       block.statements.forEach(blockOutWithoutBraces);
-      endSourceRange(node);
+      context.exitNode(node);
     } else {
       visit(node);
     }
   }
 
   void blockOut(Block node, bool shouldIndent, bool needsNewline) {
     if (shouldIndent) indent();
-    beginSourceRange(node);
+    context.enterNode(node);
     out("{");
     lineOut();
-    indentBlock(() => node.statements.forEach(blockOutWithoutBraces));
+    indentMore();
+    node.statements.forEach(blockOutWithoutBraces);
+    indentLess();
     indent();
     out("}");
-    endSourceRange(node);
+    context.exitNode(node);
     if (needsNewline) lineOut();
   }
 
   visitBlock(Block block) {
     blockOut(block, true, true);
   }
 
   visitExpressionStatement(ExpressionStatement expressionStatement) {
     indent();
     visitNestedExpression(expressionStatement.expression, EXPRESSION,
@@ skipping 191 matching lines @@
 
   visitSwitch(Switch node) {
     outIndent("switch");
     spaceOut();
     out("(");
     visitNestedExpression(node.key, EXPRESSION,
                           newInForInit: false, newAtStatementBegin: false);
     out(")");
     spaceOut();
     outLn("{");
-    indentBlock(() => visitAll(node.cases));
+    indentMore();
+    visitAll(node.cases);
+    indentLess();
     outIndentLn("}");
   }
 
   visitCase(Case node) {
     outIndent("case");
     pendingSpace = true;
     visitNestedExpression(node.expression, EXPRESSION,
                           newInForInit: false, newAtStatementBegin: false);
     outLn(":");
     if (!node.body.statements.isEmpty) {
-      indentBlock(() => blockOutWithoutBraces(node.body));
+      indentMore();
+      blockOutWithoutBraces(node.body);
+      indentLess();
     }
   }
 
   visitDefault(Default node) {
     outIndentLn("default:");
     if (!node.body.statements.isEmpty) {
-      indentBlock(() => blockOutWithoutBraces(node.body));
+      indentMore();
+      blockOutWithoutBraces(node.body);
+      indentLess();
     }
   }
 
   visitLabeledStatement(LabeledStatement node) {
     outIndent("${node.label}:");
     blockBody(node.body, needsSeparation: false, needsNewline: true);
   }
 
   void functionOut(Fun fun, Node name, VarCollector vars) {
     out("function");
@@ skipping 196 matching lines @@
         rightPrecedenceRequirement = MULTIPLICATIVE;
         break;
       case "*":
       case "/":
       case "%":
         leftPrecedenceRequirement = MULTIPLICATIVE;
         // We cannot remove parenthesis for "*" because of precision issues.
         rightPrecedenceRequirement = UNARY;
         break;
       default:
-        diagnosticListener
-            .internalError(NO_LOCATION_SPANNABLE, "Forgot operator: $op");
+        context.error("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) {
-      diagnosticListener.internalError(NO_LOCATION_SPANNABLE,
-          'Wrong number of arguments for JS: $template');
+      context.error('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 106 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.DiagnosticListener diagnosticListener;
+  JavaScriptPrintingContext context;
 
-  DanglingElseVisitor(this.diagnosticListener);
+  DanglingElseVisitor(this.context);
 
   bool visitProgram(Program node) => false;
 
   bool visitNode(Statement node) {
-    diagnosticListener
-        .internalError(NO_LOCATION_SPANNABLE, "Forgot node: $node");
+    context.error("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 18 matching lines @@
   bool visitDefault(Default node) => false;
   bool visitFunctionDeclaration(FunctionDeclaration node) => false;
   bool visitLabeledStatement(LabeledStatement node)
       => node.body.accept(this);
   bool visitLiteralStatement(LiteralStatement node) => true;
 
   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);
   void enterScope(VarCollector vars);
   void leaveScope();
 }
 
 
 class IdentityNamer implements LocalNamer {
@@ skipping 118 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;
   }
 }