more care around generated names, fixes #60 #82 and #97

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;
   final bool preferSemicolonToNewlineInMinifiedOutput;
-  final bool avoidKeywordsInIdentifiers;
+
+
+  /// True to allow keywords in properties, such as `obj.var` or `obj.function`
+  /// Modern JS engines support this.
+  final bool allowKeywordsInProperties;
 
   JavaScriptPrintingOptions(
       {this.shouldCompressOutput: false,
        this.minifyLocalVariables: false,
        this.preferSemicolonToNewlineInMinifiedOutput: false,
-       this.avoidKeywordsInIdentifiers: false});
+       this.allowKeywordsInProperties: false});
 }
 
 
 /// An environment in which JavaScript printing is done.  Provides emitting of
 /// text and pre- and post-visit callbacks.
 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.
@@ skipping 32 matching lines @@
 
   // 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(JavaScriptPrintingOptions options,
-          JavaScriptPrintingContext context)
+          JavaScriptPrintingContext context,
+          {LocalNamer localNamer})
       : options = options,
         context = context,
         shouldCompressOutput = options.shouldCompressOutput,
         danglingElseVisitor = new DanglingElseVisitor(context),
-        localNamer = determineRenamer(options.shouldCompressOutput,
-                                      options.minifyLocalVariables);
+        localNamer = determineRenamer(localNamer, options);
 
-  static LocalNamer determineRenamer(bool shouldCompressOutput,
-                                     bool allowVariableMinification) {
-    return (shouldCompressOutput && allowVariableMinification)
+  static LocalNamer determineRenamer(LocalNamer localNamer,
+                                     JavaScriptPrintingOptions options) {
+    if (localNamer != null) return localNamer;
+    return (options.shouldCompressOutput && options.minifyLocalVariables)
         ? 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 + "  ");
     }
@@ skipping 679 matching lines @@
   }
 
   visitThis(This node) {
     out("this");
   }
 
   visitSuper(Super node) {
     out("super");
   }
 
-  visitIdentifier(Identifier param) {
-    out(localNamer.getName(param.name));
+  visitIdentifier(Identifier node) {
+    out(localNamer.getName(node));
   }
 
   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++) {
       // TODO(floitsch): allow more characters.
       int charCode = field.codeUnitAt(i);
       if (!(charCodes.$a <= charCode && charCode <= charCodes.$z ||
             charCodes.$A <= charCode && charCode <= charCodes.$Z ||
             charCode == charCodes.$$ ||
             charCode == charCodes.$_ ||
             i != 1 && isDigit(charCode))) {
         return false;
       }
     }
 
-    if (options.avoidKeywordsInIdentifiers) {
-      return !isJsKeyword(field.substring(1, field.length - 1));
-    } else {
-      // TODO(floitsch): normally we should also check that the field is not a
-      // reserved word.  We don't generate fields with reserved word names except
-      // for 'super'.
-      return field != '"super"';
-    }
+    // TODO(floitsch): normally we should also check that the field is not a
+    // reserved word.  We don't generate fields with reserved word names except
+    // for 'super'.
+    return options.allowKeywordsInProperties || field != '"super"';
   }
 
   visitAccess(PropertyAccess access) {
     visitNestedExpression(access.receiver, CALL,
                           newInForInit: inForInit,
                           newAtStatementBegin: atStatementBegin);
     propertyNameOut(access.selector, inAccess: true);
   }
 
   visitNamedFunction(NamedFunction namedFunction) {
@@ skipping 412 matching lines @@
   bool visitLabeledStatement(LabeledStatement node)
       => 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 getName(Identifier node);
   void enterScope(Node node);
   void leaveScope();
 }
 
 
 class IdentityNamer implements LocalNamer {
-  String getName(String oldName) => oldName;
+  String getName(Identifier node) => node.name;
   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;
 
   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();
     parameterNumber = parameterNumberStack.removeLast();
   }
 
-  String getName(String oldName) {
+  String getName(Identifier node) {
+    String oldName = node.name;
     // Go from inner scope to outer looking for mapping of name.
     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 const LOWER_CASE_LETTERS = 26;
@@ skipping 76 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;
   }
 }