Incremental compilation of superclass change.

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
     UTF8;
 
 import 'package:compiler/compiler.dart' as api;
 
 import 'package:compiler/src/dart2jslib.dart' show
     Compiler,
     Script;
 
 import 'package:compiler/src/elements/elements.dart' show
     ClassElement,
     Element,
     FunctionElement,
     LibraryElement,
+    STATE_NOT_STARTED,
     ScopeContainerElement;
 
 import 'package:compiler/src/scanner/scannerlib.dart' show
     EOF_TOKEN,
     PartialClassElement,
     PartialElement,
     PartialFunctionElement,
     Token;
 
 import 'package:compiler/src/source_file.dart' show
@@ skipping 332 matching lines @@
       PartialClassElement after) {
     ClassNode node = after.parseNode(compiler).asClassNode();
     if (node == null) {
       return cannotReuse(after, "Not a ClassNode: '$node'");
     }
     NodeList body = node.body;
     if (body == null) {
       return cannotReuse(after, "Class has no body.");
     }
     if (isTokenBetween(diffToken, node.beginToken, body.beginToken)) {
-      return cannotReuse(after, "Class header changed.");
+      logVerbose('Class header modified in ${after}');
+      updates.add(new ClassUpdate(compiler, before, after));
+      before.forEachLocalMember((ElementX member) {
+        // TODO(ahe): Quadratic.
+        invalidateScopesAffectedBy(member, before);
+      });
     }
-    logVerbose('Simple modification of ${after} detected');
     return canReuseScopeContainerElement(before, after);
   }
 
   bool isTokenBetween(Token token, Token first, Token last) {
     Token current = first;
     while (current != last && current.kind != EOF_TOKEN) {
       if (current == token) {
         return true;
       }
       current = current.next;
@@ skipping 50 matching lines @@
         new Set.from(compiler.codegenWorld.directlyInstantiatedClasses);
 
     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);
       }
     }
     compiler.processQueue(compiler.enqueuer.resolution, null);
 
     compiler.phase = Compiler.PHASE_DONE_RESOLVING;
 
+    Set<PartialClassElement> changedClasses = new Set<PartialClassElement>();
     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>[];
 
     Set newClasses =
         new Set.from(compiler.codegenWorld.directlyInstantiatedClasses);
     newClasses.removeAll(existingClasses);
 
@@ skipping 23 matching lines @@
         jsAst.Node superAccess = namer.elementAccess(superclass);
         inherits.add(
             js.statement(
                 r'self.$dart_unsafe_eval.inheritFrom(#, #)',
                 [classAccess, superAccess]));
       }
     }
 
     updates.addAll(inherits);
 
+    for (ClassElementX cls in changedClasses) {
+      ClassElement superclass = cls.superclass;
+      if (superclass != null) {
+        jsAst.Node classAccess = namer.elementAccess(cls);
+        jsAst.Node superAccess = namer.elementAccess(superclass);
+        updates.add(
+            js.statement(
+                r'#.prototype.__proto__ = #.prototype',
+                [classAccess, superAccess]));
+        updates.add(
+            js.statement(
+                r'#.prototype.constructor = #',
+                [classAccess, classAccess]));
+      }
+    }
+
     for (RemovedFunctionUpdate 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) {
@@ skipping 339 matching lines @@
 
   PartialFunctionElement apply() {
     // TODO(ahe): Reuse compilation unit of element instead?
     CompilationUnitElementX compilationUnit = library.compilationUnit;
     PartialClassElement copy = element.copyWithEnclosing(compilationUnit);
     compilationUnit.addMember(copy, compiler);
     return copy;
   }
 }
 
+class ClassUpdate extends Update with JsFeatures {
+  final PartialClassElement before;
+
+  final PartialClassElement after;
+
+  ClassUpdate(Compiler compiler, this.before, this.after)
+      : super(compiler);
+
+  PartialFunctionElement 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;
+  }
+
+  void reuseElement() {
+    before.supertype = null;
+    before.interfaces = null;
+    before.nativeTagInfo = null;
+    before.supertypeLoadState = STATE_NOT_STARTED;
+    before.resolutionState = STATE_NOT_STARTED;
+    before.isProxy = false;
+    before.hasIncompleteHierarchy = false;
+    before.backendMembers = const Link<Element>();
+    before.allSupertypesAndSelf = null;
+  }
+}
+
 /// Returns all qualified names in [element] with less than four identifiers. A
 /// qualified name is an identifier followed by a sequence of dots and
 /// identifiers, for example, "x", and "x.y.z". But not "x.y.z.w" ("w" is the
 /// fourth identifier).
 ///
 /// The longest possible name that can be resolved is three identifiers, for
 /// example, "prefix.MyClass.staticMethod". Since four or more identifiers
 /// cannot resolve to anything statically, they're not included in the returned
 /// value of this method.
 Set<String> qualifiedNamesIn(PartialElement element) {
@@ skipping 80 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;
   }
 }