Fix JS minifier to lift var declarations within functions. Still disabled.

lib/compiler/implementation/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.
 
 class Printer implements NodeVisitor {
   final bool shouldCompressOutput;
   leg.Compiler compiler;
   leg.CodeBuffer outBuffer;
   int indentLevel = 0;
   bool inForInit = false;
@@ skipping 333 matching lines @@
       blockOutWithoutBraces(node.body);
       indentLevel--;
     }
   }
 
   visitLabeledStatement(LabeledStatement node) {
     outIndent("${node.label}:");
     blockBody(node.body, needsSeparation: false, needsNewline: true);
   }
 
-  void functionOut(Fun fun, Node name) {
+  void functionOut(Fun fun, Node name, VarCollector vars) {
     out("function");
     if (name != null) {
       out(" ");
       // Name must be a [Decl]. Therefore only test for primary expressions.
       visitNestedExpression(name, PRIMARY,
                             newInForInit: false, newAtStatementBegin: false);
     }
-    namer.enterScope();
+    namer.enterScope(vars);
     out("(");
     if (fun.params != null) {
       visitCommaSeparated(fun.params, PRIMARY,
                           newInForInit: false, newAtStatementBegin: false);
     }
     out(")");
     blockBody(fun.body, needsSeparation: false, needsNewline: false);
     namer.leaveScope();
   }
 
   visitFunctionDeclaration(FunctionDeclaration declaration) {
+    VarCollector vars = new VarCollector();
+    vars.visitFunctionDeclaration(declaration);
     indent();
-    functionOut(declaration.function, declaration.name);
+    functionOut(declaration.function, declaration.name, vars);
     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 220 matching lines @@
 
   visitVariableUse(VariableUse ref) {
     out(namer.getName(ref.name));
   }
 
   visitThis(This node) {
     out("this");
   }
 
   visitVariableDeclaration(VariableDeclaration decl) {
-    out(namer.declareName(decl.name));
+    out(namer.getName(decl.name));
   }
 
   visitParameter(Parameter param) {
-    out(namer.declareName(param.name));
+    out(namer.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++) {
@@ skipping 27 matching lines @@
         return;
       }
     }
     out("[");
     visitNestedExpression(selector, EXPRESSION,
                           newInForInit: false, newAtStatementBegin: false);
     out("]");
   }
 
   visitNamedFunction(NamedFunction namedFunction) {
-    functionOut(namedFunction.function, namedFunction.name);
+    VarCollector vars = new VarCollector();
+    vars.visitNamedFunction(namedFunction);
+    functionOut(namedFunction.function, namedFunction.name, vars);
   }
 
   visitFun(Fun fun) {
-    functionOut(fun, null);
+    VarCollector vars = new VarCollector();
+    vars.visitFun(fun);
+    functionOut(fun, null, vars);
   }
 
   visitLiteralBool(LiteralBool node) {
     out(node.value ? "true" : "false");
   }
 
   visitLiteralString(LiteralString node) {
     out(node.value);
   }
 
@@ skipping 88 matching lines @@
       visit(inputs[i]);
       out(parts[i + 1]);
     }
   }
 
   visitLiteralStatement(LiteralStatement node) {
     outLn(node.code);
   }
 }
 
+
+// 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 Set<String> vars;
+  final List<String> ordered_vars;
+
+  VarCollector() : nested = false, vars = new Set<String>(), ordered_vars = [];
+
+  void forEach(void fn(String)) => ordered_vars.forEach(fn);
+
+  void functionOut(Fun fun) {

[floitsch, 2012/10/15 11:17:18]

"out" doesn't seem to fit. Maybe "collectVarsInFunction"?

+    if (!nested) {
+      nested = true;
+      if (fun.params != null) {
+        for (int i = 0; i < fun.params.length; i++) {
+          add(fun.params[i].name);
+        }
+      }
+      visitBlock(fun.body);
+      nested = false;
+    }
+  }
+
+  void add(String name) {
+    if (!vars.contains(name)) {
+      vars.add(name);
+      ordered_vars.add(name);
+    }
+  }
+
+  void visitFunctionDeclaration(FunctionDeclaration declaration) {
+    functionOut(declaration.function);

[floitsch, 2012/10/15 11:17:18]

Add comment that we are skipping the function-declaration's name.

+  }
+
+  void visitNamedFunction(NamedFunction namedFunction) {

[floitsch, 2012/10/15 11:17:18]

Add comment that we are skipping the named-function's name.

+    functionOut(namedFunction.function);
+  }
+
+  void visitFun(Fun fun) {
+    functionOut(fun);
+  }
+
+  void visitVariableDeclaration(VariableDeclaration decl) {
+    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;
 
   DanglingElseVisitor(this.compiler);
 
   bool visitProgram(Program node) => false;
@@ skipping 41 matching lines @@
                            leg.Compiler compiler) {
   Printer printer = new Printer(compiler);
   printer.visit(node);
   return printer.outBuffer;
 }
 
 
 abstract class Namer {
   String getName(String oldName);
   String declareName(String oldName);
-  void enterScope();
+  void enterScope(VarCollector vars);
   void leaveScope();
 }
 
 
 class IdentityNamer implements Namer {
   String getName(String oldName) => oldName;
   String declareName(String oldName) => oldName;
-  void enterScope() {}
+  void enterScope(VarCollector vars) {}
   void leaveScope() {}
 }
 
 
 class MinifyRenamer implements Namer {
   final List<Map<String, String>> maps = [];
   final List<int> nameNumberStack = [];
   int nameNumber = 0;
 
   MinifyRenamer();
 
-  void enterScope() {
+  void enterScope(VarCollector vars) {
     maps.add(new Map<String, String>());
     nameNumberStack.add(nameNumber);
+    vars.forEach(declareName);
   }
 
   void leaveScope() {
     maps.removeLast();
     nameNumber = nameNumberStack.removeLast();
   }
 
   String getName(String oldName) {
     for (int i = maps.length - 1; i >= 0; i--) {
       var map = maps[i];
       var replacement = map[oldName];
       if (replacement != null) return replacement;
     }
     return oldName;
   }
 
   static int nthLetter(int n) {
     return (n < 26) ? charCodes.$a + n : charCodes.$A + n - 26;
   }
 
   String declareName(String oldName) {
     const LETTERS = 52;
     const DIGITS = 10;
     if (maps.isEmpty()) return oldName;
+
     String newName;
     int n = nameNumber;
     if (n < LETTERS) {
       // Start naming variables a, b, c, ..., z, A, B, C, ..., Z.
       newName = new String.fromCharCodes([nthLetter(n)]);
     } else {
       // Then name variables a0, a1, a2, ..., a9, b0, b1, ..., Z9, aa0, aa1, ...
       // For all functions with fewer than 500 locals this is just as compact
       // as using aa, ab, etc. but avoids clashes with keywords.
       n -= LETTERS;
@@ skipping 15 matching lines @@
       }
       codes.add(charCodes.$0 + digit);
       newName = new String.fromCharCodes(codes);
     }
     assert(const RegExp(r'[a-zA-Z][a-zA-Z0-9]*').hasMatch(newName));
     nameNumber++;
     maps.last()[oldName] = newName;
     return newName;
   }
 }