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

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

Index: pkg/compiler/lib/src/js_backend/namer.dart
diff --git a/pkg/compiler/lib/src/js_backend/namer.dart b/pkg/compiler/lib/src/js_backend/namer.dart
index 9c10db5e226cbe66c5d1edbbfc2870070c4f1b84..ac3965889516ed15b83070d2484dfeb40a729e9e 100644
--- a/pkg/compiler/lib/src/js_backend/namer.dart
+++ b/pkg/compiler/lib/src/js_backend/namer.dart
@@ -6,104 +6,10 @@ part of js_backend;
 
 /**
  * Assigns JavaScript identifiers to Dart variables, class-names and members.
- *
- * Names are generated through three stages:
- *
- * 1. Original names and proposed names
- * 2. Disambiguated names (also known as "mangled names")
- * 3. Annotated names
- *
- * Original names are names taken directly from the input.
- *
- * Proposed names are either original names or synthesized names for input
- * elements that do not have original names.
- *
- * Disambiguated names are derived from the above, but are mangled to ensure
- * uniqueness within some namespace (e.g. as fields on the same JS object).
- * In [MinifyNamer], disambiguated names are also minified.
- *
- * Annotated names are names generated from a disambiguated name. Annnotated
- * names must be computable at runtime by prefixing/suffixing constant strings
- * onto the disambiguated name.
- *
- * For example, some entity called `x` might be associated with these names:
- *
- *     Original name: `x`
- *
- *     Disambiguated name: `x1` (if something else was called `x`)
- *
- *     Annotated names: `x1`     (field name)
- *                      `get$x1` (getter name)
- *                      `set$x1` (setter name)
- *
- * The [Namer] can choose the disambiguated names, and to some degree the
- * prefix/suffix constants used to construct annotated names. It cannot choose
- * annotated names with total freedom, for example, it cannot choose that the
- * getter for `x1` should be called `getX` -- the annotated names are always
- * built by concatenation.
- *
- * Disambiguated names must be chosen such that none of the annotated names can
- * clash with each other. This may happen even if the disambiguated names are
- * distinct, for example, suppose a field `x` and `get$x` exists in the input:
- *
- *     Original names: `x` and `get$x`
- *
- *     Disambiguated names: `x` and `get$x` (the two names a different)
- *
- *     Annotated names: `x` (field for `x`)
- *                      `get$x` (getter for `x`)
- *                      `get$x` (field for `get$x`)
- *                      `get$get$x` (getter for `get$x`)
- *
- * The getter for `x` clashes with the field name for `get$x`, so the
- * disambiguated names are invalid.
- *
- * Additionally, disambiguated names must be chosen such that all annotated
- * names are valid JavaScript identifiers and do not coincide with a native
- * JavaScript property such as `__proto__`.
- *
- * The following annotated names are generated for instance members, where
- * <NAME> denotes the disambiguated name.
- *
- * 0. The disambiguated name can itself be seen as an annotated name.
- *
- * 1. Multiple annotated names exist for the `call` method, encoding arity and
- *    named parameters with the pattern:
- *
- *       call$<N>$namedParam1...$namedParam<M>
- *
- *    where <N> is the number of parameters (required and optional) and <M> is
- *    the number of named parameters, and namedParam<n> are the names of the
- *    named parameters in alphabetical order.
- *
- *    Note that the same convention is used for the *proposed name* of other
- *    methods. Thus, for ordinary methods, the suffix becomes embedded in the
- *    disambiguated name (and can be minified), whereas for the 'call' method,
- *    the suffix is an annotation that must be computable at runtime
- *    (and thus cannot be minified).
- *
- *    Note that the ordering of named parameters is not encapsulated in the
- *    [Namer], and is hardcoded into other components, such as [Element] and
- *    [Selector].
- *
- * 2. The getter/setter for a field:
- *
- *        get$<NAME>
- *        set$<NAME>
- *
- *    (The [getterPrefix] and [setterPrefix] are different in [MinifyNamer]).
- *
- * 3. The `is` and operator uses the following names:
- *
- *        $is<NAME>
- *        $as<NAME>
- *
- * For local variables, the [Namer] only provides *proposed names*. These names
- * must be disambiguated elsewhere.
  */
 class Namer implements ClosureNamer {
 
-  static const List<String> javaScriptKeywords = const <String>[
+  static const javaScriptKeywords = const <String>[
     // These are current keywords.
     "break", "delete", "function", "return", "typeof", "case", "do", "if",
     "switch", "var", "catch", "else", "in", "this", "void", "continue",
@@ -118,11 +24,11 @@ class Namer implements ClosureNamer {
     "long", "short", "volatile"
   ];
 
-  static const List<String> reservedPropertySymbols =
+  static const reservedPropertySymbols =
       const <String>["__proto__", "prototype", "constructor", "call"];
 
   // Symbols that we might be using in our JS snippets.
-  static const List<String> reservedGlobalSymbols = const <String>[
+  static const reservedGlobalSymbols = const <String>[
     // Section references are from Ecma-262
     // (http://www.ecma-international.org/publications/files/ECMA-ST/Ecma-262.pdf)
 
@@ -242,7 +148,7 @@ class Namer implements ClosureNamer {
     "JavaArray", "JavaMember",
   ];
 
-  static const List<String> reservedGlobalObjectNames = const <String>[
+  static const reservedGlobalObjectNames = const <String>[
       "A",
       "B",
       "C", // Global object for *C*onstants.
@@ -271,13 +177,12 @@ class Namer implements ClosureNamer {
       "Z",
   ];
 
-  static const List<String> reservedGlobalHelperFunctions = const <String>[
+  static const reservedGlobalHelperFunctions = const <String>[
       "init",
       "Isolate",
   ];
 
-  static final List<String> userGlobalObjects =
-      new List.from(reservedGlobalObjectNames)
+  static final userGlobalObjects = new List.from(reservedGlobalObjectNames)
       ..remove('C')
       ..remove('H')
       ..remove('J')
@@ -329,56 +234,35 @@ class Namer implements ClosureNamer {
 
   final String classDescriptorProperty = r'^';
 
-  /// The non-minifying namer's [callPrefix] with a dollar after it.
-  static const String _callPrefixDollar = r'call$';
-
   // Name of property in a class description for the native dispatch metadata.
   final String nativeSpecProperty = '%';
 
   static final RegExp IDENTIFIER = new RegExp(r'^[A-Za-z_$][A-Za-z0-9_$]*$');
   static final RegExp NON_IDENTIFIER_CHAR = new RegExp(r'[^A-Za-z_0-9$]');
 
+  /**
+   * Map from top-level or static elements to their unique identifiers provided
+   * by [getName].
+   *
+   * Invariant: Keys must be declaration elements.
+   */
   final Compiler compiler;
+  final Map<Element, String> globals;
+  final Map<String, LibraryElement> shortPrivateNameOwners;
 
-  /// Used disambiguated names in the global namespace, issued by
-  /// [_disambiguateGlobal], and [_disambiguateInternalGlobal].
-  ///
-  /// Although global names are distributed across a number of global objects,
-  /// (see [globalObjectFor]), we currently use a single namespace for all these
-  /// names.
-  final Set<String> usedGlobalNames = new Set<String>();
-  final Map<Element, String> userGlobals = <Element, String>{};
-  final Map<String, String> internalGlobals = <String, String>{};
-
-  /// Used disambiguated names in the instance namespace, issued by
-  /// [_disambiguateMember], [_disambiguateInternalMember],
-  /// [_disambiguateOperator], and [reservePublicMemberName].
-  final Set<String> usedInstanceNames = new Set<String>();
-  final Map<String, String> userInstanceMembers = <String, String>{};
-  final Map<Element, String> internalInstanceMembers = <Element, String>{};
-  final Map<String, String> userInstanceOperators = <String, String>{};
-
-  final Map<String, int> popularNameCounters = <String, int>{};
-
-  final Map<ConstantValue, String> constantNames = <ConstantValue, String>{};
-  final Map<ConstantValue, String> constantLongNames =
-      <ConstantValue, String>{};
-  ConstantCanonicalHasher constantHasher;
+  final Set<String> usedGlobalNames;
+  final Set<String> usedInstanceNames;
+  final Map<String, String> globalNameMap;
+  final Map<String, String> suggestedGlobalNames;
+  final Map<String, String> instanceNameMap;
+  final Map<String, String> suggestedInstanceNames;
+
+  final Map<String, String> operatorNameMap;
+  final Map<String, int> popularNameCounters;
 
-  /// Maps private names to a library that may use that name without prefixing
-  /// itself. Used for building proposed names.
-  final Map<String, LibraryElement> shortPrivateNameOwners =
-      <String, LibraryElement>{};
-
-  /// Maps proposed names to *suggested* disambiguated names.
-  ///
-  /// Suggested names are hints to the [MinifyNamer], suggesting that a specific
-  /// names be given to the first item with the given proposed name.
-  ///
-  /// This is currently used in [MinifyNamer] to assign very short minified
-  /// names to things that tend to be used very often.
-  final Map<String, String> suggestedGlobalNames = <String, String>{};
-  final Map<String, String> suggestedInstanceNames = <String, String>{};
+  final Map<ConstantValue, String> constantNames;
+  final Map<ConstantValue, String> constantLongNames;
+  ConstantCanonicalHasher constantHasher;
 
   // All alphanumeric characters.
   static const String _alphaNumeric =
@@ -386,6 +270,18 @@ class Namer implements ClosureNamer {
 
   Namer(Compiler compiler)
       : compiler = compiler,
+        globals = new Map<Element, String>(),
+        shortPrivateNameOwners = new Map<String, LibraryElement>(),
+        usedGlobalNames = new Set<String>(),
+        usedInstanceNames = new Set<String>(),
+        instanceNameMap = new Map<String, String>(),
+        operatorNameMap = new Map<String, String>(),
+        globalNameMap = new Map<String, String>(),
+        suggestedGlobalNames = new Map<String, String>(),
+        suggestedInstanceNames = new Map<String, String>(),
+        popularNameCounters = new Map<String, int>(),
+        constantNames = new Map<ConstantValue, String>(),
+        constantLongNames = new Map<ConstantValue, String>(),
         constantHasher = new ConstantCanonicalHasher(compiler),
         functionTypeNamer = new FunctionTypeNamer(compiler);
 
@@ -419,9 +315,6 @@ class Namer implements ClosureNamer {
     }
   }
 
-  /// Disambiguated name for [constant].
-  ///
-  /// Unique within the global-member namespace.
   String constantName(ConstantValue constant) {
     // In the current implementation it doesn't make sense to give names to
     // function constants since the function-implementation itself serves as
@@ -430,13 +323,14 @@ class Namer implements ClosureNamer {
     String result = constantNames[constant];
     if (result == null) {
       String longName = constantLongName(constant);
-      result = getFreshName(longName, usedGlobalNames, suggestedGlobalNames);
+      result = getFreshName(longName, usedGlobalNames, suggestedGlobalNames,
+                            ensureSafe: true);
       constantNames[constant] = result;
     }
     return result;
   }
 
-  /// Proposed name for [constant].
+  // The long name is unminified and may have collisions.
   String constantLongName(ConstantValue constant) {
     String longName = constantLongNames[constant];
     if (longName == null) {
@@ -466,133 +360,107 @@ class Namer implements ClosureNamer {
   }
 
   /**
-   * If the [originalName] is not private returns [originalName]. Otherwise
-   * mangles the [originalName] so that each library has its own distinguished
-   * version of the name.
-   *
-   * Although the name is not guaranteed to be unique within any namespace,
-   * clashes are very unlikely in practice. Therefore, it can be used in cases
-   * where uniqueness is nice but not a strict requirement.
-   *
-   * The resulting name is a *proposed name* and is never minified.
+   * If the [name] is not private returns [:name:]. Otherwise
+   * mangles the [name] so that each library has a unique name.
    */
-  String privateName(LibraryElement library, String originalName) {
+  String privateName(LibraryElement library, String name) {
     // Public names are easy.
-    if (!isPrivateName(originalName)) return originalName;
+    String nameString = name;
+    if (!isPrivateName(name)) return nameString;
 
     // The first library asking for a short private name wins.
     LibraryElement owner =
-        shortPrivateNameOwners.putIfAbsent(originalName, () => library);
+        shortPrivateNameOwners.putIfAbsent(nameString, () => library);
 
-    if (owner == library) {
-      return originalName;
+    if (owner == library && !nameString.contains('\$')) {
+      // Since the name doesn't contain $ it doesn't clash with any
+      // of the private names that have the library name as the prefix.
+      return nameString;
     } else {
       // Make sure to return a private name that starts with _ so it
       // cannot clash with any public names.
-      // The name is still not guaranteed to be unique, since both the library
-      // name and originalName could contain $ symbols.
-      String libraryName = _disambiguateGlobal(library);
-      return '_$libraryName\$${originalName}';
+      String libraryName = getNameOfLibrary(library);
+      return '_$libraryName\$$nameString';
     }
   }
 
-  String _proposeNameForConstructorBody(ConstructorBodyElement method) {
-    String name = Elements.reconstructConstructorNameSourceString(method);
-    // We include the method suffix on constructor bodies. It has no purpose,
-    // but this way it produces the same names as previous versions of the
-    // Namer class did.
-    List<String> suffix = callSuffixForSignature(method.functionSignature);
-    return '$name\$${suffix.join(r'$')}';
-  }
+  String instanceMethodName(FunctionElement element) {
+    // TODO(ahe): Could this be: return invocationName(new
+    // Selector.fromElement(element))?
+    String elementName = element.name;
+    String name = operatorNameToIdentifier(elementName);
+    if (name != elementName) return getMappedOperatorName(name);
 
-  /// Annotated name for [method] encoding arity and named parameters.
-  String instanceMethodName(FunctionElement method) {
-    if (method.isGenerativeConstructorBody) {
-      return _disambiguateInternalMember(method,
-          () => _proposeNameForConstructorBody(method));
+    LibraryElement library = element.library;
+    if (element.isGenerativeConstructorBody) {
+      name = Elements.reconstructConstructorNameSourceString(element);
     }
-    return invocationName(new Selector.fromElement(method));
-  }
-
-  /// Annotated name for a public method with the given [originalName]
-  /// and [arity] and no named parameters.
-  String publicInstanceMethodNameByArity(String originalName, int arity) {
-    return invocationName(new Selector.call(originalName, null, arity));
-  }
-
-  /// Returns the annotated name for a variant of `call` that takes [arity]
-  /// positional parameters and no named parameters.
-  /// The result has the form:
-  ///
-  ///     call$<N>$namedParam1...$namedParam<M>
-  ///
-  /// This name cannot be minified because it is generated by string
-  /// concatenation at runtime, by applyFunction in js_helper.dart.
-  String deriveCallMethodName(List<String> suffix) {
-    // TODO(asgerf): Avoid clashes when named parameters contain $ symbols.
-    return '$callPrefix\$${suffix.join(r'$')}';
-  }
-
-  /// The suffix list for the pattern:
-  ///
-  ///     $<N>$namedParam1...$namedParam<M>
-  ///
-  /// This is used for the annotated names of `call`, and for the proposed name
-  /// for other instance methods.
-  List<String> callSuffixForSelector(Selector selector) {
-    List<String> suffixes = ['${selector.argumentCount}'];
-    suffixes.addAll(selector.getOrderedNamedArguments());
-    return suffixes;
-  }
-
-  /// The suffix list for the pattern:
-  ///
-  ///     $<N>$namedParam1...$namedParam<M>
-  ///
-  /// This is used for the annotated names of `call`, and for the proposed name
-  /// for other instance methods.
-  List<String> callSuffixForSignature(FunctionSignature sig) {
-    List<String> suffixes = ['${sig.parameterCount}'];
-    if (sig.optionalParametersAreNamed) {
-      for (FormalElement param in sig.orderedOptionalParameters) {
-        suffixes.add(param.name);
-      }
+    FunctionSignature signature = element.functionSignature;
+    // We don't mangle the closure invoking function name because it
+    // is generated by string concatenation in applyFunction from
+    // js_helper.dart. To keep code size down, we potentially shorten
+    // the prefix though.
+    String methodName;
+    if (name == closureInvocationSelectorName) {
+      methodName = '$callPrefix\$${signature.parameterCount}';
+    } else {
+      methodName = '${privateName(library, name)}\$${signature.parameterCount}';
+    }
+    if (signature.optionalParametersAreNamed &&
+        !signature.optionalParameters.isEmpty) {
+      StringBuffer buffer = new StringBuffer();
+      signature.orderedOptionalParameters.forEach((Element element) {
+        buffer.write('\$${safeName(element.name)}');
+      });
+      methodName = '$methodName$buffer';
     }
-    return suffixes;
+    if (name == closureInvocationSelectorName) return methodName;
+    return getMappedInstanceName(methodName);
   }
 
-  /// Annotated name for the member being invoked by [selector].
-  String invocationName(Selector selector) {
-    LibraryElement library = selector.library;
-    switch (selector.kind) {
-      case SelectorKind.GETTER:
-        String disambiguatedName = _disambiguateMember(library, selector.name);
-        return deriveGetterName(disambiguatedName);
-
-      case SelectorKind.SETTER:
-        String disambiguatedName = _disambiguateMember(library, selector.name);
-        return deriveSetterName(disambiguatedName);
-
-      case SelectorKind.OPERATOR:
-      case SelectorKind.INDEX:
-        String operatorIdentifier = operatorNameToIdentifier(selector.name);
-        String disambiguatedName = _disambiguateOperator(operatorIdentifier);
-        return disambiguatedName; // Operators are not annotated.
-
-      case SelectorKind.CALL:
-        List<String> suffix = callSuffixForSelector(selector);
-        if (selector.name == Compiler.CALL_OPERATOR_NAME) {
-          // Derive the annotated name for this variant of 'call'.
-          return deriveCallMethodName(suffix);
-        }
-        String disambiguatedName =
-            _disambiguateMember(library, selector.name, suffix);
-        return disambiguatedName; // Methods other than call are not annotated.
+  String publicInstanceMethodNameByArity(String name, int arity) {
+    String newName = operatorNameToIdentifier(name);
+    if (newName != name) return getMappedOperatorName(newName);
+    assert(!isPrivateName(name));
+    // We don't mangle the closure invoking function name because it
+    // is generated by string concatenation in applyFunction from
+    // js_helper.dart. To keep code size down, we potentially shorten
+    // the prefix though.
+    if (name == closureInvocationSelectorName) return '$callPrefix\$$arity';
 
-      default:
-        compiler.internalError(compiler.currentElement,
-            'Unexpected selector kind: ${selector.kind}');
-        return null;
+    return getMappedInstanceName('$name\$$arity');
+  }
+
+  String invocationName(Selector selector) {
+    if (selector.isGetter) {
+      String proposedName = privateName(selector.library, selector.name);
+      return '$getterPrefix${getMappedInstanceName(proposedName)}';
+    } else if (selector.isSetter) {
+      String proposedName = privateName(selector.library, selector.name);
+      return '$setterPrefix${getMappedInstanceName(proposedName)}';
+    } else {
+      String name = selector.name;
+      if (selector.kind == SelectorKind.OPERATOR
+          || selector.kind == SelectorKind.INDEX) {
+        name = operatorNameToIdentifier(name);
+        assert(name != selector.name);
+        return getMappedOperatorName(name);
+      }
+      assert(name == operatorNameToIdentifier(name));
+      StringBuffer buffer = new StringBuffer();
+      for (String argumentName in selector.getOrderedNamedArguments()) {
+        buffer.write('\$${safeName(argumentName)}');
+      }
+      String suffix = '\$${selector.argumentCount}$buffer';
+      // We don't mangle the closure invoking function name because it
+      // is generated by string concatenation in applyFunction from
+      // js_helper.dart. We potentially shorten the prefix though.
+      if (selector.isClosureCall) {
+        return "$callPrefix$suffix";
+      } else {
+        String proposedName = privateName(selector.library, name);
+        return getMappedInstanceName('$proposedName$suffix');
+      }
     }
   }
 
@@ -603,13 +471,13 @@ class Namer implements ClosureNamer {
       => invocationName(selector);
 
   /**
-   * Returns the disambiguated name for the given field, used for constructing
-   * the getter and setter names.
+   * Returns name of accessor (root to getter and setter) for a static or
+   * instance field.
    */
   String fieldAccessorName(Element element) {
     return element.isInstanceMember
-        ? _disambiguateMember(element.library, element.name)
-        : _disambiguateGlobal(element);
+        ? instanceFieldAccessorName(element)
+        : getNameOfField(element);
   }
 
   /**
@@ -619,297 +487,126 @@ class Namer implements ClosureNamer {
   String fieldPropertyName(Element element) {
     return element.isInstanceMember
         ? instanceFieldPropertyName(element)
-        : _disambiguateGlobal(element);
+        : getNameOfField(element);
   }
 
   /**
-   * Returns name of the JavaScript property used to store the
-   * `readTypeVariable` function for the given type variable.
+   * Returns name of accessor (root to getter and setter) for an instance field.
    */
-  String nameForReadTypeVariable(TypeVariableElement element) {
-    return _disambiguateInternalMember(element, () => element.name);
+  String instanceFieldAccessorName(Element element) {
+    String proposedName = privateName(element.library, element.name);
+    return getMappedInstanceName(proposedName);
   }
 
-  /**
-   * Returns a JavaScript property name used to store [element] on one
-   * of the global objects.
-   *
-   * Should be used together with [globalObjectFor], which denotes the object
-   * on which the returned property name should be used.
-   */
-  String globalPropertyName(Element element) {
-    return _disambiguateGlobal(element);
+  String readTypeVariableName(TypeVariableElement element) {
+    return '\$tv_${instanceFieldAccessorName(element)}';
   }
 
   /**
-   * Returns the JavaScript property name used to store an instance field.
+   * Returns name of the JavaScript property used to store an instance field.
    */
   String instanceFieldPropertyName(Element element) {
-    ClassElement enclosingClass = element.enclosingClass;
-
     if (element.hasFixedBackendName) {
-      // Box fields and certain native fields must be given a specific name.
-      assert(element is BoxFieldElement || enclosingClass.isNative);
-
-      // This name must not contain '$'. We rely on this to avoid clashes.
-      assert(!element.fixedBackendName.contains(r'$'));
-
       return element.fixedBackendName;
     }
-
-    // If the name of the field might clash with another field,
-    // use a mangled field name to avoid potential clashes.
-    // Note that if the class extends a native class, that native class might
-    // have fields with fixed backend names, so we assume the worst and always
-    // mangle the field names of classes extending native classes.
-    // Methods on such classes are stored on the interceptor, not the instance,
-    // so only fields have the potential to clash with a native property name.
+    // If a class is used anywhere as a mixin, we must make the name unique so
+    // that it does not accidentally shadow.  Also, the mixin name must be
+    // constant over all mixins.
     ClassWorld classWorld = compiler.world;
-    if (classWorld.isUsedAsMixin(enclosingClass) ||
-        _isShadowingSuperField(element) ||
-        _isUserClassExtendingNative(enclosingClass)) {
-      String proposeName() => '${enclosingClass.name}_${element.name}';
-      return _disambiguateInternalMember(element, proposeName);
+    if (classWorld.isUsedAsMixin(element.enclosingClass) ||
+        shadowingAnotherField(element)) {
+      // Construct a new name for the element based on the library and class it
+      // is in.  The name here is not important, we just need to make sure it is
+      // unique.  If we are minifying, we actually construct the name from the
+      // minified version of the class name, but the result is minified once
+      // again, so that is not visible in the end result.
+      String libraryName = getNameOfLibrary(element.library);
+      String className = getNameOfClass(element.enclosingClass);
+      String instanceName = privateName(element.library, element.name);
+      return getMappedInstanceName('$libraryName\$$className\$$instanceName');
     }
 
-    // No superclass uses the disambiguated name as a property name, so we can
-    // use it for this field. This generates nicer field names since otherwise
-    // the field name would have to be mangled.
-    return _disambiguateMember(element.library, element.name);
+    String proposedName = privateName(element.library, element.name);
+    return getMappedInstanceName(proposedName);
   }
 
-  bool _isShadowingSuperField(Element element) {
-    return element.enclosingClass.hasFieldShadowedBy(element);
-  }
 
-  /// True if [class_] is a non-native class that inherits from a native class.
-  bool _isUserClassExtendingNative(ClassElement class_) {
-    return !class_.isNative &&
-           Elements.isNativeOrExtendsNative(class_.superclass);
+  bool shadowingAnotherField(Element element) {
+    return element.enclosingClass.hasFieldShadowedBy(element);
   }
 
-  /// Annotated name for the setter of [element].
-  String setterForElement(Element element) {
+  String setterName(Element element) {
     // We dynamically create setters from the field-name. The setter name must
     // therefore be derived from the instance field-name.
-    String name = _disambiguateMember(element.library, element.name);
-    return deriveSetterName(name);
+    LibraryElement library = element.library;
+    String name = getMappedInstanceName(privateName(library, element.name));
+    return '$setterPrefix$name';
   }
 
-  /// Annotated name for the setter of any member with [disambiguatedName].
-  String deriveSetterName(String disambiguatedName) {
+  String setterNameFromAccessorName(String name) {
     // We dynamically create setters from the field-name. The setter name must
     // therefore be derived from the instance field-name.
-    return '$setterPrefix$disambiguatedName';
+    return '$setterPrefix$name';
   }
 
-  /// Annotated name for the setter of any member with [disambiguatedName].
-  String deriveGetterName(String disambiguatedName) {
+  String getterNameFromAccessorName(String name) {
     // We dynamically create getters from the field-name. The getter name must
     // therefore be derived from the instance field-name.
-    return '$getterPrefix$disambiguatedName';
+    return '$getterPrefix$name';
   }
 
-  /// Annotated name for the getter of [element].
-  String getterForElement(Element element) {
+  String getterName(Element element) {
     // We dynamically create getters from the field-name. The getter name must
     // therefore be derived from the instance field-name.
-    String name = _disambiguateMember(element.library, element.name);
-    return deriveGetterName(name);
-  }
-
-  /// Property name for the getter of an instance member with [originalName]
-  /// in [library].
-  ///
-  /// [library] may be `null` if [originalName] is known to be public.
-  String getterForMember(LibraryElement library, String originalName) {
-    String disambiguatedName = _disambiguateMember(library, originalName);
-    return deriveGetterName(disambiguatedName);
-  }
-
-  /// Property name for the getter or a public instance member with
-  /// [originalName].
-  String getterForPublicMember(String originalName) {
-    return getterForMember(null, originalName);
-  }
-
-  /// Disambiguated name for a compiler-owned global variable.
-  ///
-  /// The resulting name is unique within the global-member namespace.
-  String _disambiguateInternalGlobal(String name) {
-    String newName = internalGlobals[name];
-    if (newName == null) {
-      newName = getFreshName(name, usedGlobalNames, suggestedGlobalNames);
-      internalGlobals[name] = newName;
-    }
-    return newName;
+    LibraryElement library = element.library;
+    String name = getMappedInstanceName(privateName(library, element.name));
+    return '$getterPrefix$name';
   }
 
-  /// Returns the property name to use for a compiler-owner global variable,
-  /// i.e. one that does not correspond to any element but is used as a utility
-  /// global by code generation.
-  ///
-  /// [name] functions as both the proposed name for the global, and as a key
-  /// identifying the global. The [name] must not contain `$` symbols, since
-  /// the [Namer] uses those names internally.
-  ///
-  /// This provides an easy mechanism of avoiding a name-clash with user-space
-  /// globals, although the callers of must still take care not to accidentally
-  /// pass in the same [name] for two different internal globals.
-  String internalGlobal(String name) {
-    assert(!name.contains(r'$'));
-    return _disambiguateInternalGlobal(name);
-  }
-
-  /// Returns the disambiguated name for a top-level or static element.
-  ///
-  /// The resulting name is unique within the global-member namespace.
-  String _disambiguateGlobal(Element element) {
-    // TODO(asgerf): We can reuse more short names if we disambiguate with
-    // a separate namespace for each of the global holder objects.
-    element = element.declaration;
-    String newName = userGlobals[element];
+  String getMappedGlobalName(String proposedName, {bool ensureSafe: true}) {
+    var newName = globalNameMap[proposedName];
     if (newName == null) {
-      String proposedName = _proposeNameForGlobal(element);
       newName = getFreshName(proposedName, usedGlobalNames,
-                             suggestedGlobalNames);
-      userGlobals[element] = newName;
-    }
-    return newName;
-  }
-
-  /// Returns the disambiguated name for an instance method or field
-  /// with [originalName] in [library].
-  ///
-  /// [library] may be `null` if [originalName] is known to be public.
-  ///
-  /// This is the name used for deriving property names of accessors (getters
-  /// and setters) and as property name for storing methods and method stubs.
-  ///
-  /// [suffixes] denote an extension of [originalName] to distiguish it from
-  /// other members with that name. These are used to encode the arity and
-  /// named parameters to a method. Disambiguating the same [originalName] with
-  /// different [suffixes] will yield different disambiguated names.
-  ///
-  /// The resulting name, and its associated annotated names, are unique
-  /// to the ([originalName], [suffixes]) pair within the instance-member
-  /// namespace.
-  String _disambiguateMember(LibraryElement library,
-                             String originalName,
-                             [List<String> suffixes = const []]) {
-    // For private names, a library must be given.
-    assert(isPublicName(originalName) || library != null);
-
-    // Build a string encoding the library name, if the name is private.
-    String libraryKey = isPrivateName(originalName)
-            ? _disambiguateGlobal(library)
-            : '';
-
-    // In the unique key, separate the name parts by '@'.
-    // This avoids clashes since the original names cannot contain that symbol.
-    String key = '$libraryKey@$originalName@${suffixes.join('@')}';
-    String newName = userInstanceMembers[key];
-    if (newName == null) {
-      String proposedName = privateName(library, originalName);
-      if (!suffixes.isEmpty) {
-        // In the proposed name, separate the name parts by '$', because the
-        // proposed name must be a valid identifier, but not necessarily unique.
-        proposedName += r'$' + suffixes.join(r'$');
-      }
-      newName = getFreshName(proposedName,
-                             usedInstanceNames, suggestedInstanceNames,
-                             sanitizeForAnnotations: true);
-      userInstanceMembers[key] = newName;
+                             suggestedGlobalNames, ensureSafe: ensureSafe);
+      globalNameMap[proposedName] = newName;
     }
     return newName;
   }
 
-  /// Forces the public instance member with [originalName] to have the given
-  /// [disambiguatedName].
-  ///
-  /// The [originalName] must not have been disambiguated before, and the
-  /// [disambiguatedName] must not have been used.
-  ///
-  /// Using [_disambiguateMember] with the given [originalName] and no suffixes
-  /// will subsequently return [disambiguatedName].
-  void reservePublicMemberName(String originalName,
-                               String disambiguatedName) {
-    // Build a key that corresponds to the one built in disambiguateMember.
-    String libraryPrefix = ''; // Public names have an empty library prefix.
-    String suffix = ''; // We don't need any suffixes.
-    String key = '$libraryPrefix@$originalName@$suffix';
-    assert(!userInstanceMembers.containsKey(key));
-    assert(!usedInstanceNames.contains(disambiguatedName));
-    userInstanceMembers[key] = disambiguatedName;
-    usedInstanceNames.add(disambiguatedName);
-  }
-
-  /// Disambiguated name unique to [element].
-  ///
-  /// This is used as the property name for fields, type variables,
-  /// constructor bodies, and super-accessors.
-  ///
-  /// The resulting name is unique within the instance-member namespace.
-  String _disambiguateInternalMember(Element element, String proposeName()) {
-    String newName = internalInstanceMembers[element];
+  String getMappedInstanceName(String proposedName) {
+    var newName = instanceNameMap[proposedName];
     if (newName == null) {
-      String name = proposeName();
-      bool mayClashNative = _isUserClassExtendingNative(element.enclosingClass);
-      newName = getFreshName(name,
-                             usedInstanceNames, suggestedInstanceNames,
-                             sanitizeForAnnotations: true,
-                             sanitizeForNatives: mayClashNative);
-      internalInstanceMembers[element] = newName;
+      newName = getFreshName(proposedName, usedInstanceNames,
+                             suggestedInstanceNames, ensureSafe: true);
+      instanceNameMap[proposedName] = newName;
     }
     return newName;
   }
 
-  /// Disambiguated name for the given operator.
-  ///
-  /// [operatorIdentifier] must be the operator's identifier, e.g.
-  /// `$add` and not `+`.
-  ///
-  /// The resulting name is unique within the instance-member namespace.
-  String _disambiguateOperator(String operatorIdentifier) {
-    String newName = userInstanceOperators[operatorIdentifier];
+  String getMappedOperatorName(String proposedName) {
+    var newName = operatorNameMap[proposedName];
     if (newName == null) {
-      newName = getFreshName(operatorIdentifier, usedInstanceNames,
-                             suggestedInstanceNames);
-      userInstanceOperators[operatorIdentifier] = newName;
+      newName = getFreshName(proposedName, usedInstanceNames,
+                             suggestedInstanceNames, ensureSafe: false);
+      operatorNameMap[proposedName] = newName;
     }
     return newName;
   }
 
-  /// Returns an unused name.
-  ///
-  /// [proposedName] must be a valid JavaScript identifier.
-  ///
-  /// If [sanitizeForAnnotations] is `true`, then the result is guaranteed not
-  /// to have the form of an annotated name.
-  ///
-  /// If [sanitizeForNatives] it `true`, then the result is guaranteed not to
-  /// clash with a property name on a native object.
-  ///
-  /// Note that [MinifyNamer] overrides this method with one that produces
-  /// minified names.
   String getFreshName(String proposedName,
                       Set<String> usedNames,
                       Map<String, String> suggestedNames,
-                      {bool sanitizeForAnnotations: false,
-                       bool sanitizeForNatives: false}) {
-    if (sanitizeForAnnotations) {
-      proposedName = _sanitizeForAnnotations(proposedName);
+                      {bool ensureSafe: true}) {
+    var candidate;
+    if (ensureSafe) {
+      proposedName = safeName(proposedName);
     }
-    if (sanitizeForNatives) {
-      proposedName = _sanitizeForNatives(proposedName);
-    }
-    proposedName = _sanitizeForKeywords(proposedName);
-    String candidate;
+    assert(!jsReserved.contains(proposedName));
     if (!usedNames.contains(proposedName)) {
       candidate = proposedName;
     } else {
-      int counter = popularNameCounters[proposedName];
-      int i = (counter == null) ? 0 : counter;
+      var counter = popularNameCounters[proposedName];
+      var i = counter == null ? 0 : counter;
       while (usedNames.contains("$proposedName$i")) {
         i++;
       }
@@ -920,63 +617,15 @@ class Namer implements ClosureNamer {
     return candidate;
   }
 
-  /// Returns a variant of [name] that cannot clash with the annotated
-  /// version of another name, that is, the resulting name can never be returned
-  /// by [deriveGetterName], [deriveSetterName], [deriveCallMethodName],
-  /// [operatorIs], or [substitutionName].
-  ///
-  /// For example, a name `get$x` would be converted to `$get$x` to ensure it
-  /// cannot clash with the getter for `x`.
-  ///
-  /// We don't want to register all potential annotated names in
-  /// [usedInstanceNames] (there are too many), so we use this step to avoid
-  /// clashes between annotated and unannotated names.
-  String _sanitizeForAnnotations(String name) {
-    // Ensure name does not clash with a getter or setter of another name,
-    // one of the other special names that start with `$`, such as `$is`,
-    // or with one of the `call` stubs, such as `call$1`.
-    assert(this is! MinifyNamer);
-    if (name.startsWith(r'$') ||
-        name.startsWith(getterPrefix) ||
-        name.startsWith(setterPrefix) ||
-        name.startsWith(_callPrefixDollar)) {
-      name = '\$$name';
-    }
-    return name;
-  }
-
-  /// Returns a variant of [name] that cannot clash with a native property name
-  /// (e.g. the name of a method on a JS DOM object).
-  ///
-  /// If [name] is not an annotated name, the result will not be an annotated
-  /// name either.
-  String _sanitizeForNatives(String name) {
-    if (!name.contains(r'$')) {
-      // Prepend $$. The result must not coincide with an annotated name.
-      name = '\$\$$name';
-    }
-    return name;
-  }
-
-  /// Generate a unique name for the [id]th closure variable, with proposed name
-  /// [name].
-  ///
-  /// The result is used as the name of [BoxFieldElement]s and
-  /// [ClosureFieldElement]s, and must therefore be unique to avoid breaking an
-  /// invariant in the element model (classes cannot declare multiple fields
-  /// with the same name).
-  ///
-  /// Since the result is used as an element name, it will later show up as a
-  /// *proposed name* when the element is passed to [instanceFieldPropertyName].
   String getClosureVariableName(String name, int id) {
     return "${name}_$id";
   }
 
   /**
-   * Returns a proposed name for the given top-level or static element.
+   * Returns a preferred JS-id for the given top-level or static element.
    * The returned id is guaranteed to be a valid JS-id.
    */
-  String _proposeNameForGlobal(Element element) {
+  String _computeGuess(Element element) {
     assert(!element.isInstanceMember);
     String name;
     if (element.isGenerativeConstructor) {
@@ -1021,7 +670,7 @@ class Namer implements ClosureNamer {
     return name;
   }
 
-  String suffixForGetInterceptor(Iterable<ClassElement> classes) {
+  String getInterceptorSuffix(Iterable<ClassElement> classes) {
     String abbreviate(ClassElement cls) {
       if (cls == compiler.objectClass) return "o";
       if (cls == backend.jsStringClass) return "s";
@@ -1048,118 +697,137 @@ class Namer implements ClosureNamer {
     return names.join();
   }
 
-  /// Property name used for `getInterceptor` or one of its specializations.
-  String nameForGetInterceptor(Iterable<ClassElement> classes) {
-    FunctionElement getInterceptor = backend.getInterceptorMethod;
+  String getInterceptorName(Element element, Iterable<ClassElement> classes) {
     if (classes.contains(backend.jsInterceptorClass)) {
       // If the base Interceptor class is in the set of intercepted classes, we
       // need to go through the generic getInterceptorMethod, since any subclass
       // of the base Interceptor could match.
-      // The unspecialized getInterceptor method can also be accessed through
-      // its element, so we treat this as a user-space global instead of an
-      // internal global.
-      return _disambiguateGlobal(getInterceptor);
+      return getNameOfInstanceMember(element);
     }
-    String suffix = suffixForGetInterceptor(classes);
-    return _disambiguateInternalGlobal("${getInterceptor.name}\$$suffix");
+    String suffix = getInterceptorSuffix(classes);
+    return getMappedGlobalName("${element.name}\$$suffix");
   }
 
-  /// Property name used for the one-shot interceptor method for the given
-  /// [selector] and return-type specialization.
-  String nameForGetOneShotInterceptor(Selector selector,
-                                      Iterable<ClassElement> classes) {
+  String getOneShotInterceptorName(Selector selector,
+                                   Iterable<ClassElement> classes) {
     // The one-shot name is a global name derived from the invocation name.  To
     // avoid instability we would like the names to be unique and not clash with
     // other global names.
 
-    String root = invocationName(selector);
+    String root = invocationName(selector);  // Is already safe.
 
     if (classes.contains(backend.jsInterceptorClass)) {
       // If the base Interceptor class is in the set of intercepted classes,
       // this is the most general specialization which uses the generic
       // getInterceptor method.  To keep the name short, we add '$' only to
-      // distinguish from internal globals requested from outside the Namer
-      // with internalGlobal().
+      // distinguish from global getters or setters; operators and methods can't
+      // clash.
       // TODO(sra): Find a way to get the simple name when Object is not in the
       // set of classes for most general variant, e.g. "$lt$n" could be "$lt".
       if (selector.isGetter || selector.isSetter) root = '$root\$';
-      return _disambiguateInternalGlobal(root);
+      return getMappedGlobalName(root, ensureSafe: false);
     } else {
-      String suffix = suffixForGetInterceptor(classes);
-      return _disambiguateInternalGlobal("$root\$$suffix");
+      String suffix = getInterceptorSuffix(classes);
+      return getMappedGlobalName("$root\$$suffix", ensureSafe: false);
     }
   }
 
-  /// Returns the runtime name for [element].
-  ///
-  /// This name is used as the basis for deriving `is` and `as` property names
-  /// for the given type.
-  ///
-  /// The result is not always safe as a property name unless prefixing
-  /// [operatorIsPrefix] or [operatorAsPrefix]. If this is a function type,
-  /// then by convention, an underscore must also separate [operatorIsPrefix]
-  /// from the type name.
-  String runtimeTypeName(TypeDeclarationElement element) {
+  /// Returns the runtime name for [element].  The result is not safe as an id.
+  String getRuntimeTypeName(Element element) {
     if (element == null) return 'dynamic';
-    // The returned name affects both the global and instance member namespaces:
-    //
-    // - If given a class, this must coincide with the class name, which
-    //   is also the GLOBAL property name of its constructor.
-    //
-    // - The result is used to derive `$isX` and `$asX` names, which are used
-    //   as INSTANCE property names.
-    //
-    // To prevent clashes in both namespaces at once, we disambiguate the name
-    // as a global here, and in [_sanitizeForAnnotations] we ensure that
-    // ordinary instance members cannot start with `$is` or `$as`.
-    return _disambiguateGlobal(element);
-  }
-
-  /// Returns the disambiguated name of [class_].
-  ///
-  /// This is both the *runtime type* of the class (see [runtimeTypeName])
-  /// and a global property name in which to store its JS constructor.
-  String className(ClassElement class_) => _disambiguateGlobal(class_);
-
-  /// Property name on which [member] can be accessed directly,
-  /// without clashing with another JS property name.
-  ///
-  /// This is used for implementing super-calls, where ordinary dispatch
-  /// semantics must be circumvented. For example:
-  ///
-  ///     class A { foo() }
-  ///     class B extends A {
-  ///         foo() { super.foo() }
-  ///     }
-  ///
-  /// Example translation to JS:
-  ///
-  ///     A.prototype.super$A$foo = function() {...}
-  ///     A.prototype.foo$0 = A.prototype.super$A$foo
-  ///
-  ///     B.prototype.foo$0 = function() {
-  ///         this.super$A$foo(); // super.foo()
-  ///     }
-  ///
-  String aliasedSuperMemberPropertyName(Element member) {
-    assert(!member.isField); // Fields do not need super aliases.
-    String methodName = instanceMethodName(member);
-    return _disambiguateInternalMember(member,
-        () => 'super\$${member.enclosingClass.name}\$$methodName');
-  }
-
-  /// Property name in which to store the given static or instance [method].
-  /// For instance methods, this includes the suffix encoding arity and named
-  /// parameters.
-  ///
-  /// The name is not necessarily unique to [method], since a static method
-  /// may share its name with an instance method.
-  String methodPropertyName(Element method) {
-    return method.isInstanceMember
-        ? instanceMethodName(method)
-        : globalPropertyName(method);
+    return getNameForRti(element);
+  }
+
+  /**
+   * Returns a preferred JS-id for the given element. The returned id is
+   * guaranteed to be a valid JS-id. Globals and static fields are furthermore
+   * guaranteed to be unique.
+   *
+   * For accessing statics consider calling [elementAccess] instead.
+   */
+  // TODO(ahe): This is an internal method to the Namer (and its subclasses)
+  // and should not be call from outside.
+  String getNameX(Element element) {
+    if (element.isInstanceMember) {
+      if (element.kind == ElementKind.GENERATIVE_CONSTRUCTOR_BODY
+          || element.kind == ElementKind.FUNCTION) {
+        return instanceMethodName(element);
+      } else if (element.kind == ElementKind.GETTER) {
+        return getterName(element);
+      } else if (element.kind == ElementKind.SETTER) {
+        return setterName(element);
+      } else if (element.kind == ElementKind.FIELD) {
+        compiler.internalError(element,
+            'Use instanceFieldPropertyName or instanceFieldAccessorName.');
+        return null;
+      } else {
+        compiler.internalError(element,
+            'getName for bad kind: ${element.kind}.');
+        return null;
+      }
+    } else {
+      // Use declaration element to ensure invariant on [globals].
+      element = element.declaration;
+      // Dealing with a top-level or static element.
+      String cached = globals[element];
+      if (cached != null) return cached;
+
+      String guess = _computeGuess(element);
+      ElementKind kind = element.kind;
+      if (kind == ElementKind.VARIABLE ||
+          kind == ElementKind.PARAMETER) {
+        // The name is not guaranteed to be unique.
+        return safeName(guess);
+      }
+      if (kind == ElementKind.GENERATIVE_CONSTRUCTOR ||
+          kind == ElementKind.FUNCTION ||
+          kind == ElementKind.CLASS ||
+          kind == ElementKind.FIELD ||
+          kind == ElementKind.GETTER ||
+          kind == ElementKind.SETTER ||
+          kind == ElementKind.TYPEDEF ||
+          kind == ElementKind.LIBRARY) {
+        bool fixedName = false;
+        if (Elements.isInstanceField(element)) {
+          fixedName = element.hasFixedBackendName;
+        }
+        String result = fixedName
+            ? guess
+            : getFreshName(guess, usedGlobalNames, suggestedGlobalNames,
+                           ensureSafe: true);
+        globals[element] = result;
+        return result;
+      }
+      compiler.internalError(element,
+          'getName for unknown kind: ${element.kind}.');
+      return null;
+    }
   }
 
+  String getNameForRti(Element element) => getNameX(element);
+
+  String getNameOfLibrary(LibraryElement library) => getNameX(library);
+
+  String getNameOfClass(ClassElement cls) => getNameX(cls);
+
+  String getNameOfField(VariableElement field) => getNameX(field);
+
+  // TODO(ahe): Remove this method. Use get getNameOfMember instead.
+  String getNameOfInstanceMember(Element member) => getNameX(member);
+
+  String getNameOfAliasedSuperMember(Element member) {
+    ClassElement superClass = member.enclosingClass;
+    String className = getNameOfClass(superClass);
+    String memberName = getNameOfMember(member);
+    String proposal = "$superPrefix$className\$$memberName";
+    // TODO(herhut): Use field naming constraints (unique wrt. inheritance).
+    return getMappedInstanceName(proposal);
+  }
+
+  String getNameOfMember(Element member) => getNameX(member);
+
+  String getNameOfGlobalField(VariableElement field) => getNameX(field);
+
   /// Returns true if [element] is stored on current isolate ('$').  We intend
   /// to store only mutable static state in [currentIsolate], constants are
   /// stored in 'C', and functions, accessors, classes, etc. are stored in one
@@ -1193,23 +861,21 @@ class Namer implements ClosureNamer {
         library.getLibraryOrScriptName().hashCode % userGlobalObjects.length];
   }
 
-  String lazyInitializerName(Element element) {
+  String getLazyInitializerName(Element element) {
     assert(Elements.isStaticOrTopLevelField(element));
-    String name = _disambiguateGlobal(element);
-    return _disambiguateInternalGlobal("$getterPrefix$name");
+    return getMappedGlobalName("$getterPrefix${getNameX(element)}");
   }
 
-  String staticClosureName(Element element) {
-    assert(Elements.isStaticOrTopLevelFunction(element));
-    String name = _disambiguateGlobal(element);
-    return _disambiguateInternalGlobal("$name\$closure");
+  String getStaticClosureName(Element element) {
+    assert(invariant(element, Elements.isStaticOrTopLevelFunction(element)));
+    return getMappedGlobalName("${getNameX(element)}\$closure");
   }
 
   // This name is used as part of the name of a TypeConstant
   String uniqueNameForTypeConstantElement(Element element) {
     // TODO(sra): If we replace the period with an identifier character,
     // TypeConstants will have better names in unminified code.
-    return "${globalObjectFor(element)}.${globalPropertyName(element)}";
+    return "${globalObjectFor(element)}.${getNameX(element)}";
   }
 
   String globalObjectForConstant(ConstantValue constant) => 'C';
@@ -1242,7 +908,7 @@ class Namer implements ClosureNamer {
     return functionTypeNameMap.putIfAbsent(functionType, () {
       String proposedName = functionTypeNamer.computeName(functionType);
       String freshName = getFreshName(proposedName, usedInstanceNames,
-                                      suggestedInstanceNames);
+                                      suggestedInstanceNames, ensureSafe: true);
       return freshName;
     });
   }
@@ -1255,35 +921,32 @@ class Namer implements ClosureNamer {
     return operatorIs(type.element);
   }
 
-  String operatorIs(ClassElement element) {
+  String operatorIs(Element element) {
     // TODO(erikcorry): Reduce from $isx to ix when we are minifying.
-    return '${operatorIsPrefix}${runtimeTypeName(element)}';
+    return '${operatorIsPrefix}${getRuntimeTypeName(element)}';
   }
 
-  /// Returns a name that does not clash with reserved JS keywords.
-  String _sanitizeForKeywords(String name) {
-    if (jsReserved.contains(name)) {
+  /*
+   * Returns a name that does not clash with reserved JS keywords,
+   * and also ensures it won't clash with other identifiers.
+   */
+  String _safeName(String name, Set<String> reserved) {
+    if (reserved.contains(name) || name.startsWith(r'$')) {
       name = '\$$name';
     }
-    assert(!jsReserved.contains(name));
+    assert(!reserved.contains(name));
     return name;
   }
 
   String substitutionName(Element element) {
-    return '${operatorAsPrefix}${runtimeTypeName(element)}';
+    // TODO(ahe): Creating a string here is unfortunate. It is slow (due to
+    // string concatenation in the implementation), and may prevent
+    // segmentation of '$'.
+    return '${operatorAsPrefix}${getNameForRti(element)}';
   }
 
-  /// Returns a variable name that cannot clash with a keyword, a global
-  /// variable, or any name starting with a single '$'.
-  ///
-  /// Furthermore, this function is injective, that is, it never returns the
-  /// same name for two different inputs.
-  String safeVariableName(String name) {
-    if (jsVariableReserved.contains(name) || name.startsWith(r'$')) {
-      return '\$$name';
-    }
-    return name;
-  }
+  String safeName(String name) => _safeName(name, jsReserved);
+  String safeVariableName(String name) => _safeName(name, jsVariableReserved);
 
   String operatorNameToIdentifier(String name) {
     if (name == null) return null;
@@ -1340,10 +1003,10 @@ class Namer implements ClosureNamer {
   }
 
   void forgetElement(Element element) {
-    String globalName = userGlobals[element];
+    String globalName = globals[element];
     invariant(element, globalName != null, message: 'No global name.');
     usedGlobalNames.remove(globalName);
-    userGlobals.remove(element);
+    globals.remove(element);
   }
 }