Incremental compilation: correctly track emitted constants.

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 126 matching lines @@
 
   bool _hasComputedNeeds = false;
 
   LibraryUpdater(
       Compiler compiler,
       this.inputProvider,
       this.uri,
       this.logTime,
       this.logVerbose)
       : this.compiler = compiler,
-        _emittedClasses = new Set.from(
-            compiler == null
-                ? [] : compiler.backend.emitter.neededClasses),
-        _directlyInstantiatedClasses = new Set.from(
-            compiler == null
-                ? [] : compiler.codegenWorld.directlyInstantiatedClasses),
-        _compiledConstants = new Set<ConstantValue>.identity()..addAll(
-            compiler == null
-                ? [] : compiler.backend.constants.compiledConstants);
+        _emittedClasses = _getEmittedClasses(compiler),
+        _directlyInstantiatedClasses =
+            _getDirectlyInstantiatedClasses(compiler),
+        _compiledConstants = _getEmittedConstants(compiler);
+
+  /// Returns the classes emitted by [compiler].
+  static Set<ClassElementX> _getEmittedClasses(Compiler compiler) {
+    if (compiler == null) return null;
+    return new Set.from(compiler.backend.emitter.neededClasses);
+  }
+
+  /// Returns the directly instantantiated classes seen by [compiler].
+  static Set<ClassElementX> _getDirectlyInstantiatedClasses(Compiler compiler) {
+    if (compiler == null) return null;
+    return new Set.from(compiler.codegenWorld.directlyInstantiatedClasses);
+  }
+
+  /// Returns the constants emitted by [compiler].
+  static Set<ConstantValue> _getEmittedConstants(Compiler compiler) {
+    if (compiler != null) {
+      List<ConstantValue> constants =
+          compiler.backend.emitter.outputConstantLists[
+              compiler.deferredLoadTask.mainOutputUnit];
+      if (constants != null) {
+        return new Set<ConstantValue>.identity()..addAll(constants);
+      }
+    }
+    return null;
+  }
 
   /// 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 515 matching lines @@
     Set<ConstantValue> newConstants = new Set<ConstantValue>.identity()..addAll(
         compiler.backend.constants.compiledConstants);
     newConstants.removeAll(_compiledConstants);
 
     if (!newConstants.isEmpty) {
       _ensureAllNeededEntitiesComputed();
       List<ConstantValue> constants =
           emitter.outputConstantLists[compiler.deferredLoadTask.mainOutputUnit];
       if (constants != null) {
         for (ConstantValue constant in constants) {
-          if (newConstants.contains(constant)) {
-            jsAst.Statement constantInitializer = emitter.oldEmitter
-                .buildConstantInitializer(constant).toStatement();
+          if (!_compiledConstants.contains(constant)) {
+            jsAst.Statement constantInitializer =
+                emitter.oldEmitter.buildConstantInitializer(constant)
+                .toStatement();
             updates.add(constantInitializer);
           }
         }
       }
     }
 
     updates.add(js.statement(r'''
 if (#helper.pendingStubs) {
   #helper.pendingStubs.map(function(e) { return e(); });
   #helper.pendingStubs = void 0;
@@ skipping 570 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;