Deferred loading track type-dependencies for is, as and type-annotations.

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/values.dart' show
     ConstantValue,
     ConstructedConstantValue,
     DeferredConstantValue,
@@ skipping 234 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 collects all the dependencies of [type].
+    void collectTypeDependencies(DartType type) {
+      if (type is GenericType) {
+        type.typeArguments.forEach(collectTypeDependencies);
+      }
+      if (type is FunctionType) {
+        for (DartType argumentType in type.parameterTypes) {
+          collectTypeDependencies(argumentType);
+        }
+        for (DartType argumentType in type.optionalParameterTypes) {
+          collectTypeDependencies(argumentType);
+        }
+        for (DartType argumentType in type.namedParameterTypes) {
+          collectTypeDependencies(argumentType);
+        }
+        collectTypeDependencies(type.returnType);
+      } else if (type is TypedefType) {
+        elements.add(type.element);
+        collectTypeDependencies(type.unalias(compiler));
+      } else if (type is InterfaceType) {
+        elements.add(type.element);
+      }
+    }
+
     /// 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;
 
       // TODO(sigurdm): We want to be more specific about this - need a better
       // way to query "liveness".
       if (astElement is! TypedefElement &&
           !compiler.enqueuer.resolution.hasBeenResolved(astElement)) {
         return;
       }
 
       TreeElements treeElements = astElement.resolvedAst.elements;
 
       assert(treeElements != null);
 
       for (Element dependency in treeElements.allElements) {
         if (dependency.isLocal && !dependency.isFunction) continue;
         if (dependency.isErroneous) continue;
         if (dependency.isTypeVariable) continue;
 
         elements.add(dependency);
       }
 
-      void registerTypeArgumentsAsDependencies(DartType type) {
-        Element dependency = type.element;
-        if (dependency == null || dependency.isErroneous ||
-            dependency.isTypeVariable) {
-          return;
-        }
-        elements.add(dependency);
-        if (type is GenericType) {
-          type.typeArguments.forEach(registerTypeArgumentsAsDependencies);
-        }
+      for (DartType type in treeElements.requiredTypes) {
+        collectTypeDependencies(type);
       }
 
-      treeElements.forEachType((Node node, DartType type) {
-        if (node is NewExpression) registerTypeArgumentsAsDependencies(type);
-      });
-
       treeElements.forEachConstantNode((Node node, _) {
         // Explicitly depend on the backend constants.
         ConstantValue value =
             backend.constants.getConstantValueForNode(node, treeElements);
         if (value != null) {
           // TODO(johnniwinther): Assert that all constants have values when
           // these are directly evaluated.
           constants.add(value);
         }
       });
       elements.addAll(treeElements.otherDependencies);
     }
 
     // TODO(sigurdm): How is metadata on a patch-class handled?
     for (MetadataAnnotation metadata in element.metadata) {
       ConstantValue constant =
           backend.constants.getConstantValueForMetadata(metadata);
       if (constant != null) {
         constants.add(constant);
       }
     }
 
-    collectTypeDependencies(DartType type) {
-      if (type is FunctionType) {
-        for (DartType argumentType in type.parameterTypes) {
-          collectTypeDependencies(argumentType);
-        }
-        for (DartType argumentType in type.optionalParameterTypes) {
-          collectTypeDependencies(argumentType);
-        }
-        for (DartType argumentType in type.namedParameterTypes) {
-          collectTypeDependencies(argumentType);
-        }
-        collectTypeDependencies(type.returnType);
-      } else if (type is TypedefType) {
-        elements.add(type.element);
-        collectTypeDependencies(type.unalias(compiler));
-      } else if (type is InterfaceType) {
-        elements.add(type.element);
-      }
-    }
-
     if (element is FunctionElement &&
         compiler.resolverWorld.closurizedMembers.contains(element)) {
       collectTypeDependencies(element.type);
     }
 
-    // TODO(sigurdm): Also collect types that are used in is checks and for
-    // checked mode.
-
     if (element.isClass) {
       // If we see a class, add everything its live instance members refer
       // to.  Static members are not relevant, unless we are processing
       // extra dependencies due to mirrors.
       void addLiveInstanceMember(Element element) {
         if (!compiler.enqueuer.resolution.hasBeenResolved(element)) return;
         if (!isMirrorUsage && !element.isInstanceMember) return;
         collectDependencies(element.implementation);
       }
       ClassElement cls = element.declaration;
@@ skipping 541 matching lines @@
         _importingLibrary = importingLibrary;
 
   String get importingLibraryName {
     String libraryName = _importingLibrary.getLibraryName();
     return libraryName == ""
       ? "<unnamed>"
       : libraryName;
   }
 
 }