Move elementAccess() from namer to emitter.

pkg/compiler/lib/src/js_emitter/old_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.
 
 part of dart2js.js_emitter;
 
 
 class OldEmitter implements Emitter {
   final Compiler compiler;
   final CodeEmitterTask task;
@@ skipping 163 matching lines @@
 
   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) {
+    String name = namer.getNameX(element);
+    jsAst.PropertyAccess pa = new jsAst.PropertyAccess.field(
+        new jsAst.VariableUse(namer.globalObjectFor(element)),
+        name);
+    return pa;
+  }
+  
+  jsAst.PropertyAccess staticFieldAccess(Element element) {
+      return globalPropertyAccess(element);
+  }
+  
+  jsAst.PropertyAccess staticFunctionAccess(Element element) {
+      return globalPropertyAccess(element);
+  }
+    
+  jsAst.PropertyAccess classAccess(Element element) {
+        return globalPropertyAccess(element);
+  }
+  
+  jsAst.PropertyAccess typedefAccess(Element element) {
+       return globalPropertyAccess(element);
+  }
+
   jsAst.FunctionDeclaration get generateAccessorFunction {
     const RANGE1_SIZE = RANGE1_LAST - RANGE1_FIRST + 1;
     const RANGE2_SIZE = RANGE2_LAST - RANGE2_FIRST + 1;
     const RANGE1_ADJUST = - (FIRST_FIELD_CODE - RANGE1_FIRST);
     const RANGE2_ADJUST = - (FIRST_FIELD_CODE + RANGE1_SIZE - RANGE2_FIRST);
     const RANGE3_ADJUST =
         - (FIRST_FIELD_CODE + RANGE1_SIZE + RANGE2_SIZE - RANGE3_FIRST);
 
     String receiverParamName = compiler.enableMinification ? "r" : "receiver";
     String valueParamName = compiler.enableMinification ? "v" : "value";
@@ skipping 445 matching lines @@
       }''',
         [namer.isolatePropertiesName, namer.isolatePropertiesName,
          needsDefineClass, finishClassesProperty, finishClassesProperty,
          task.outputContainsConstantList,
          makeConstListProperty, makeConstListProperty ]);
   }
 
   jsAst.Fun get lazyInitializerFunction {
     String isolate = namer.currentIsolate;
     jsAst.Expression cyclicThrow =
-        namer.elementAccess(backend.getCyclicThrowHelper());
+        staticFunctionAccess(backend.getCyclicThrowHelper());
     jsAst.Expression laziesAccess =
         generateEmbeddedGlobalAccess(embeddedNames.LAZIES);
 
     return js('''
       function (prototype, staticName, fieldName, getterName, lazyValue) {
         if (!#) # = Object.create(null);
         #[fieldName] = getterName;
 
         var sentinelUndefined = {};
         var sentinelInProgress = {};
@@ skipping 376 matching lines @@
   }
 
   /// Returns the code equivalent to:
   ///   `function(args) { $.startRootIsolate(X.main$closure(), args); }`
   jsAst.Expression buildIsolateSetupClosure(Element appMain,
                                             Element isolateMain) {
     jsAst.Expression mainAccess = namer.isolateStaticClosureAccess(appMain);
     // Since we pass the closurized version of the main method to
     // the isolate method, we must make sure that it exists.
     return js('function(a){ #(#, a); }',
-        [namer.elementAccess(isolateMain), mainAccess]);
+        [backend.emitter.staticFunctionAccess(isolateMain), mainAccess]);
   }
 
   /**
    * Emits code that sets the `isolateTag embedded global to a unique string.
    */
   jsAst.Expression generateIsolateAffinityTagInitialization() {
     jsAst.Expression getIsolateTagAccess =
         generateEmbeddedGlobalAccess(embeddedNames.GET_ISOLATE_TAG);
     jsAst.Expression isolateTagAccess =
         generateEmbeddedGlobalAccess(embeddedNames.ISOLATE_TAG);
@@ skipping 51 matching lines @@
 
   emitMain(CodeBuffer buffer) {
     if (compiler.isMockCompilation) return;
     Element main = compiler.mainFunction;
     jsAst.Expression mainCallClosure = null;
     if (compiler.hasIsolateSupport) {
       Element isolateMain =
         backend.isolateHelperLibrary.find(JavaScriptBackend.START_ROOT_ISOLATE);
       mainCallClosure = buildIsolateSetupClosure(main, isolateMain);
     } else if (compiler.hasIncrementalSupport) {
-      mainCallClosure =
-          js('function() { return #(); }', namer.elementAccess(main));
+      mainCallClosure = js(
+          'function() { return #(); }',
+          backend.emitter.staticFunctionAccess(main));
     } else {
-      mainCallClosure = namer.elementAccess(main);
+      mainCallClosure = backend.emitter.staticFunctionAccess(main);
     }
 
     if (backend.needToInitializeIsolateAffinityTag) {
       buffer.write(
           jsAst.prettyPrint(generateIsolateAffinityTagInitialization(),
                             compiler, monitor: compiler.dumpInfoTask));
       buffer.write(N);
     }
     if (backend.needToInitializeDispatchProperty) {
       assert(backend.needToInitializeIsolateAffinityTag);
@@ skipping 936 matching lines @@
     for (Element element in compiler.enqueuer.codegen.newlyEnqueuedElements) {
       if (element.isInstanceMember) {
         cachedClassBuilders.remove(element.enclosingClass);
 
         nativeEmitter.cachedBuilders.remove(element.enclosingClass);
 
       }
     }
   }
 }