Move elementAccess() from namer to emitter.

pkg/dart2js_incremental/lib/library_updater.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_incremental.library_updater;
 
 import 'dart:async' show
     Future;
 
 import 'dart:convert' show
@@ skipping 558 matching lines @@
 
     List<jsAst.Statement> updates = <jsAst.Statement>[];
 
     Set newClasses =
         new Set.from(compiler.codegenWorld.directlyInstantiatedClasses);
     newClasses.removeAll(existingClasses);
 
     List<jsAst.Statement> inherits = <jsAst.Statement>[];
 
     for (ClassElementX cls in newClasses) {
-      jsAst.Node classAccess = namer.elementAccess(cls);
+      jsAst.Node classAccess = emitter.classAccess(cls);
       String name = namer.getNameOfClass(cls);
 
       updates.add(
           js.statement(
               r'# = #', [classAccess, invokeDefineClass(cls)]));
 
       ClassElement superclass = cls.superclass;
       if (superclass != null) {
-        jsAst.Node superAccess = namer.elementAccess(superclass);
+        jsAst.Node superAccess = emitter.classAccess(superclass);
         inherits.add(
             js.statement(
                 r'self.$dart_unsafe_eval.inheritFrom(#, #)',
                 [classAccess, superAccess]));
       }
     }
 
     // Call inheritFrom after all classes have been created. This way we don't
     // need to sort the classes by having superclasses defined before their
     // subclasses.
     updates.addAll(inherits);
 
     for (ClassElementX cls in changedClasses) {
       ClassElement superclass = cls.superclass;
       jsAst.Node superAccess =
-          superclass == null ? js('null') : namer.elementAccess(superclass);
-      jsAst.Node classAccess = namer.elementAccess(cls);
+          superclass == null ? js('null')
+              : emitter.classAccess(superclass);
+      jsAst.Node classAccess = emitter.classAccess(cls);
       updates.add(
           js.statement(
               r'# = self.$dart_unsafe_eval.schemaChange(#, #, #)',
               [classAccess, invokeDefineClass(cls), classAccess, superAccess]));
     }
 
     for (RemovalUpdate update in removals) {
       update.writeUpdateJsOn(updates);
     }
     for (Element element in compiler.enqueuer.codegen.newlyEnqueuedElements) {
@@ skipping 34 matching lines @@
 
     String name = info.name;
     jsAst.Node function = info.code;
     bool isStatic = !element.isInstanceMember;
 
     /// Either a global object (non-instance members) or a prototype (instance
     /// members).
     jsAst.Node holder;
 
     if (element.isInstanceMember) {
-      holder = js('#.prototype', namer.elementAccess(element.enclosingClass));
+      holder = js('#.prototype', emitter.classAccess(element.enclosingClass));
     } else {
       holder = js('#', namer.globalObjectFor(element));
     }
 
     jsAst.Expression globalFunctionsAccess =
         emitter.generateEmbeddedGlobalAccess(embeddedNames.GLOBAL_FUNCTIONS);
 
     return js.statement(
         r'self.$dart_unsafe_eval.addMethod(#, #, #, #, #)',
         [partialDescriptor, js.string(name), holder,
@@ skipping 128 matching lines @@
 
   PartialFunctionElement get before => element;
 
   PartialFunctionElement get after => null;
 
   void captureState() {
     if (wasStateCaptured) throw "captureState was called twice.";
     wasStateCaptured = true;
 
     if (element.isInstanceMember) {
-      elementAccess = namer.elementAccess(element.enclosingClass);
+      elementAccess = emitter.classAccess(element.enclosingClass);
       name = namer.getNameOfMember(element);
     } else {
-      elementAccess = namer.elementAccess(element);
+      elementAccess = emitter.staticFunctionAccess(element);
     }
   }
 
   PartialFunctionElement apply() {
     if (!wasStateCaptured) throw "captureState must be called before apply.";
     removeFromEnclosing();
     reuseElement();
     return null;
   }
 
@@ skipping 24 matching lines @@
   RemovedClassUpdate(Compiler compiler, this.element)
       : super(compiler);
 
   PartialClassElement get before => element;
 
   PartialClassElement get after => null;
 
   void captureState() {
     if (wasStateCaptured) throw "captureState was called twice.";
     wasStateCaptured = true;
-
-    accessToStatics.add(namer.elementAccess(element));
+    accessToStatics.add(emitter.classAccess(element));
 
     element.forEachLocalMember((ElementX member) {
       if (!member.isInstanceMember) {
-        accessToStatics.add(namer.elementAccess(member));
+        accessToStatics.add(emitter.staticFunctionAccess(member));
       }
     });
   }
 
   PartialClassElement apply() {
     if (!wasStateCaptured) {
       throw new StateError("captureState must be called before apply.");
     }
 
     removeFromEnclosing();
@@ skipping 36 matching lines @@
       : super(compiler);
 
   PartialFieldList get before => element.declarationSite;
 
   PartialFieldList get after => null;
 
   void captureState() {
     if (wasStateCaptured) throw "captureState was called twice.";
     wasStateCaptured = true;
 
-    elementAccess = namer.elementAccess(element.enclosingClass);
+    elementAccess = emitter.classAccess(element.enclosingClass);
     getterName = namer.getterName(element);
     setterName = namer.setterName(element);
   }
 
   FieldElementX apply() {
     if (!wasStateCaptured) {
       throw new StateError("captureState must be called before apply.");
     }
 
     removeFromEnclosing();
@@ skipping 215 matching lines @@
   List<String> computeFields(ClassElement cls) {
     // TODO(ahe): Rewrite for new emitter.
     ClassBuilder builder = new ClassBuilder(cls, namer);
     classEmitter.emitFields(cls, builder, "");
     return builder.fields;
   }
 }
 
 // TODO(ahe): Remove this method.
 NO_WARN(x) => x;