Checked mode fixes.

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 50 matching lines @@
 
 import 'package:compiler/src/util/util.dart' show
     Link,
     LinkBuilder;
 
 import 'package:compiler/src/elements/modelx.dart' show
     ClassElementX,
     CompilationUnitElementX,
     DeclarationSite,
     ElementX,
+    FieldElementX,
     LibraryElementX;
 
 import 'diff.dart' show
     Difference,
     computeDifference;
 
 typedef void Logger(message);
 
 typedef bool Reuser(
     Token diffToken,
@@ skipping 422 matching lines @@
         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<PartialClassElement> changedClasses =
-        new Set<PartialClassElement>.from(_classesWithSchemaChanges);
+    Set<ClassElementX> changedClasses =
+        new Set<ClassElementX>.from(_classesWithSchemaChanges);
     for (Element element in updatedElements) {
       if (!element.isClass) {
         compiler.enqueuer.codegen.addToWorkList(element);
       } else {
         changedClasses.add(element);
       }
     }
     compiler.processQueue(compiler.enqueuer.codegen, null);
 
     List<jsAst.Statement> updates = <jsAst.Statement>[];
@@ skipping 31 matching lines @@
       ClassElement superclass = cls.superclass;
       jsAst.Node superAccess =
           superclass == null ? js('null') : namer.elementAccess(superclass);
       jsAst.Node classAccess = namer.elementAccess(cls);
       updates.add(
           js.statement(
               r'# = self.$dart_unsafe_eval.schemaChange(#, #, #)',
               [classAccess, invokeDefineClass(cls), classAccess, superAccess]));
     }
 
-    for (RemovedFunctionUpdate update in removals) {
+    for (RemovalUpdate update in removals) {
       update.writeUpdateJsOn(updates);
     }
     for (Element element in compiler.enqueuer.codegen.newlyEnqueuedElements) {
       if (!element.isField) {
         updates.add(computeMemberUpdateJs(element));
       }
     }
 
     if (updates.length == 1) {
       return prettyPrintJs(updates.single);
@@ skipping 141 matching lines @@
       : super(compiler);
 
   bool get isRemoval => true;
 
   void writeUpdateJsOn(List<jsAst.Statement> updates);
 
   void removeFromEnclosing() {
     // TODO(ahe): Need to recompute duplicated elements logic again. Simplest
     // solution is probably to remove all elements from enclosing scope and add
     // them back.
-    PartialClassElement cls = element.enclosingClass;
-    if (cls == null) {
+    if (element.isTopLevel) {
       removeFromLibrary(element.library);
     } else {
-      removeFromEnclosingClass(cls);
+      removeFromEnclosingClass(element.enclosingClass);
     }
   }
 
   void removeFromEnclosingClass(PartialClassElement cls) {
     cls.localMembersCache = null;
-    cls.localMembersReversed =
-        copyLinkWithout(element, cls.localMembersReversed);
+    cls.localMembersReversed = cls.localMembersReversed.copyWithout(element);
     cls.localScope.contents.remove(element.name);
   }
 
   void removeFromLibrary(LibraryElementX library) {
-    library.localMembers = copyLinkWithout(element, library.localMembers);
+    library.localMembers = library.localMembers.copyWithout(element);
     library.localScope.contents.remove(element.name);
   }
-
-  Link copyLinkWithout(e, Link link) {
-    // TODO(ahe): Consider adding to [Link].
-    LinkBuilder copy = new LinkBuilder();
-
-    for (; !link.isEmpty; link = link.tail) {
-      if (link.head != e) {
-        copy.addLast(e);
-      }
-    }
-
-    return copy.toLink(link);
-  }
 }
 
 class RemovedFunctionUpdate extends RemovalUpdate
     with JsFeatures, ReuseFunction {
   final PartialFunctionElement element;
 
   /// Name of property to remove using JavaScript "delete". Null for
   /// non-instance methods.
   String name;
 
@@ skipping 87 matching lines @@
   }
 
   PartialClassElement apply() {
     if (!wasStateCaptured) {
       throw new StateError("captureState must be called before apply.");
     }
 
     removeFromEnclosing();
 
     element.forEachLocalMember((ElementX member) {
-      compiler.forgetElement(before);
+      compiler.forgetElement(member);
       member.reuseElement();
     });
 
     compiler.forgetElement(element);
     element.reuseElement();
 
     return null;
   }
 
   void writeUpdateJsOn(List<jsAst.Statement> updates) {
@@ skipping 78 matching lines @@
 
 
 class ClassUpdate extends Update with JsFeatures {
   final PartialClassElement before;
 
   final PartialClassElement after;
 
   ClassUpdate(Compiler compiler, this.before, this.after)
       : super(compiler);
 
-  PartialFunctionElement apply() {
+  PartialClassElement apply() {
     patchElement();
     reuseElement();
     return before;
   }
 
   /// Destructively change the tokens in [before] to match those of [after].
   void patchElement() {
     before.cachedNode = after.cachedNode;
     before.beginToken = after.beginToken;
     before.endToken = after.endToken;
@@ skipping 105 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;
   }
 }