[js_ast] adds Identifier that merges VariableDeclaration/Use and Parameter

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;
@@ skipping 487 matching lines @@
       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) {
+  void functionOut(Fun fun, Node name, Node scope) {
     out("function");
     if (name != null) {
       out(" ");
       // Name must be a [Decl]. Therefore only test for primary expressions.
       visitNestedExpression(name, PRIMARY,
                             newInForInit: false, newAtStatementBegin: false);
     }
-    localNamer.enterScope(vars);
+    localNamer.enterScope(scope);
     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);
+    functionOut(declaration.function, declaration.name, declaration);
     lineOut();
   }
 
   visitNestedExpression(Expression node, int requiredPrecedence,
                         {bool newInForInit, bool newAtStatementBegin}) {
     bool needsParentheses =
         // a - (b + c).
         (requiredPrecedence != EXPRESSION &&
          node.precedenceLevel < requiredPrecedence) ||
         // for (a = (x in o); ... ; ... ) { ... }
@@ skipping 210 matching lines @@
                           newInForInit: inForInit, newAtStatementBegin: false);
   }
 
   visitPostfix(Postfix postfix) {
     visitNestedExpression(postfix.argument, LEFT_HAND_SIDE,
                           newInForInit: inForInit,
                           newAtStatementBegin: atStatementBegin);
     out(postfix.op);
   }
 
-  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) {
+  visitIdentifier(Identifier 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.
@@ skipping 20 matching lines @@
   }
 
   visitAccess(PropertyAccess access) {
     visitNestedExpression(access.receiver, CALL,
                           newInForInit: inForInit,
                           newAtStatementBegin: atStatementBegin);
     propertyNameOut(access.selector, inAccess: true);
   }
 
   visitNamedFunction(NamedFunction namedFunction) {
-    VarCollector vars = new VarCollector();
-    vars.visitNamedFunction(namedFunction);
-    functionOut(namedFunction.function, namedFunction.name, vars);
+    functionOut(namedFunction.function, namedFunction.name, namedFunction);
   }
 
   visitFun(Fun fun) {
-    VarCollector vars = new VarCollector();
-    vars.visitFun(fun);
-    functionOut(fun, null, vars);
+    functionOut(fun, null, fun);
   }
 
   visitArrowFun(ArrowFun fun) {
-    VarCollector vars = new VarCollector();
-    vars.visitArrowFun(fun);
-    localNamer.enterScope(vars);
+    localNamer.enterScope(fun);
     out("(");
     if (fun.params != null) {
       visitCommaSeparated(fun.params, PRIMARY,
           newInForInit: false, newAtStatementBegin: false);
     }
     out(")");
     spaceOut();
     out("=>");
     if (fun.body is Expression) {
       spaceOut();
@@ skipping 139 matching lines @@
 
   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);
+    localNamer.enterScope(node);
     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();
@@ skipping 67 matching lines @@
 
   visitInterpolatedParameter(InterpolatedParameter node) =>
       visitInterpolatedNode(node);
 
   visitInterpolatedSelector(InterpolatedSelector node) =>
       visitInterpolatedNode(node);
 
   visitInterpolatedMethod(InterpolatedMethod node) =>
       visitInterpolatedNode(node);
 
-  visitInterpolatedVariableDeclaration(InterpolatedVariableDeclaration node) =>
+  visitInterpolatedIdentifier(InterpolatedIdentifier 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;
@@ skipping 17 matching lines @@
     }
     visit(node.expression);
   }
 
   void visitAwait(Await node) {
     out("await ");
     visit(node.expression);
   }
 }
 
-
-class OrderedSet<T> {

[Jennifer Messerly, 2015/03/25 21:29:16]

presumably this predates LinkedHashSet

-  final Set<T> set;
-  final List<T> list;
-
-  OrderedSet() : set = new Set<T>(), list = <T>[];
-
-  void add(T x) {
-    if (!set.contains(x)) {
-      set.add(x);
-      list.add(x);
-    }
-  }
-
-  void forEach(void fun(T x)) {
-    list.forEach(fun);
-  }
-}
-
 // Collects all the var declarations in the function.  We need to do this in a
 // separate pass because JS vars are lifted to the top of the function.
 class VarCollector extends BaseVisitor {
   bool nested;
-  final OrderedSet<String> vars;
-  final OrderedSet<String> params;
+  final Set<String> vars;
+  final Set<String> params;
 
   VarCollector() : nested = false,
-                   vars = new OrderedSet<String>(),
-                   params = new OrderedSet<String>();
+                   vars = new Set<String>(),
+                   params = new Set<String>();
 
   void forEachVar(void fn(String v)) => vars.forEach(fn);
   void forEachParam(void fn(String p)) => params.forEach(fn);
 
   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);
+        for (var param in fun.params) {
+          params.add(param.name);
         }
       }
       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.
+    // Method names are qualified by the instance, so we don't collect them.
     collectVarsInFunction(declaration.function);
   }
 
   void visitFun(Fun fun) {
     collectVarsInFunction(fun);
   }
 
   void visitArrowFun(ArrowFun fun) {
     collectVarsInFunction(fun);
   }
 
-  void visitThis(This node) {}
+  void visitClassExpression(ClassExpression node) {
+    // Note that we don't bother collecting the name of the class.
+    if (node.heritage != null) node.heritage.accept(this);
+    for (Method method in node.methods) method.accept(this);
+  }
 
-  void visitVariableDeclaration(VariableDeclaration decl) {
+  void visitCatch(Catch node) {
+    declareVariable(node.declaration);
+    node.body.accept(this);
+  }
+
+  void visitVariableInitialization(VariableInitialization node) {
+    declareVariable(node.declaration);
+    if (node.value != null) node.value.accept(this);
+  }
+
+  void declareVariable(Identifier decl) {
     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> {
@@ skipping 40 matching lines @@
       => 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);
+  void enterScope(Node node);
   void leaveScope();
 }
 
 
 class IdentityNamer implements LocalNamer {
   String getName(String oldName) => oldName;
-  String declareVariable(String oldName) => oldName;
-  String declareParameter(String oldName) => oldName;
-  void enterScope(VarCollector vars) {}
+  void enterScope(Node node) {}
   void leaveScope() {}
 }
 
 
 class MinifyRenamer implements LocalNamer {
   final List<Map<String, String>> maps = [];
   final List<int> parameterNumberStack = [];
   final List<int> variableNumberStack = [];
   int parameterNumber = 0;
   int variableNumber = 0;
 
-  MinifyRenamer();
-
-  void enterScope(VarCollector vars) {
+  void enterScope(Node node) {
+    var vars = new VarCollector();
+    node.accept(vars);
     maps.add(new Map<String, String>());
     variableNumberStack.add(variableNumber);
     parameterNumberStack.add(parameterNumber);
     vars.forEachVar(declareVariable);
     vars.forEachParam(declareParameter);
   }
 
   void leaveScope() {
     maps.removeLast();
     variableNumber = variableNumberStack.removeLast();
@@ skipping 90 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;
   }
 }