Allow use of deferred type-literals in non-constant contexts.

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 'constants/expressions.dart';
 import 'constants/values.dart' show
     ConstantValue,
     ConstructedConstantValue,
@@ skipping 176 matching lines @@
         break;
       }
       element = element.enclosingElement.implementation;
     }
     return _elementToOutputUnit[element];
   }
 
   /// Returns the [OutputUnit] where [constant] belongs.
   OutputUnit outputUnitForConstant(ConstantValue constant) {
     if (!isProgramSplit) return mainOutputUnit;
-
     return _constantToOutputUnit[constant];
   }
 
   bool isDeferred(Element element) {
     return outputUnitForElement(element) != mainOutputUnit;
   }
 
   /// Returns true if e1 and e2 are in the same output unit.
   bool inSameOutputUnit(Element e1, Element e2) {
     return outputUnitForElement(e1) == outputUnitForElement(e2);
@@ skipping 34 matching lines @@
   /// Finds all elements and constants that [element] depends directly on.
   /// (not the transitive closure.)
   ///
   /// Adds the results to [elements] and [constants].
   void _collectAllElementsAndConstantsResolvedFrom(
       Element element,
       Set<Element> elements,
       Set<ConstantValue> constants,
       isMirrorUsage) {
 
-    /// Recursively add the constant and its dependencies to [constants].
-    void addConstants(ConstantValue constant) {
-      if (constants.contains(constant)) return;
-      constants.add(constant);
-      if (constant is ConstructedConstantValue) {
-        elements.add(constant.type.element);
-      }
-      constant.getDependencies().forEach(addConstants);
-    }
-
     /// Collects all direct dependencies of [element].
     ///
     /// The collected dependent elements and constants are are added to
     /// [elements] and [constants] respectively.
     void collectDependencies(Element element) {
       // TODO(johnniwinther): Remove this when [AbstractFieldElement] has been
       // removed.
       if (element is! AstElement) return;
       AstElement astElement = element;
 
@@ skipping 10 matching lines @@
 
       for (Element dependency in treeElements.allElements) {
         if (dependency.isLocal && !dependency.isFunction) continue;
         if (dependency.isErroneous) continue;
         if (dependency.isTypeVariable) continue;
 
         elements.add(dependency);
       }
       treeElements.forEachConstantNode((Node node, _) {
         // Explicitly depend on the backend constants.
-        addConstants(
+        constants.add(
             backend.constants.getConstantForNode(node, treeElements).value);
       });
       elements.addAll(treeElements.otherDependencies);
     }
 
     // TODO(sigurdm): How is metadata on a patch-class handled?
     for (MetadataAnnotation metadata in element.metadata) {
       ConstantExpression constant =
           backend.constants.getConstantForMetadata(metadata);
       if (constant != null) {
-        addConstants(constant.value);
+        constants.add(constant.value);
       }
     }
 
     collectTypeDependencies(DartType type) {
       if (type is FunctionType) {
         for (DartType argumentType in type.parameterTypes) {
           collectTypeDependencies(argumentType);
         }
         for (DartType argumentType in type.optionalParameterTypes) {
           collectTypeDependencies(argumentType);
@@ skipping 80 matching lines @@
       iterateTags(library);
       if (library.isPatched) {
         iterateTags(library.implementation);
       }
     }
     traverseLibrary(root);
     result.add(compiler.coreLibrary);
     return result;
   }
 
-  /// Recursively traverses the graph of dependencies from [element], mapping
-  /// deferred imports to each dependency it needs in the sets
-  /// [_importedDeferredBy] and [_constantsDeferredBy].
-  void _mapDependencies(Element element, Import import,
-                        {isMirrorUsage: false}) {
+  /// Add all dependencies of [constant] to the mapping of [import].
+  void _mapConstantDependencies(ConstantValue constant, Import import) {
+    Set<ConstantValue> constants = _constantsDeferredBy.putIfAbsent(import,
+        () => new Set<ConstantValue>());
+    if (constants.contains(constant)) return;
+    constants.add(constant);
+    if (constant is ConstructedConstantValue) {
+      _mapDependencies(element: constant.type.element, import: import);
+    }
+    constant.getDependencies().forEach((ConstantValue dependency) {
+      _mapConstantDependencies(dependency, import);
+    });
+  }
+
+  /// Recursively traverses the graph of dependencies from one of [element]
+  /// or [constant], mapping deferred imports to each dependency it needs in the
+  /// sets [_importedDeferredBy] and [_constantsDeferredBy].
+  /// Only one of [element] and [constant] should be given.
+  void _mapDependencies({Element element,
+                         Import import,
+                         isMirrorUsage: false}) {
+
     Set<Element> elements = _importedDeferredBy.putIfAbsent(import,
         () => new Set<Element>());
-    Set<ConstantValue> constants = _constantsDeferredBy.putIfAbsent(import,
-        () => new Set<ConstantValue>());
 
-    // Only process elements once, unless we are doing dependencies due to
-    // mirrors, which are added in additional traversals.
-    if (!isMirrorUsage && elements.contains(element)) return;
-    // Anything used directly by main will be loaded from the start
-    // We do not need to traverse it again.
-    if (import != _fakeMainImport && _mainElements.contains(element)) return;
-
-    // Here we modify [_importedDeferredBy].
-    elements.add(element);
 
     Set<Element> dependentElements = new Set<Element>();
+    Set<ConstantValue> dependentConstants = new Set<ConstantValue>();
 
-    // This call can modify [_importedDeferredBy] and [_constantsDeferredBy].
-    _collectAllElementsAndConstantsResolvedFrom(
-        element, dependentElements, constants, isMirrorUsage);
+    LibraryElement library;
 
-    LibraryElement library = element.library;
+    if (element != null) {
+      // Only process elements once, unless we are doing dependencies due to
+      // mirrors, which are added in additional traversals.
+      if (!isMirrorUsage && elements.contains(element)) return;
+      // Anything used directly by main will be loaded from the start
+      // We do not need to traverse it again.
+      if (import != _fakeMainImport && _mainElements.contains(element)) return;
+      elements.add(element);
+
+
+      // This call can modify [dependentElements] and [dependentConstants].
+      _collectAllElementsAndConstantsResolvedFrom(
+          element, dependentElements, dependentConstants, isMirrorUsage);
+
+      library = element.library;
+    }
+
     for (Element dependency in dependentElements) {
       if (_isExplicitlyDeferred(dependency, library)) {
         for (Import deferredImport in _getImports(dependency, library)) {
-          _mapDependencies(dependency, deferredImport);
-        };
+          _mapDependencies(element: dependency, import: deferredImport);
+        }
       } else {
-        _mapDependencies(dependency, import);
+        _mapDependencies(element: dependency, import: import);
+      }
+    }
+
+    for (ConstantValue dependency in dependentConstants) {
+      if (dependency is DeferredConstantValue) {
+        _mapConstantDependencies(dependency,
+                                 dependency.prefix.deferredImport);
+      } else {
+        _mapConstantDependencies(dependency, import);
       }
     }
   }
 
   /// Adds extra dependencies coming from mirror usage.
   ///
   /// The elements are added with [_mapDependencies].
   void _addMirrorElements() {
     void mapDependenciesIfResolved(Element element, Import deferredImport) {
       // If an element is the target of a MirrorsUsed annotation but never used
       // It will not be resolved, and we should not call isNeededForReflection.
       // TODO(sigurdm): Unresolved elements should just answer false when
       // asked isNeededForReflection. Instead an internal error is triggered.
       // So we have to filter them out here.
       if (element is AnalyzableElementX && !element.hasTreeElements) return;
       if (compiler.backend.isAccessibleByReflection(element)) {
-        _mapDependencies(element, deferredImport, isMirrorUsage: true);
+        _mapDependencies(element: element, import: deferredImport,
+                         isMirrorUsage: true);
       }
     }
 
     // For each deferred import we analyze all elements reachable from the
     // imported library through non-deferred imports.
     handleLibrary(LibraryElement library, Import deferredImport) {
       library.implementation.forEachLocalMember((Element element) {
         mapDependenciesIfResolved(element, deferredImport);
       });
 
       for (MetadataAnnotation metadata in library.metadata) {
         ConstantExpression constant =
             backend.constants.getConstantForMetadata(metadata);
         if (constant != null) {
-          _mapDependencies(constant.value.getType(compiler.coreTypes).element,
-              deferredImport);
+          _mapConstantDependencies(constant.value,
+                                   deferredImport);
         }
       }
       for (LibraryTag tag in library.tags) {
         for (MetadataAnnotation metadata in tag.metadata) {
           ConstantExpression constant =
               backend.constants.getConstantForMetadata(metadata);
           if (constant != null) {
-            _mapDependencies(constant.value.getType(compiler.coreTypes).element,
-                deferredImport);
+            _mapConstantDependencies(constant.value,
+                                     deferredImport);
           }
         }
       }
     }
 
     for (Import deferredImport in _allDeferredImports.keys) {
       LibraryElement deferredLibrary = _allDeferredImports[deferredImport];
       for (LibraryElement library in
           _nonDeferredReachableLibraries(deferredLibrary)) {
         handleLibrary(library, deferredImport);
@@ skipping 83 matching lines @@
     }
     if (main == null) return;
     LibraryElement mainLibrary = main.library;
     _importedDeferredBy = new Map<Import, Set<Element>>();
     _constantsDeferredBy = new Map<Import, Set<ConstantValue>>();
     _importedDeferredBy[_fakeMainImport] = _mainElements;
 
     measureElement(mainLibrary, () {
 
       // Starting from main, traverse the program and find all dependencies.
-      _mapDependencies(compiler.mainFunction, _fakeMainImport);
+      _mapDependencies(element: compiler.mainFunction, import: _fakeMainImport);
 
       // Also add "global" dependencies to the main OutputUnit.  These are
       // things that the backend need but cannot associate with a particular
       // element, for example, startRootIsolate.  This set also contains
       // elements for which we lack precise information.
       for (Element element in compiler.globalDependencies.otherDependencies) {
-        _mapDependencies(element, _fakeMainImport);
+        _mapDependencies(element: element, import: _fakeMainImport);
       }
 
       // Now check to see if we have to add more elements due to mirrors.
       if (compiler.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>();
 
       // Reverse the mappings. For each element record an OutputUnit collecting
       // all deferred imports mapped to this element. Same for constants.
       for (Import 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;
           } else {
             elementToOutputUnitBuilder
                 .putIfAbsent(element, () => new OutputUnit())
                 .imports.add(import);
           }
         }
+      }
+      for (Import import in _constantsDeferredBy.keys) {
         for (ConstantValue constant in _constantsDeferredBy[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) {
             constantToOutputUnitBuilder[constant] = mainOutputUnit;
           } else {
             constantToOutputUnitBuilder
                 .putIfAbsent(constant, () => new OutputUnit())
                 .imports.add(import);
           }
@@ skipping 232 matching lines @@
         _importingLibrary = importingLibrary;
 
   String get importingLibraryName {
     String libraryName = _importingLibrary.getLibraryName();
     return libraryName == ""
       ? "<unnamed>"
       : libraryName;
   }
 
 }