Use entities for globals in Namer.

pkg/compiler/lib/src/js_emitter/program_builder/program_builder.dart

 // Copyright (c) 2014, 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 dart2js.js_emitter.program_builder;
 
 import 'dart:io';
 import 'dart:convert' show JSON;
 
 import '../../closure.dart' show ClosureTask, ClosureFieldElement;
@@ skipping 424 matching lines @@
   }
 
   StaticField _buildStaticField(FieldElement element) {
     ConstantValue initialValue =
         _constantHandler.getConstantValue(element.constant);
     // TODO(zarah): The holder should not be registered during building of
     // a static field.
     _registry.registerHolder(_namer.globalObjectForConstant(initialValue),
         isConstantsHolder: true);
     js.Expression code = _task.emitter.constantReference(initialValue);
-    js.Name name = _namer.globalPropertyName(element);
+    js.Name name = _namer.globalPropertyNameForMember(element);
     bool isFinal = false;
     bool isLazy = false;
 
     // TODO(floitsch): we shouldn't update the registry in the middle of
     // building a static field. (Note that the static-state holder was
     // already registered earlier, and that we just call the register to get
     // the holder-instance.
     return new StaticField(
         element, name, _registerStaticStateHolder(), code, isFinal, isLazy);
   }
@@ skipping 12 matching lines @@
         .toList(growable: false);
   }
 
   StaticField _buildLazyField(FieldElement element) {
     js.Expression code = _generatedCode[element];
     // The code is null if we ended up not needing the lazily
     // initialized field after all because of constant folding
     // before code generation.
     if (code == null) return null;
 
-    js.Name name = _namer.globalPropertyName(element);
+    js.Name name = _namer.globalPropertyNameForMember(element);
     bool isFinal = element.isFinal;
     bool isLazy = true;
     // TODO(floitsch): we shouldn't update the registry in the middle of
     // building a static field. (Note that the static-state holder was
     // already registered earlier, and that we just call the register to get
     // the holder-instance.
     return new StaticField(
         element, name, _registerStaticStateHolder(), code, isFinal, isLazy);
   }
 
@@ skipping 291 matching lines @@
           checkedSetters.add(_buildStubMethod(name, code, element: element));
         }
       }
 
       typeTests.properties.forEach((js.Name name, js.Node code) {
         isChecks.add(_buildStubMethod(name, code));
       });
     }
 
     js.Name name = _namer.className(element);
-    String holderName = _namer.globalObjectFor(element);
+    String holderName = _namer.globalObjectForClass(element);
     // TODO(floitsch): we shouldn't update the registry in the middle of
     // building a class.
     Holder holder = _registry.registerHolder(holderName);
     bool isInstantiated = !_nativeData.isJsInteropClass(element) &&
         _worldBuilder.directlyInstantiatedClasses.contains(element);
 
     Class result;
     if (element.isMixinApplication && !onlyForRti) {
       assert(!_nativeData.isNativeClass(element));
       assert(methods.isEmpty);
@@ skipping 306 matching lines @@
 
     List<js.Name> names = _oneShotInterceptorData.oneShotInterceptorNames;
     return names.map((js.Name name) {
       js.Expression code = stubGenerator.generateOneShotInterceptor(name);
       return new StaticStubMethod(name, holder, code);
     });
   }
 
   StaticDartMethod _buildStaticMethod(MethodElement element) {
     js.Name name = _namer.methodPropertyName(element);
-    String holder = _namer.globalObjectFor(element);
+    String holder = _namer.globalObjectForMember(element);
     js.Expression code = _generatedCode[element];
 
     bool isApplyTarget = !element.isConstructor && !element.isAccessor;
     bool canBeApplied = _methodCanBeApplied(element);
     bool canBeReflected = _methodCanBeReflected(element);
 
     bool needsTearOff = isApplyTarget &&
         (canBeReflected ||
             _worldBuilder.staticFunctionsNeedingGetter.contains(element));
 
@@ skipping 49 matching lines @@
       Constant constant = new Constant(name, holder, constantValue);
       _constants[constantValue] = constant;
     }
   }
 
   Holder _registerStaticStateHolder() {
     return _registry.registerHolder(_namer.staticStateHolder,
         isStaticStateHolder: true);
   }
 }