dart2js: Fix incremental compilation.

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 814 matching lines @@
       // updates.
       // TODO(ahe): This is a bit convoluted, find a better approach.
       emitter.neededClasses
           ..clear()
           ..addAll(_emittedClasses);
     }
 
     List<jsAst.Statement> inherits = <jsAst.Statement>[];
 
     for (ClassElementX cls in newClasses) {
-      jsAst.Node classAccess = emitter.classAccess(cls);
+      jsAst.Node classAccess = emitter.constructorAccess(cls);
       String name = namer.getNameOfClass(cls);
 
       updates.add(
           js.statement(
               r'# = #', [classAccess, invokeDefineClass(cls)]));
 
       ClassElement superclass = cls.superclass;
       if (superclass != null) {
-        jsAst.Node superAccess = emitter.classAccess(superclass);
+        jsAst.Node superAccess = emitter.constructorAccess(superclass);
         inherits.add(
             js.statement(
                 r'#.inheritFrom(#, #)', [helper, 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')
-              : emitter.classAccess(superclass);
-      jsAst.Node classAccess = emitter.classAccess(cls);
+              : emitter.constructorAccess(superclass);
+      jsAst.Node classAccess = emitter.constructorAccess(cls);
       updates.add(
           js.statement(
               r'# = #.schemaChange(#, #, #)',
               [classAccess, helper,
                invokeDefineClass(cls), classAccess, superAccess]));
     }
 
     for (RemovalUpdate update in removals) {
       update.writeUpdateJsOn(updates);
     }
@@ skipping 66 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', emitter.classAccess(element.enclosingClass));
+      holder = emitter.prototypeAccess(element.enclosingClass);
     } else {
       holder = js('#', namer.globalObjectFor(element));
     }
 
     jsAst.Expression globalFunctionsAccess =
         emitter.generateEmbeddedGlobalAccess(embeddedNames.GLOBAL_FUNCTIONS);
 
     return js.statement(
         r'#.addMethod(#, #, #, #, #)',
         [helper, partialDescriptor, js.string(name), holder,
@@ skipping 161 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 = emitter.classAccess(element.enclosingClass);
+      elementAccess = emitter.constructorAccess(element.enclosingClass);
       name = namer.getNameOfMember(element);
     } else {
       elementAccess = emitter.staticFunctionAccess(element);
     }
   }
 
   PartialFunctionElement apply() {
     if (!wasStateCaptured) throw "captureState must be called before apply.";
     removeFromEnclosing();
     reuseElement();
@@ skipping 27 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(emitter.classAccess(element));
+    accessToStatics.add(emitter.constructorAccess(element));
 
     element.forEachLocalMember((ElementX member) {
       if (!member.isInstanceMember) {
         accessToStatics.add(emitter.staticFunctionAccess(member));
       }
     });
   }
 
   PartialClassElement apply() {
     if (!wasStateCaptured) {
@@ skipping 23 matching lines @@
       updates.add(js.statement('delete #', [access]));
     }
   }
 }
 
 class RemovedFieldUpdate extends RemovalUpdate with JsFeatures {
   final FieldElementX element;
 
   bool wasStateCaptured = false;
 
-  jsAst.Node elementAccess;
+  jsAst.Node prototypeAccess;
 
   String getterName;
 
   String setterName;
 
   RemovedFieldUpdate(Compiler compiler, this.element)
       : super(compiler);
 
   PartialFieldList get before => element.declarationSite;
 
   PartialFieldList get after => null;
 
   void captureState() {
     if (wasStateCaptured) throw "captureState was called twice.";
     wasStateCaptured = true;
 
-    elementAccess = emitter.classAccess(element.enclosingClass);
+    prototypeAccess = emitter.prototypeAccess(element.enclosingClass);
     getterName = namer.getterName(element);
     setterName = namer.setterName(element);
   }
 
   FieldElementX apply() {
     if (!wasStateCaptured) {
       throw new StateError("captureState must be called before apply.");
     }
 
     removeFromEnclosing();
 
     return element;
   }
 
   void writeUpdateJsOn(List<jsAst.Statement> updates) {
     if (!wasStateCaptured) {
       throw new StateError(
           "captureState must be called before writeUpdateJsOn.");
     }
 
     updates.add(
-        js.statement('delete #.prototype.#', [elementAccess, getterName]));
+        js.statement('delete #.prototype.#', [prototypeAccess, getterName]));
     updates.add(
-        js.statement('delete #.prototype.#', [elementAccess, setterName]));
+        js.statement('delete #.prototype.#', [prototypeAccess, setterName]));
   }
 }
 
 class AddedFunctionUpdate extends Update with JsFeatures {
   final PartialFunctionElement element;
 
   final /* ScopeContainerElement */ container;
 
   AddedFunctionUpdate(Compiler compiler, this.element, this.container)
       : super(compiler) {
@@ skipping 200 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;