Use entities for globals in Namer.

pkg/compiler/lib/src/js_emitter/full_emitter/emitter.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.full_emitter;
 
 import 'dart:collection' show HashMap;
 import 'dart:convert';
 
 import 'package:js_runtime/shared/embedded_names.dart' as embeddedNames;
@@ skipping 35 matching lines @@
         TypeVariableCodegenAnalysis;
 import '../../js_backend/native_data.dart';
 import '../../universe/call_structure.dart' show CallStructure;
 import '../../universe/selector.dart' show Selector;
 import '../../universe/world_builder.dart' show CodegenWorldBuilder;
 import '../../util/uri_extras.dart' show relativize;
 import '../../world.dart' show ClosedWorld;
 import '../constant_ordering.dart' show deepCompareConstants;
 import '../headers.dart';
 import '../js_emitter.dart' hide Emitter, EmitterFactory;
-import '../js_emitter.dart' as js_emitter show Emitter, EmitterFactory;
+import '../js_emitter.dart' as js_emitter show EmitterBase, EmitterFactory;
 import '../model.dart';
 import '../program_builder/program_builder.dart';
 import '../sorter.dart';
 
 import 'class_builder.dart';
 import 'class_emitter.dart';
 import 'container_builder.dart';
 import 'interceptor_emitter.dart';
 import 'nsm_emitter.dart';
 
@@ skipping 17 matching lines @@
   bool get supportsReflection => true;
 
   @override
   Emitter createEmitter(
       CodeEmitterTask task, Namer namer, ClosedWorld closedWorld) {
     return new Emitter(task.compiler, namer, closedWorld, generateSourceMap,
         task, task.sorter);
   }
 }
 
