Incremental compilation handles indirectly instantiated classes.

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 104 matching lines @@
 
   final List<FailedUpdate> _failedUpdates = <FailedUpdate>[];
 
   final Set<ElementX> _elementsToInvalidate = new Set<ElementX>();
 
   final Set<ElementX> _removedElements = new Set<ElementX>();
 
   final Set<ClassElementX> _classesWithSchemaChanges =
       new Set<ClassElementX>();
 
+  final Set<ClassElementX> _existingClasses = new Set();
+
   LibraryUpdater(
       this.compiler,
       this.inputProvider,
       this.uri,
       this.logTime,
-      this.logVerbose);
+      this.logVerbose) {
+    if (compiler != null) {
+      _existingClasses.addAll(emitter.neededClasses);
+    }
+  }
 
   /// When [true], updates must be applied (using [applyUpdates]) before the
   /// [compiler]'s state correctly reflects the updated program.
   bool get hasPendingUpdates => !updates.isEmpty;
 
   bool get failed => !_failedUpdates.isEmpty;
 
   /// Used as tear-off passed to [LibraryLoaderTask.resetAsync].
   Future<bool> reuseLibrary(LibraryElement library) {
     assert(compiler != null);
@@ skipping 386 matching lines @@
           removals.add(update);
         }
       } else {
         elementsToInvalidate.add(element);
       }
     }
     return elementsToInvalidate;
   }
 
   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) {
       if (!element.isClass) {
         compiler.enqueuer.resolution.addToWorkList(element);
       } else {
         NO_WARN(element).ensureResolved(compiler);
@@ skipping 12 matching lines @@
       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);
+    Set newClasses = new Set.from(
+        compiler.codegenWorld.allInstantiatedClasses.where(
+            emitter.computeClassFilter()));
+    newClasses.removeAll(_existingClasses);
 
     List<jsAst.Statement> inherits = <jsAst.Statement>[];
 
     for (ClassElementX cls in newClasses) {
       jsAst.Node classAccess = emitter.classAccess(cls);
       String name = namer.getNameOfClass(cls);
 
       updates.add(
           js.statement(
               r'# = #', [classAccess, invokeDefineClass(cls)]));
@@ skipping 560 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;