Incremental compilation of added class.

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 210 matching lines @@
 
     return _failedUpdates.isEmpty;
   }
 
   bool canReuseAddedElement(
       PartialElement element,
       ScopeContainerElement container) {
     if (element is PartialFunctionElement) {
       addFunction(element, container);
       return true;
+    } else if (element is PartialClassElement) {
+      addClass(element, container);
+      return true;
     }
     return cannotReuse(element, "Added element that isn't a function.");
   }
 
   void addFunction(
       PartialFunctionElement element,
       ScopeContainerElement container) {
     invalidateScopesAffectedBy(element, container);
 
     updates.add(new AddedFunctionUpdate(compiler, element, container));
   }
 
+  void addClass(
+      PartialClassElement element,
+      LibraryElementX library) {
+    invalidateScopesAffectedBy(element, library);
+
+    updates.add(new AddedClassUpdate(compiler, element, library));
+  }
+
   bool canReuseRemovedElement(PartialElement element) {
     if (element is PartialFunctionElement) {
       removeFunction(element);
       return true;
     }
     return cannotReuse(element, "Removed element that isn't a function.");
   }
 
   void removeFunction(PartialFunctionElement element) {
     logVerbose("Removed method $element.");
@@ skipping 157 matching lines @@
   String computeUpdateJs() {
     Set existingClasses =
         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) {
-      compiler.enqueuer.resolution.addToWorkList(element);
+      if (!element.isClass) {
+        compiler.enqueuer.resolution.addToWorkList(element);
+      }
     }
     compiler.processQueue(compiler.enqueuer.resolution, null);
 
     compiler.phase = Compiler.PHASE_DONE_RESOLVING;
 
     for (Element element in updatedElements) {
-      compiler.enqueuer.codegen.addToWorkList(element);
+      if (!element.isClass) {
+        compiler.enqueuer.codegen.addToWorkList(element);
+      }
     }
     compiler.processQueue(compiler.enqueuer.codegen, null);
 
     List<jsAst.Statement> updates = <jsAst.Statement>[];
 
     Set newClasses =
         new Set.from(compiler.codegenWorld.directlyInstantiatedClasses);
     newClasses.removeAll(existingClasses);
 
     List<jsAst.Statement> inherits = <jsAst.Statement>[];
@@ skipping 206 matching lines @@
   }
 
   PartialFunctionElement apply() {
     if (!wasStateCaptured) throw "captureState must be called before apply.";
     removeFromEnclosing();
     reuseElement();
     return null;
   }
 
   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) {
       removeFromLibrary(element.library);
     } else {
       removeFromEnclosingClass(cls);
     }
   }
 
   void removeFromEnclosingClass(PartialClassElement cls) {
     cls.localMembersCache = null;
@@ skipping 49 matching lines @@
 
   AddedFunctionUpdate(Compiler compiler, this.element, this.container)
       : super(compiler) {
     if (container == null) {
       throw "container is null";
     }
   }
 
   PartialFunctionElement get before => null;
 
-  PartialElement get after => element;
+  PartialFunctionElement get after => element;
 
   PartialFunctionElement apply() {
     Element enclosing = container;
     if (enclosing.isLibrary) {
-      // TODO(ahe): Reuse compilation unit instead?
+      // TODO(ahe): Reuse compilation unit of element instead?
       enclosing = enclosing.compilationUnit;
     }
     PartialFunctionElement copy = element.copyWithEnclosing(enclosing);
     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)
+      : super(compiler);
+
+  PartialClassElement get before => null;
+
+  PartialClassElement get after => element;
+
+  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;
+  }
+}
+
 /// 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;
   }
 }