-class Emitter implements js_emitter.Emitter {
+class Emitter extends js_emitter.EmitterBase {
   final Compiler compiler;
   final CodeEmitterTask task;
   final ClosedWorld _closedWorld;
 
   // The following fields will be set to copies of the program-builder's
   // collector.
   Map<OutputUnit, List<FieldEntity>> outputStaticNonFinalFieldLists;
   Map<OutputUnit, Set<LibraryEntity>> outputLibraryLists;
   List<TypedefElement> typedefsNeededForReflection;
 
@@ skipping 187 matching lines @@
   @override
   jsAst.Expression generateEmbeddedGlobalAccess(String global) {
     return js(generateEmbeddedGlobalAccessString(global));
   }
 
   String generateEmbeddedGlobalAccessString(String global) {
     // TODO(floitsch): don't use 'init' as global embedder storage.
     return '$initName.$global';
   }
 
-  jsAst.PropertyAccess globalPropertyAccess(Element element) {
-    jsAst.Name name = namer.globalPropertyName(element);
-    jsAst.PropertyAccess pa = new jsAst.PropertyAccess(
-        new jsAst.VariableUse(namer.globalObjectFor(element)), name);
-    return pa;
-  }
-
   @override
   jsAst.Expression isolateLazyInitializerAccess(FieldElement element) {
-    return jsAst.js('#.#',
-        [namer.globalObjectFor(element), namer.lazyInitializerName(element)]);
+    return jsAst.js('#.#', [
+      namer.globalObjectForMember(element),
+      namer.lazyInitializerName(element)
+    ]);
   }
 
   @override
   jsAst.Expression isolateStaticClosureAccess(MethodElement element) {
-    return jsAst.js('#.#()',
-        [namer.globalObjectFor(element), namer.staticClosureName(element)]);
+    return jsAst.js('#.#()', [
+      namer.globalObjectForMember(element),
+      namer.staticClosureName(element)
+    ]);
   }
 
   @override
-  jsAst.PropertyAccess staticFieldAccess(FieldElement element) {
-    return globalPropertyAccess(element);
-  }
-
-  @override
-  jsAst.PropertyAccess staticFunctionAccess(MethodElement element) {
-    return globalPropertyAccess(element);
-  }
-
-  @override
-  jsAst.PropertyAccess constructorAccess(ClassElement element) {
-    return globalPropertyAccess(element);
-  }
-
-  @override
   jsAst.PropertyAccess prototypeAccess(
       ClassElement element, bool hasBeenInstantiated) {
     return jsAst.js('#.prototype', constructorAccess(element));
   }
 
   @override
-  jsAst.PropertyAccess interceptorClassAccess(ClassElement element) {
-    return globalPropertyAccess(element);
-  }
-
-  @override
-  jsAst.PropertyAccess typeAccess(Entity element) {
-    return globalPropertyAccess(element);
-  }
-
-  @override
   jsAst.Template templateForBuiltin(JsBuiltin builtin) {
     switch (builtin) {
       case JsBuiltin.dartObjectConstructor:
         return jsAst.js
             .expressionTemplateYielding(typeAccess(commonElements.objectClass));
 
       case JsBuiltin.isCheckPropertyToJsConstructorName:
         int isPrefixLength = namer.operatorIsPrefix.length;
         return jsAst.js.expressionTemplateFor('#.substring($isPrefixLength)');
 
@@ skipping 239 matching lines @@
           .properties
           .addAll(builder.properties);
     }
   }
 
   jsAst.Statement buildStaticNonFinalFieldInitializations(
       OutputUnit outputUnit) {
     jsAst.Statement buildInitialization(
         FieldElement element, jsAst.Expression initialValue) {
       return js.statement('${namer.staticStateHolder}.# = #',
-          [namer.globalPropertyName(element), initialValue]);
+          [namer.globalPropertyNameForMember(element), initialValue]);
     }
 
     bool inMainUnit = (outputUnit == compiler.deferredLoadTask.mainOutputUnit);
     JavaScriptConstantCompiler handler = backend.constants;
     List<jsAst.Statement> parts = <jsAst.Statement>[];
 
     Iterable<FieldEntity> fields = outputStaticNonFinalFieldLists[outputUnit];
     // If the outputUnit does not contain any static non-final fields, then
     // [fields] is `null`.
     if (fields != null) {
@@ skipping 448 matching lines @@
     }
 
     compiler.dumpInfoTask.registerElementAst(library, metadata);
     compiler.dumpInfoTask.registerElementAst(library, initializer);
 
     List<jsAst.Expression> parts = <jsAst.Expression>[];
     parts
       ..add(js.string(libraryName))
       ..add(js.string(uri.toString()))
       ..add(metadata == null ? new jsAst.ArrayHole() : metadata)
-      ..add(js('#', namer.globalObjectFor(library)))
+      ..add(js('#', namer.globalObjectForLibrary(library)))
       ..add(initializer);
     if (library == compiler.mainApp) {
       parts.add(js.number(1));
     }
 
     return new jsAst.ArrayInitializer(parts);
   }
 
   void assemblePrecompiledConstructor(
       OutputUnit outputUnit,
@@ skipping 58 matching lines @@
           embeddedNames.TYPEDEF_TYPE_PROPERTY_NAME, typeIndex);
       builder.addPropertyByName(
           embeddedNames.TYPEDEF_PREDICATE_PROPERTY_NAME, js.boolean(true));
 
       // We can be pretty sure that the objectClass is initialized, since
       // typedefs are only emitted with reflection, which requires lots of
       // classes.
       assert(commonElements.objectClass != null);
       builder.superName = namer.className(commonElements.objectClass);
       jsAst.Node declaration = builder.toObjectInitializer();
-      jsAst.Name mangledName = namer.globalPropertyName(typedef);
+      jsAst.Name mangledName = namer.globalPropertyNameForType(typedef);
       String reflectionName = getReflectionName(typedef, mangledName);
       getLibraryDescriptor(library, mainFragment)
         ..addProperty(mangledName, declaration)
         ..addPropertyByName("+$reflectionName", js.string(''));
       // Also emit a trivial constructor for CSP mode.
       jsAst.Name constructorName = mangledName;
       jsAst.Expression constructorAst = js('function() {}');
       List<jsAst.Name> fieldNames = [];
       assemblePrecompiledConstructor(
           mainOutputUnit, constructorName, constructorAst, fieldNames);
@@ skipping 768 matching lines @@
     // data.
     mapping["_comment"] = "This mapping shows which compiled `.js` files are "
         "needed for a given deferred library import.";
     mapping.addAll(compiler.deferredLoadTask.computeDeferredMap());
     compiler.outputProvider(
         compiler.options.deferredMapUri.path, '', OutputType.info)
       ..add(const JsonEncoder.withIndent("  ").convert(mapping))
       ..close();
   }
 }