Minify methods, classes and fields.

sdk/lib/_internal/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 Namer namer;
+  final LocalNamer localNamer;
   bool pendingSemicolon = false;
   bool pendingSpace = false;
   static final identifierCharacterRegExp = new RegExp(r'^[a-zA-Z_0-9$]');
 
   Printer(leg.Compiler compiler, { allowVariableMinification: true })
       : shouldCompressOutput = compiler.enableMinification,
         this.compiler = compiler,
         outBuffer = new leg.CodeBuffer(),
         danglingElseVisitor = new DanglingElseVisitor(compiler),
-        namer = determineRenamer(compiler.enableMinification,
-                                 allowVariableMinification);
+        localNamer = determineRenamer(compiler.enableMinification,
+                                      allowVariableMinification);
 
-  static Namer determineRenamer(bool shouldCompressOutput,
-                                bool allowVariableMinification) {
+  static LocalNamer determineRenamer(bool shouldCompressOutput,
+                                     bool allowVariableMinification) {
     return (shouldCompressOutput && allowVariableMinification)
         ? new MinifyRenamer() : new IdentityNamer();
   }
 
   void spaceOut() {
     if (!shouldCompressOutput) out(" ");
   }
   void lineOut() {
     if (!shouldCompressOutput) out("\n");
   }
@@ skipping 344 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);
     }
-    namer.enterScope(vars);
+    localNamer.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();
+    localNamer.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(namer.getName(ref.name));
+    out(localNamer.getName(ref.name));
   }
 
   visitThis(This node) {
     out("this");
   }
 
   visitVariableDeclaration(VariableDeclaration decl) {
-    out(namer.getName(decl.name));
+    out(localNamer.getName(decl.name));
   }
 
   visitParameter(Parameter param) {
-    out(namer.getName(param.name));
+    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++) {
@@ skipping 272 matching lines @@
 leg.CodeBuffer prettyPrint(Node node, leg.Compiler compiler,
                            { allowVariableMinification: true }) {
   Printer printer =
       new Printer(compiler,
                   allowVariableMinification: allowVariableMinification);
   printer.visit(node);
   return printer.outBuffer;
 }
 
 
-abstract class Namer {
+abstract class LocalNamer {
   String getName(String oldName);
   String declareVariable(String oldName);
   String declareParameter(String oldName);
   void enterScope(VarCollector vars);
   void leaveScope();
 }
 
 
-class IdentityNamer implements Namer {
+class IdentityNamer implements LocalNamer {
   String getName(String oldName) => oldName;
   String declareVariable(String oldName) => oldName;
   String declareParameter(String oldName) => oldName;
   void enterScope(VarCollector vars) {}
   void leaveScope() {}
 }
 
 
-class MinifyRenamer implements Namer {
+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) {
     maps.add(new Map<String, String>());
@@ skipping 89 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;
   }
 }