Incremental compilation of 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 57 matching lines @@
     ClassElementX,
     CompilationUnitElementX,
     DeclarationSite,
     ElementX,
     FieldElementX,
     LibraryElementX;
 
 import 'package:compiler/src/universe/universe.dart' show
     Selector;
 
+import 'package:compiler/src/constants/values.dart' show
+    ConstantValue;
+
 import 'diff.dart' show
     Difference,
     computeDifference;
 
 typedef void Logger(message);
 
 typedef bool Reuser(
     Token diffToken,
     PartialElement before,
     PartialElement after);
@@ skipping 34 matching lines @@
 
   final Set<ElementX> _removedElements = new Set<ElementX>();
 
   final Set<ClassElementX> _classesWithSchemaChanges =
       new Set<ClassElementX>();
 
   final Set<ClassElementX> _emittedClasses;
 
   final Set<ClassElementX> _directlyInstantiatedClasses;
 
+  final Set<ConstantValue> _compiledConstants;
+
+  bool _hasComputedNeeds = false;
+
   LibraryUpdater(
       Compiler compiler,
       this.inputProvider,
       this.uri,
       this.logTime,
       this.logVerbose)
       : this.compiler = compiler,
         _emittedClasses = new Set.from(compiler.backend.emitter.neededClasses),
         _directlyInstantiatedClasses = new Set.from(
-            compiler.codegenWorld.directlyInstantiatedClasses);
+            compiler.codegenWorld.directlyInstantiatedClasses),
+        _compiledConstants = new Set<ConstantValue>.identity()..addAll(
+            compiler.backend.constants.compiledConstants);
 
   /// 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 443 matching lines @@
 
     List<jsAst.Statement> updates = <jsAst.Statement>[];
 
     Set<ClassElementX> newClasses = new Set.from(
         compiler.codegenWorld.directlyInstantiatedClasses);
     newClasses.removeAll(_directlyInstantiatedClasses);
 
     if (!newClasses.isEmpty) {
       // Ask the emitter to compute "needs" (only) if new classes were
       // instantiated.
-      emitter.computeNeeds();
+      _ensureNeedsComputed();
       newClasses = new Set.from(emitter.neededClasses);
       newClasses.removeAll(_emittedClasses);
     } else {
       // Make sure that the set of emitted classes is preserved for subsequent
       // updates.
       // TODO(ahe): This is a bit convoluted, find a better approach.
       emitter.neededClasses
           ..clear()
           ..addAll(_emittedClasses);
     }
@@ skipping 38 matching lines @@
       update.writeUpdateJsOn(updates);
     }
     for (Element element in compiler.enqueuer.codegen.newlyEnqueuedElements) {
       if (element.isField) {
         updates.addAll(computeFieldUpdateJs(element));
       } else {
         updates.add(computeMethodUpdateJs(element));
       }
     }
 
+    Set<ConstantValue> newConstants = new Set<ConstantValue>.identity()..addAll(
+        compiler.backend.constants.compiledConstants);
+    newConstants.removeAll(_compiledConstants);
+
+    if (!newConstants.isEmpty) {
+      _ensureNeedsComputed();
+      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();
+            updates.add(constantInitializer);
+          }
+        }
+      }
+    }
+
     updates.add(js.statement(r'''
 if (self.$dart_unsafe_eval.pendingStubs) {
   self.$dart_unsafe_eval.pendingStubs.map(function(e) { return e(); });
   self.$dart_unsafe_eval.pendingStubs = void 0;
 }
 '''));
 
     if (updates.length == 1) {
       return prettyPrintJs(updates.single);
     } else {
@@ skipping 83 matching lines @@
   String callNameFor(FunctionElement element) {
     // TODO(ahe): Call a method in the compiler to obtain this name.
     String callPrefix = namer.callPrefix;
     int parameterCount = element.functionSignature.parameterCount;
     return '$callPrefix\$$parameterCount';
   }
 
   List<String> computeFields(ClassElement cls) {
     return new EmitterHelper(compiler).computeFields(cls);
   }
+
+  void _ensureNeedsComputed() {
+    if (_hasComputedNeeds) return;
+    emitter.computeNeeds();
+    _hasComputedNeeds = true;
+  }
 }
 
 /// Represents an update (aka patch) of [before] to [after]. We use the word
 /// "update" to avoid confusion with the compiler feature of "patch" methods.
 abstract class Update {
   final Compiler compiler;
 
   PartialElement get before;
 
   PartialElement get after;
@@ skipping 463 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;