Revert "dart2js: Refactoring, documentation, and a few bugfixes in Namer class."

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 {
   MinifyNamer(Compiler compiler) : super(compiler) {
     reserveBackendNames();
     fieldRegistry = new _FieldNamingRegistry(this);
   }
 
   String get isolateName => 'I';
   String get isolatePropertiesName => 'p';
   bool get shouldMinify => true;
 
   final String getterPrefix = 'g';
   final String setterPrefix = 's';
   final String callPrefix = ''; // this will create function names $<n>
 
   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.
+  // 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.
   String getFreshName(String proposedName,
                       Set<String> usedNames,
                       Map<String, String> suggestedNames,
-                      {bool sanitizeForNatives, bool sanitizeForAnnotations}) {
-    String freshName;
-    String suggestion = suggestedNames[proposedName];
+                      {bool ensureSafe: true}) {
+    var freshName;
+    var suggestion = suggestedNames[proposedName];
     if (suggestion != null && !usedNames.contains(suggestion)) {
       freshName = suggestion;
     } else {
       freshName = _getUnusedName(proposedName, usedNames,
           suggestedNames.values);
     }
     usedNames.add(freshName);
     return freshName;
   }
 
-  String getClosureVariableName(String _, int id) {
+  String getClosureVariableName(String name, int id) {
     if (id < ALPHABET_CHARACTERS) {
       return new String.fromCharCodes([_letterNumber(id)]);
     }
-    // Fall back to a slightly longer name.
-    String basename = _disambiguateMember(null, 'closure');
-    return '${basename}_$id';
+    return "${getMappedInstanceName('closure')}_$id";
   }
 
   // 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>[
+  static const _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',
       'k2', 'k3', 'k4', 'r1', 'r2', 'rx', 'ry', 'x1', 'x2', 'y1', 'y2',
       // 3-letter:
       'add', 'all', 'alt', 'arc', 'CCW', 'cmp', 'dir', 'end', 'get', 'in1',
       'in2', 'INT', 'key', 'log', 'low', 'm11', 'm12', 'm13', 'm14', 'm21',
       'm22', 'm23', 'm24', 'm31', 'm32', 'm33', 'm34', 'm41', 'm42', 'm43',
       'm44', 'max', 'min', 'now', 'ONE', 'put', 'red', 'rel', 'rev', 'RGB',
       'sdp', 'set', 'src', 'tag', 'top', 'uid', 'uri', 'url', 'URL',
       // 4-letter:
       'abbr', 'atob', 'Attr', 'axes', 'axis', 'back', 'BACK', 'beta', 'bias',
       'Blob', 'blue', 'blur', 'BLUR', 'body', 'BOOL', 'BOTH', 'btoa', 'BYTE',
       'cite', 'clip', 'code', 'cols', 'cues', 'data', 'DECR', 'DONE', 'face',
       'file', 'File', 'fill', 'find', 'font', 'form', 'gain', 'hash', 'head',
       'high', 'hint', 'host', 'href', 'HRTF', 'IDLE', 'INCR', 'info', 'INIT',
       'isId', 'item', 'KEEP', 'kind', 'knee', 'lang', 'left', 'LESS', 'line',
       'link', 'list', 'load', 'loop', 'mode', 'name', 'Node', 'None', 'NONE',
       'only', 'open', 'OPEN', 'ping', 'play', 'port', 'rect', 'Rect', 'refX',
       'refY', 'RGBA', 'root', 'rows', 'save', 'seed', 'seek', 'self', 'send',
       'show', 'SINE', 'size', 'span', 'stat', 'step', 'stop', 'tags', 'text',
       'Text', 'time', 'type', 'view', 'warn', 'wrap', 'ZERO'];
 
   void reserveBackendNames() {
-    for (String name in _reservedNativeProperties) {
+    for (var name in _reservedNativeProperties) {
       if (name.length < 2) {
-        // Ensure the 1-letter names are disambiguated to the same name.
-        String disambiguatedName = name;
-        reservePublicMemberName(name, disambiguatedName);
+        instanceNameMap[name] = name;
       }
       usedInstanceNames.add(name);
       // Getter and setter names are autogenerated by prepending 'g' and 's' to
       // field names.  Therefore there are some field names we don't want to
       // use.  It is implicit in the next line that the banned prefix is
       // only one character.
       if (_hasBannedPrefix(name)) usedInstanceNames.add(name.substring(1));
     }
 
     // These popular names are present in most programs and deserve
@@ skipping 63 matching lines @@
                         Iterable<String> suggestions) {
     int hash = _calculateHash(proposedName);
     // Avoid very small hashes that won't try many names.
     hash = hash < 1000 ? hash * 314159 : hash;  // Yes, it's prime.
 
     // Try other n-character names based on the hash.  We try one to three
     // character identifiers.  For each length we try around 10 different names
     // in a predictable order determined by the proposed name.  This is in order
     // to make the renamer stable: small changes in the input should nornally
     // result in relatively small changes in the output.
-    for (int n = 1; n <= 3; n++) {
+    for (var n = 1; n <= 3; n++) {
       int h = hash;
       while (h > 10) {
-        List<int> codes = <int>[_letterNumber(h)];
+        var codes = <int>[_letterNumber(h)];
         int h2 = h ~/ ALPHABET_CHARACTERS;
-        for (int i = 1; i < n; i++) {
+        for (var i = 1; i < n; i++) {
           codes.add(_alphaNumericNumber(h2));
           h2 ~/= ALPHANUMERIC_CHARACTERS;
         }
         final candidate = new String.fromCharCodes(codes);
         if (!usedNames.contains(candidate) &&
             !jsReserved.contains(candidate) &&
             !_hasBannedPrefix(candidate) &&
             (n != 1 || !suggestions.contains(candidate))) {
           return candidate;
         }
@@ skipping 21 matching lines @@
       h &= 0xffffffff;
       h ^= h >> 6;
       h &= 0xffffffff;
     }
     return h;
   }
 
   /// If we can't find a hash based name in the three-letter space, then base
   /// the name on a letter and a counter.
   String _badName(int hash, Set<String> usedNames) {
-    String startLetter = new String.fromCharCodes([_letterNumber(hash)]);
-    String name;
-    int i = 0;
+    var startLetter = new String.fromCharCodes([_letterNumber(hash)]);
+    var name;
+    var i = 0;
     do {
       name = "$startLetter${i++}";
     } while (usedNames.contains(name));
     // We don't need to check for banned prefix because the name is in the form
     // xnnn, where nnn is a number.  There can be no getter or setter called
     // gnnn since that would imply a numeric field name.
     return name;
   }
 
   int _letterNumber(int x) {
@@ skipping 55 matching lines @@
     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]);
       } else {
         nameStore.add(namer.getFreshName("field$count",
-            namer.usedInstanceNames, namer.suggestedInstanceNames));
+            namer.usedInstanceNames, namer.suggestedInstanceNames,
+            ensureSafe: true));
       }
     }
 
     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
@@ skipping 109 matching lines @@
   Map<Entity, String> 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();
+    var proposed = super._nextName();
     return proposed + r'$';
   }
 }
 
 /**
  * [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) {
     if (!names.containsKey(field)) add(field);
     return names[field];
   }
 }