A step towards handling `new Object()` in compile_from_dill_test

pkg/compiler/lib/src/js_backend/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.
 
 library js_backend.namer;
 
 import 'dart:collection' show HashMap;
 
 import 'package:js_runtime/shared/embedded_names.dart' show JsGetName;
 
@@ skipping 509 matching lines @@
   final Map<Entity, jsAst.Name> userGlobals = new HashMap<Entity, jsAst.Name>();
   final Map<String, jsAst.Name> internalGlobals =
       new HashMap<String, jsAst.Name>();
 
   /// Used disambiguated names in the instance namespace, issued by
   /// [_disambiguateMember], [_disambiguateInternalMember],
   /// [_disambiguateOperator], and [reservePublicMemberName].
   final NamingScope instanceScope = new NamingScope();
   final Map<String, jsAst.Name> userInstanceMembers =
       new HashMap<String, jsAst.Name>();
-  final Map<Element, jsAst.Name> internalInstanceMembers =
-      new HashMap<Element, jsAst.Name>();
+  final Map<MemberEntity, jsAst.Name> internalInstanceMembers =
+      new HashMap<MemberEntity, jsAst.Name>();
   final Map<String, jsAst.Name> userInstanceOperators =
       new HashMap<String, jsAst.Name>();
 
   /// Used to disambiguate names for constants in [constantName].
   final NamingScope constantScope = new NamingScope();
 
   /// Used to store scopes for instances of [PrivatelyNamedJsEntity]
   final Map<Entity, NamingScope> _privateNamingScopes =
       new Map<Entity, NamingScope>();
 
@@ skipping 220 matching lines @@
   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'$')}';
   }
 
   /// Name for a constructor body.
-  jsAst.Name constructorBodyName(FunctionElement ctor) {
+  jsAst.Name constructorBodyName(ConstructorBodyElement ctor) {
     return _disambiguateInternalMember(
         ctor, () => _proposeNameForConstructorBody(ctor));
   }
 
   /// Annotated name for [method] encoding arity and named parameters.
   jsAst.Name instanceMethodName(FunctionEntity method) {
     // TODO(johnniwinther): Avoid the use of [ConstructorBodyElement]. The
     // codegen model should be explicit about its constructor body elements.
     if (method is ConstructorBodyElement) {
       return constructorBodyName(method);
@@ skipping 194 matching lines @@
   }
 
   /// Annotated name for the setter of any member with [disambiguatedName].
   jsAst.Name deriveGetterName(jsAst.Name disambiguatedName) {
     // We dynamically create getters from the field-name. The getter name must
     // therefore be derived from the instance field-name.
     return new GetterName(_literalGetterPrefix, disambiguatedName);
   }
 
   /// Annotated name for the getter of [element].
-  jsAst.Name getterForElement(MemberElement element) {
+  jsAst.Name getterForElement(MemberEntity element) {
     // We dynamically create getters from the field-name. The getter name must
     // therefore be derived from the instance field-name.
-    jsAst.Name name = _disambiguateMember(element.memberName);
+    jsAst.Name name = _disambiguateMember(
+        new Name(element.name, element.library, isSetter: element.isSetter));
     return deriveGetterName(name);
   }
 
   /// Property name for the getter of an instance member with [originalName].
   jsAst.Name getterForMember(Name originalName) {
     jsAst.Name disambiguatedName = _disambiguateMember(originalName);
     return deriveGetterName(disambiguatedName);
   }
 
   /// Disambiguated name for a compiler-owned global variable.
@@ skipping 150 matching lines @@
     instanceScope.registerUse(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.
   jsAst.Name _disambiguateInternalMember(
-      Element element, String proposeName()) {
+      MemberEntity element, String proposeName()) {
     jsAst.Name newName = internalInstanceMembers[element];
     if (newName == null) {
       String name = proposeName();
 
-      Entity asEntity = element;
-      if (asEntity is PrivatelyNamedJSEntity) {
-        NamingScope scope = _getPrivateScopeFor(asEntity);
+      if (element is PrivatelyNamedJSEntity) {
+        NamingScope scope = _getPrivateScopeFor(element);
         newName = getFreshName(scope, name,
             sanitizeForAnnotations: true, sanitizeForNatives: false);
         internalInstanceMembers[element] = newName;
       } else {
         bool mayClashNative =
             _isUserClassExtendingNative(element.enclosingClass);
         newName = getFreshName(instanceScope, name,
             sanitizeForAnnotations: true, sanitizeForNatives: mayClashNative);
         internalInstanceMembers[element] = newName;
       }
@@ skipping 282 matching lines @@
   ///
   /// 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()
   ///     }
   ///
-  jsAst.Name aliasedSuperMemberPropertyName(MemberElement member) {
+  jsAst.Name aliasedSuperMemberPropertyName(MemberEntity member) {
     assert(!member.isField); // Fields do not need super aliases.
     return _disambiguateInternalMember(member, () {
       String invocationName = operatorNameToIdentifier(member.name);
       return "super\$${member.enclosingClass.name}\$$invocationName";
     });
   }
 
   /// Property name in which to store the given static or instance [method].
   /// For instance methods, this includes the suffix encoding arity and named
   /// parameters.
@@ skipping 750 matching lines @@
   void addSuggestion(String original, String suggestion) {
     assert(!_suggestedNames.containsKey(original));
     _suggestedNames[original] = suggestion;
   }
 
   bool hasSuggestion(String original) => _suggestedNames.containsKey(original);
   bool isSuggestion(String candidate) {
     return _suggestedNames.containsValue(candidate);
   }
 }