dart2js: Use an abstract Name class for names in the generated JavaScript ast.

pkg/compiler/lib/src/js_backend/minify_namer.dart

 // Copyright (c) 2011, 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_backend;
 
 /**
  * Assigns JavaScript identifiers to Dart variables, class-names and members.
  */
 class MinifyNamer extends Namer {
@@ skipping 13 matching lines @@
   final ALPHABET_CHARACTERS = 52;  // a-zA-Z.
   final ALPHANUMERIC_CHARACTERS = 62;  // a-zA-Z0-9.
 
   _FieldNamingRegistry fieldRegistry;
 
   /// You can pass an invalid identifier to this and unlike its non-minifying
   /// counterpart it will never return the proposedName as the new fresh name.
   ///
   /// [sanitizeForNatives] and [sanitizeForAnnotations] are ignored because the
   /// minified names will always avoid clashing with annotated names or natives.
-  String getFreshName(String proposedName,
-                      Set<String> usedNames,
-                      Map<String, String> suggestedNames,
-                      {bool sanitizeForNatives: false,
-                       bool sanitizeForAnnotations: false}) {
+  jsAst.Name getFreshName(String proposedName,
+                             Set<String> usedNames,
+                             Map<String, String> suggestedNames,
+                             {bool sanitizeForNatives: false,
+                              bool sanitizeForAnnotations: false}) {
     String freshName;
     String suggestion = suggestedNames[proposedName];
     if (suggestion != null && !usedNames.contains(suggestion)) {
       freshName = suggestion;
     } else {
       freshName = _getUnusedName(proposedName, usedNames,
           suggestedNames.values);
     }
     usedNames.add(freshName);
-    return freshName;
+    return new StringBackedName(freshName);
   }
 
   // From issue 7554.  These should not be used on objects (as instance
   // variables) because they clash with names from the DOM. However, it is
   // OK to use them as fields, as we only access fields directly if we know
   // the receiver type.
   static const List<String> _reservedNativeProperties = const <String>[
       'Q', 'a', 'b', 'c', 'd', 'e', 'f', 'r', 'x', 'y', 'z',
       // 2-letter:
       'ch', 'cx', 'cy', 'db', 'dx', 'dy', 'fr', 'fx', 'fy', 'go', 'id', 'k1',
@@ skipping 77 matching lines @@
   void _populateSuggestedNames(Map<String, String> suggestionMap,
                                Set<String> used,
                                List<String> suggestions) {
     int c = $a - 1;
     String letter;
     for (String name in suggestions) {
       do {
         assert(c != $Z);
         c = (c == $z) ? $A : c + 1;
         letter = new String.fromCharCodes([c]);
-      } while (used.contains(letter));
+      } while (_hasBannedPrefix(letter) || used.contains(letter));
       assert(suggestionMap[name] == null);
       suggestionMap[name] = letter;
     }
   }
 
 
   // This gets a minified name based on a hash of the proposed name.  This
   // is slightly less efficient than just getting the next name in a series,
   // but it means that small changes in the input program will give smallish
   // changes in the output, which can be useful for diffing etc.
@@ skipping 80 matching lines @@
     return $A + x - 26;
   }
 
   int _alphaNumericNumber(int x) {
     if (x >= ALPHANUMERIC_CHARACTERS) x %= ALPHANUMERIC_CHARACTERS;
     if (x < 26) return $a + x;
     if (x < 52) return $A + x - 26;
     return $0 + x - 52;
   }
 
-  String instanceFieldPropertyName(Element element) {
+  jsAst.Name instanceFieldPropertyName(Element element) {
     if (element.hasFixedBackendName) {
-      return element.fixedBackendName;
+      return new StringBackedName(element.fixedBackendName);
     }
 
     _FieldNamingScope names;
     if (element is BoxFieldElement) {
       names = new _FieldNamingScope.forBox(element.box, fieldRegistry);
     } else {
       ClassElement cls = element is ClosureFieldElement
           ? element.closureClass : element.enclosingClass;
       names = new _FieldNamingScope.forClass(cls, compiler.world,
           fieldRegistry);
@@ skipping 11 matching lines @@
 
 /**
  * Encapsulates the global state of field naming.
  */
 class _FieldNamingRegistry {
   final MinifyNamer namer;
 
   final Map<Entity, _FieldNamingScope> scopes =
       new Map<Entity, _FieldNamingScope>();
 
-  final Map<Entity, String> globalNames = new Map<Entity, String>();
+  final Map<Entity, jsAst.Name> globalNames = new Map<Entity, jsAst.Name>();
 
   int globalCount = 0;
 
-  final List<String> nameStore = new List<String>();
+  final List<jsAst.Name> nameStore = new List<jsAst.Name>();
 
   _FieldNamingRegistry(this.namer);
 
-  String getName(int count) {
+  jsAst.Name getName(int count) {
     if (count >= nameStore.length) {
       // The namer usually does not use certain names as they clash with
       // existing properties on JS objects (see [_reservedNativeProperties]).
       // However, some of them are really short and safe to use for fields.
       // Thus, we shortcut the namer to use those first.
       if (count < MinifyNamer._reservedNativeProperties.length &&
           MinifyNamer._reservedNativeProperties[count].length <= 2) {
-        nameStore.add(MinifyNamer._reservedNativeProperties[count]);
+        nameStore.add(new StringBackedName(
+            MinifyNamer._reservedNativeProperties[count]));
       } else {
         nameStore.add(namer.getFreshName("field$count",
             namer.usedInstanceNames, namer.suggestedInstanceNames));
       }
     }
 
     return nameStore[count];
   }
 }
 
 /**
  * A [_FieldNamingScope] encodes a node in the inheritance tree of the current
  * class hierarchy. The root node typically is the node corresponding to the
  * `Object` class. It is used to assign a unique name to each field of a class.
  * Unique here means unique wrt. all fields along the path back to the root.
- * This is achieved at construction time via the [_fieldNameCounter] field that counts the
- * number of fields on the path to the root node that have been encountered so
- * far.
+ * This is achieved at construction time via the [_fieldNameCounter] field that
+ * counts the number of fields on the path to the root node that have been
+ * encountered so far.
  *
  * Obviously, this only works if no fields are added to a parent node after its
  * children have added their first field.
  */
 class _FieldNamingScope {
   final _FieldNamingScope superScope;
   final Entity container;
-  final Map<Element, String> names = new Maplet<Element, String>();
+  final Map<Element, jsAst.Name> names = new Maplet<Element, jsAst.Name>();
   final _FieldNamingRegistry registry;
 
   /// Naming counter used for fields of ordinary classes.
   int _fieldNameCounter;
 
   /// The number of fields along the superclass chain that use inheritance
   /// based naming, including the ones allocated for this scope.
   int get inheritanceBasedFieldNameCounter => _fieldNameCounter;
 
   /// The number of locally used fields. Depending on the naming source
@@ skipping 39 matching lines @@
     : superScope = null,
       _fieldNameCounter = 0;
 
   _FieldNamingScope.inherit(this.container, this.superScope, this.registry) {
     _fieldNameCounter = superScope.inheritanceBasedFieldNameCounter;
   }
 
   /**
    * Checks whether [name] is already used in the current scope chain.
    */
-  _isNameUnused(String name) {
+  _isNameUnused(jsAst.Name name) {
     return !names.values.contains(name) &&
         ((superScope == null) || superScope._isNameUnused(name));
   }
 
-  String _nextName() => registry.getName(_localFieldNameCounter++);
+  jsAst.Name _nextName() => registry.getName(_localFieldNameCounter++);
 
-  String operator[](Element field) {
-    String name = names[field];
+  jsAst.Name operator[](Element field) {
+    jsAst.Name name = names[field];
     if (name == null && superScope != null) return superScope[field];
     return name;
   }
 
   void add(Element field) {
     if (names.containsKey(field)) return;
 
-    String value = _nextName();
+    jsAst.Name value = _nextName();
     assert(invariant(field, _isNameUnused(value)));
     names[field] = value;
   }
 
   bool containsField(Element field) => names.containsKey(field);
 }
 
 /**
  * Field names for mixins have two constraints: They need to be unique in the
  * hierarchy of each application of a mixin and they need to be the same for
  * all applications of a mixin. To achieve this, we use global naming for
  * mixins from the same name pool as fields and add a `$` at the end to ensure
  * they do not collide with normal field names. The `$` sign is typically used
  * as a separator between method names and argument counts and does not appear
  * in generated names themselves.
  */
 class _MixinFieldNamingScope extends _FieldNamingScope {
   int get _localFieldNameCounter => registry.globalCount;
   void set _localFieldNameCounter(int val) { registry.globalCount = val; }
 
-  Map<Entity, String> get names => registry.globalNames;
+  Map<Entity, jsAst.Name> get names => registry.globalNames;
 
   _MixinFieldNamingScope.mixin(ClassElement cls, _FieldNamingRegistry registry)
     : super.rootScope(cls, registry);
 
   _MixinFieldNamingScope.mixedIn(MixinApplicationElement container,
       _FieldNamingScope superScope, _FieldNamingRegistry registry)
     : super.inherit(container, superScope, registry);
 
-  String _nextName() {
-    String proposed = super._nextName();
-    return proposed + r'$';
+  jsAst.Name _nextName() {
+    jsAst.Name proposed = super._nextName();
+    return new CompoundName([proposed, Namer._literalDollar]);
   }
 }
 
 /**
  * [BoxFieldElement] fields work differently in that they do not belong to an
  * actual class but an anonymous box associated to a [Local]. As there is no
  * inheritance chain, we do not need to compute fields a priori but can assign
  * names on the fly.
  */
 class _BoxFieldNamingScope extends _FieldNamingScope {
   _BoxFieldNamingScope(Local box, _FieldNamingRegistry registry) :
     super.rootScope(box, registry);
 
   bool containsField(_) => true;
 
-  String operator[](Element field) {
+  jsAst.Name operator[](Element field) {
     if (!names.containsKey(field)) add(field);
     return names[field];
   }
 }