dart2js: Implement frequency based naming.

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 with _MinifiedFieldNamer {
+class MinifyNamer extends Namer with _MinifiedFieldNamer,
+    _MinifiedOneShotInterceptorNamer {
   MinifyNamer(Compiler compiler) : super(compiler) {
     reserveBackendNames();
     fieldRegistry = new _FieldNamingRegistry(this);
   }
 
   _FieldNamingRegistry fieldRegistry;
 
   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.
 
   /// 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.
   @override
-  jsAst.Name getFreshName(String proposedName,
-                          Set<String> usedNames,
-                          Map<String, String> suggestedNames,
-                          {bool sanitizeForNatives: false,
-                           bool sanitizeForAnnotations: false}) {
+  String _generateFreshStringForName(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 new StringBackedName(freshName);
+    return 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 125 matching lines @@
         // Try again with a slightly different hash.  After around 10 turns
         // around this loop h is zero and we try a longer name.
         h ~/= 7;
       }
     }
     return _badName(hash, usedNames);
   }
 
   /// Instance members starting with g and s are reserved for getters and
   /// setters.
-  bool _hasBannedPrefix(String name) {
+  static bool _hasBannedPrefix(String name) {
     int code = name.codeUnitAt(0);
     return code == $g || code == $s;
   }
 
   int _calculateHash(String name) {
     int h = 0;
     for (int i = 0; i < name.length; i++) {
       h += name.codeUnitAt(i);
       h &= 0xffffffff;
       h += h << 10;
@@ skipping 42 matching lines @@
   @override
   jsAst.Name instanceFieldPropertyName(Element element) {
     jsAst.Name proposed = _minifiedInstanceFieldPropertyName(element);
     if (proposed != null) {
       return proposed;
     }
     return super.instanceFieldPropertyName(element);
   }
 }
 
+abstract class _MinifiedOneShotInterceptorNamer implements Namer {
+  /// Property name used for the one-shot interceptor method for the given
+  /// [selector] and return-type specialization.
+  jsAst.Name nameForGetOneShotInterceptor(Selector selector,
+      Iterable<ClassElement> classes) {
+    String root = selector.isOperator ? operatorNameToIdentifier(selector.name)
+    : privateName(selector.memberName);
+    String prefix = selector.isGetter ? r"$get"
+    : selector.isSetter ? r"$set" : "";
+    String arity = selector.isCall ? "${selector.argumentCount}" : "";
+    String suffix = suffixForGetInterceptor(classes);
+    String fullName = "\$intercepted$prefix\$$root$arity\$$suffix";
+    return _disambiguateInternalGlobal(fullName);
+  }
+}