Use serialized scope info to test incremental compiler.

dart/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 527 matching lines @@
 
     List<Update> removals = <Update>[];
     List<Element> updatedElements = applyUpdates(removals);
     if (compiler.progress != null) {
       compiler.progress.reset();
     }
     for (Element element in updatedElements) {
       if (!element.isClass) {
         compiler.enqueuer.resolution.addToWorkList(element);
       } else {
-        element.ensureResolved(compiler);
+        NO_WARN(element).ensureResolved(compiler);
       }
     }
     compiler.processQueue(compiler.enqueuer.resolution, null);
 
     compiler.phase = Compiler.PHASE_DONE_RESOLVING;
 
     // TODO(ahe): Clean this up. Don't call this method in analyze-only mode.
     if (compiler.analyzeOnly) return "/* analyze only */";
 
     Set<ClassElementX> changedClasses =
@@ skipping 190 matching lines @@
   PartialFunctionElement get before;
 
   /// Reset various caches and remove this element from the compiler's internal
   /// state.
   void reuseElement() {
     compiler.forgetElement(before);
     before.reuseElement();
   }
 }
 
-class RemovalUpdate extends Update {
+abstract class RemovalUpdate extends Update {
   ElementX get element;
 
   RemovalUpdate(Compiler compiler)
       : super(compiler);
 
   bool get isRemoval => true;
 
   void writeUpdateJsOn(List<jsAst.Statement> updates);
 
   void removeFromEnclosing() {
@@ skipping 142 matching lines @@
 
     for (jsAst.Node access in accessToStatics) {
       updates.add(js.statement('delete #', [access]));
     }
   }
 }
 
 class RemovedFieldUpdate extends RemovalUpdate with JsFeatures {
   final FieldElementX element;
 
-  bool wasStateCaptured;
+  bool wasStateCaptured = false;
 
   jsAst.Node elementAccess;
 
   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 = namer.elementAccess(element.enclosingClass);
     getterName = namer.getterName(element);
     setterName = namer.setterName(element);
   }
 
   FieldElementX apply() {
@@ skipping 35 matching lines @@
 
   PartialFunctionElement get after => element;
 
   PartialFunctionElement apply() {
     Element enclosing = container;
     if (enclosing.isLibrary) {
       // TODO(ahe): Reuse compilation unit of element instead?
       enclosing = enclosing.compilationUnit;
     }
     PartialFunctionElement copy = element.copyWithEnclosing(enclosing);
-    container.addMember(copy, compiler);
+    NO_WARN(container).addMember(copy, compiler);
     return copy;
   }
 }
 
 class AddedClassUpdate extends Update with JsFeatures {
   final PartialClassElement element;
 
   final LibraryElementX library;
 
   AddedClassUpdate(Compiler compiler, this.element, this.library)
@@ skipping 19 matching lines @@
 
   AddedFieldUpdate(Compiler compiler, this.element, this.container)
       : super(compiler);
 
   PartialFieldList get before => null;
 
   PartialFieldList get after => element.declarationSite;
 
   FieldElementX apply() {
     FieldElementX copy = element.copyWithEnclosing(container);
-    container.addMember(copy, compiler);
+    NO_WARN(container).addMember(copy, compiler);
     return copy;
   }
 }
 
 
 class ClassUpdate extends Update with JsFeatures {
   final PartialClassElement before;
 
   final PartialClassElement after;
 
@@ skipping 119 matching lines @@
 
   ClassEmitter get classEmitter => backend.emitter.oldEmitter.classEmitter;
 
   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;