When registering deferred constant, use canonical output unit.

pkg/compiler/lib/src/deferred_load.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 deferred_load;
 
 import 'common/backend_api.dart' show Backend;
 import 'common/tasks.dart' show CompilerTask;
 import 'common.dart';
 import 'compiler.dart' show Compiler;
@@ skipping 204 matching lines @@
   ///
   /// For example, if we have two deferred libraries `A` and `B` that both
   /// import a library `C`, then even though elements from `A` and `C` end up in
   /// different output units, there is a non-deferred path between `A` and `C`.
   bool hasOnlyNonDeferredImportPaths(Element from, Element to) {
     OutputUnit outputUnitFrom = outputUnitForElement(from);
     OutputUnit outputUnitTo = outputUnitForElement(to);
     return outputUnitTo.imports.containsAll(outputUnitFrom.imports);
   }
 
+  // TODO(het): use a union-find to canonicalize output units
+  OutputUnit _getCanonicalUnit(OutputUnit outputUnit) {
+    OutputUnit representative = allOutputUnits.lookup(outputUnit);
+    if (representative == null) {
+      representative = outputUnit;
+      allOutputUnits.add(representative);
+    }
+    return representative;
+  }
+
   void registerConstantDeferredUse(
       DeferredConstantValue constant, PrefixElement prefix) {
     OutputUnit outputUnit = new OutputUnit();
     outputUnit.imports.add(new _DeclaredDeferredImport(prefix.deferredImport));
-    _constantToOutputUnit[constant] = outputUnit;
+
+    // Check to see if there is already a canonical output unit registered.
+    _constantToOutputUnit[constant] = _getCanonicalUnit(outputUnit);
   }
 
   /// Answers whether [element] is explicitly deferred when referred to from
   /// [library].
   bool _isExplicitlyDeferred(Element element, LibraryElement library) {
     Iterable<ImportElement> imports = _getImports(element, library);
     // If the element is not imported explicitly, it is implicitly imported
     // not deferred.
     if (imports.isEmpty) return false;
     // An element could potentially be loaded by several imports. If all of them
@@ skipping 432 matching lines @@
               if (compiler.commonElements.mirrorsLibrary != null) {
                 _addMirrorElements();
               }
 
               // Build the OutputUnits using these two maps.
               Map<Element, OutputUnit> elementToOutputUnitBuilder =
                   new Map<Element, OutputUnit>();
               Map<ConstantValue, OutputUnit> constantToOutputUnitBuilder =
                   new Map<ConstantValue, OutputUnit>();
 
+              // Add all constants that may have been registered during
+              // resolution with [registerConstantDeferredUse].
+              constantToOutputUnitBuilder.addAll(_constantToOutputUnit);
+              _constantToOutputUnit.clear();
+
               // Reverse the mappings. For each element record an OutputUnit
               // collecting all deferred imports mapped to this element. Same
               // for constants.
               for (_DeferredImport import in _importedDeferredBy.keys) {
                 for (Element element in _importedDeferredBy[import]) {
                   // Only one file should be loaded when the program starts, so
                   // make sure that only one OutputUnit is created for
                   // [fakeMainImport].
                   if (import == _fakeMainImport) {
                     elementToOutputUnitBuilder[element] = mainOutputUnit;
@@ skipping 22 matching lines @@
               }
 
               // Release maps;
               _importedDeferredBy = null;
               _constantsDeferredBy = null;
 
               // Find all the output units elements/constants have been mapped
               // to, and canonicalize them.
               elementToOutputUnitBuilder
                   .forEach((Element element, OutputUnit outputUnit) {
-                OutputUnit representative = allOutputUnits.lookup(outputUnit);
-                if (representative == null) {
-                  representative = outputUnit;
-                  allOutputUnits.add(representative);
-                }
-                _elementToOutputUnit[element] = representative;
+                _elementToOutputUnit[element] = _getCanonicalUnit(outputUnit);
               });
               constantToOutputUnitBuilder
                   .forEach((ConstantValue constant, OutputUnit outputUnit) {
-                OutputUnit representative = allOutputUnits.lookup(outputUnit);
-                if (representative == null) {
-                  representative = outputUnit;
-                  allOutputUnits.add(representative);
-                }
-                _constantToOutputUnit[constant] = representative;
+                _constantToOutputUnit[constant] = _getCanonicalUnit(outputUnit);
               });
 
               // Generate a unique name for each OutputUnit.
               _assignNamesToOutputUnits(allOutputUnits);
             }));
     // Notify the impact strategy impacts are no longer needed for deferred
     // load.
     compiler.impactStrategy.onImpactUsed(IMPACT_USE);
   }
 
@@ skipping 287 matching lines @@
 
   bool operator ==(other) {
     if (other is! _DeclaredDeferredImport) return false;
     return declaration == other.declaration;
   }
 
   int get hashCode => declaration.hashCode * 17;
 
   String toString() => '$declaration';
 }