Revert "Minifying renamer for classes, methods and instance variables."

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.
 
 part of js;
 
 class Printer implements NodeVisitor {
   final bool shouldCompressOutput;
   leg.Compiler compiler;
   leg.CodeBuffer outBuffer;
   int indentLevel = 0;
   bool inForInit = false;
   bool atStatementBegin = false;
   final DanglingElseVisitor danglingElseVisitor;
-  final LocalNamer localNamer;
+  final Namer namer;
 
   Printer(leg.Compiler compiler)
       : shouldCompressOutput = compiler.enableMinification,
         this.compiler = compiler,
         outBuffer = new leg.CodeBuffer(),
         danglingElseVisitor = new DanglingElseVisitor(compiler),
-        localNamer = determineRenamer(compiler.enableMinification);
-  
-  static LocalNamer determineRenamer(bool shouldCompressOutput) {
+        namer = determineRenamer(compiler.enableMinification);
+
+  static Namer determineRenamer(bool shouldCompressOutput) {
     // TODO(erikcorry): Re-enable the MinifyRenamer after M1.
     return new IdentityNamer();
   }
 
   void spaceOut() {
     if (!shouldCompressOutput) out(" ");
   }
   void lineOut() {
     if (!shouldCompressOutput) out("\n");
   }
@@ skipping 320 matching lines @@
   }
 
   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);
     }
-    localNamer.enterScope(vars);
+    namer.enterScope(vars);
     out("(");
     if (fun.params != null) {
       visitCommaSeparated(fun.params, PRIMARY,
                           newInForInit: false, newAtStatementBegin: false);
     }
     out(")");
     blockBody(fun.body, needsSeparation: false, needsNewline: false);
-    localNamer.leaveScope();
+    namer.leaveScope();
   }
 
   visitFunctionDeclaration(FunctionDeclaration declaration) {
     VarCollector vars = new VarCollector();
     vars.visitFunctionDeclaration(declaration);
     indent();
     functionOut(declaration.function, declaration.name, vars);
     lineOut();
   }
 
@@ skipping 219 matching lines @@
   }
 
   visitPostfix(Postfix postfix) {
     visitNestedExpression(postfix.argument, LEFT_HAND_SIDE,
                           newInForInit: inForInit,
                           newAtStatementBegin: atStatementBegin);
     out(postfix.op);
   }
 
   visitVariableUse(VariableUse ref) {
-    out(localNamer.getName(ref.name));
+    out(namer.getName(ref.name));
   }
 
   visitThis(This node) {
     out("this");
   }
 
   visitVariableDeclaration(VariableDeclaration decl) {
-    out(localNamer.getName(decl.name));
+    out(namer.getName(decl.name));
   }
 
   visitParameter(Parameter param) {
-    out(localNamer.getName(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 254 matching lines @@
 
 
 leg.CodeBuffer prettyPrint(Node node,
                            leg.Compiler compiler) {
   Printer printer = new Printer(compiler);
   printer.visit(node);
   return printer.outBuffer;
 }
 
 
-abstract class LocalNamer {
+abstract class Namer {
   String getName(String oldName);
   String declareName(String oldName);
   void enterScope(VarCollector vars);
   void leaveScope();
 }
 
 
-class IdentityNamer implements LocalNamer {
+class IdentityNamer implements Namer {
   String getName(String oldName) => oldName;
   String declareName(String oldName) => oldName;
   void enterScope(VarCollector vars) {}
   void leaveScope() {}
 }
 
 
-class MinifyRenamer implements LocalNamer {
+class MinifyRenamer implements Namer {
   final List<Map<String, String>> maps = [];
   final List<int> nameNumberStack = [];
   int nameNumber = 0;
 
   MinifyRenamer();
 
   void enterScope(VarCollector vars) {
     maps.add(new Map<String, String>());
     nameNumberStack.add(nameNumber);
     vars.forEach(declareName);
@@ skipping 16 matching lines @@
   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;
-    do {
-      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, ..., 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;
-        int digit = n % DIGITS;
-        n ~/= DIGITS;
-        int alphaChars = 1;
-        int nameSpaceSize = LETTERS;
-        // Find out whether we should use the 1-character namespace (size 52),
-        // the 2-character namespace (size 52*52), etc.
-        while (n >= nameSpaceSize) {
-          n -= nameSpaceSize;
-          alphaChars++;
-          nameSpaceSize *= LETTERS;
-        }
-        var codes = <int>[];
-        for (var i = 0; i < alphaChars; i++) {
-          nameSpaceSize ~/= LETTERS;
-          codes.add(nthLetter((n ~/ nameSpaceSize) % LETTERS));
-        }
-        codes.add(charCodes.$0 + digit);
-        newName = new String.fromCharCodes(codes);
+    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;
+      int digit = n % DIGITS;
+      n ~/= DIGITS;
+      int alphaChars = 1;
+      int nameSpaceSize = LETTERS;
+      // Find out whether we should use the 1-character namespace (size 52), the
+      // 2-character namespace (size 52*52), etc.
+      while (n >= nameSpaceSize) {
+        n -= nameSpaceSize;
+        alphaChars++;
+        nameSpaceSize *= LETTERS;
       }
-      assert(const RegExp(r'[a-zA-Z][a-zA-Z0-9]*').hasMatch(newName));
-      nameNumber++;
-    } while (isReserved(newName));
-    maps.last()[oldName] = newName;
+      var codes = <int>[];
+      for (var i = 0; i < alphaChars; i++) {
+        nameSpaceSize ~/= LETTERS;
+        codes.add(nthLetter((n ~/ nameSpaceSize) % LETTERS));
+      }
+      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;
   }
-
-  // We only have names here that are single-letter or end with a digit,
-  // since those are the ones we can generate.
-  bool isReserved(String name) {
-    assert(name.length == 1 || const RegExp(r'[0-9]$').hasMatch(name));
-    // No names reserved yet.  All JS keywords are more than one character and
-    // do not end with a digit.
-    return false;
-  }
 }