Prefix resolution_types with Resolution.

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 260 matching lines @@
   ///
   /// Adds the results to [elements] and [constants].
   void _collectAllElementsAndConstantsResolvedFrom(Element element,
       Set<Element> elements, Set<ConstantValue> constants, isMirrorUsage) {
     if (element.isMalformed) {
       // Malformed elements are ignored.
       return;
     }
 
     /// Recursively collects all the dependencies of [type].
-    void collectTypeDependencies(DartType type) {
+    void collectTypeDependencies(ResolutionDartType type) {
       // TODO(het): we would like to separate out types that are only needed for
       // rti from types that are needed for their members.
       if (type is GenericType) {
         type.typeArguments.forEach(collectTypeDependencies);
       }
-      if (type is FunctionType) {
-        for (DartType argumentType in type.parameterTypes) {
+      if (type is ResolutionFunctionType) {
+        for (ResolutionDartType argumentType in type.parameterTypes) {
           collectTypeDependencies(argumentType);
         }
-        for (DartType argumentType in type.optionalParameterTypes) {
+        for (ResolutionDartType argumentType in type.optionalParameterTypes) {
           collectTypeDependencies(argumentType);
         }
-        for (DartType argumentType in type.namedParameterTypes) {
+        for (ResolutionDartType argumentType in type.namedParameterTypes) {
           collectTypeDependencies(argumentType);
         }
         collectTypeDependencies(type.returnType);
-      } else if (type is TypedefType) {
+      } else if (type is ResolutionTypedefType) {
         elements.add(type.element);
         collectTypeDependencies(type.unaliased);
-      } else if (type is InterfaceType) {
+      } else if (type is ResolutionInterfaceType) {
         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
@@ skipping 19 matching lines @@
             new WorldImpactVisitorImpl(visitStaticUse: (StaticUse staticUse) {
               elements.add(staticUse.element);
               switch (staticUse.kind) {
                 case StaticUseKind.CONSTRUCTOR_INVOKE:
                 case StaticUseKind.CONST_CONSTRUCTOR_INVOKE:
                   collectTypeDependencies(staticUse.type);
                   break;
                 default:
               }
             }, visitTypeUse: (TypeUse typeUse) {
-              DartType type = typeUse.type;
+              ResolutionDartType type = typeUse.type;
               switch (typeUse.kind) {
                 case TypeUseKind.TYPE_LITERAL:
                   if (type.isTypedef || type.isInterfaceType) {
                     elements.add(type.element);
                   }
                   break;
                 case TypeUseKind.INSTANTIATION:
                 case TypeUseKind.MIRROR_INSTANTIATION:
                 case TypeUseKind.NATIVE_INSTANTIATION:
                 case TypeUseKind.IS_CHECK:
@@ skipping 697 matching lines @@
 
   bool operator ==(other) {
     if (other is! _DeclaredDeferredImport) return false;
     return declaration == other.declaration;
   }
 
   int get hashCode => declaration.hashCode * 17;
 
   String toString() => '$declaration';
 }