Prefix resolution_types with Resolution.

pkg/compiler/lib/src/native/enqueue.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.
 
 import 'dart:collection' show Queue;
 
 import '../common.dart';
 import '../common/backend_api.dart' show ForeignResolver;
 import '../common/resolution.dart' show Resolution;
 import '../compiler.dart' show Compiler;
@@ skipping 11 matching lines @@
 import '../universe/use.dart' show StaticUse, TypeUse;
 import '../universe/world_impact.dart'
     show WorldImpact, WorldImpactBuilder, WorldImpactBuilderImpl;
 import 'behavior.dart';
 
 /**
  * This could be an abstract class but we use it as a stub for the dart_backend.
  */
 class NativeEnqueuer {
   /// Called when a [type] has been instantiated natively.
-  void onInstantiatedType(InterfaceType type) {}
+  void onInstantiatedType(ResolutionInterfaceType type) {}
 
   /// Initial entry point to native enqueuer.
   WorldImpact processNativeClasses(Iterable<LibraryElement> libraries) =>
       const WorldImpact();
 
   /// Registers the [nativeBehavior]. Adds the liveness of its instantiated
   /// types to the world.
   void registerNativeBehavior(
       WorldImpactBuilder impactBuilder, NativeBehavior nativeBehavior, cause) {}
 
@@ skipping 49 matching lines @@
       : this.compiler = compiler,
         processedLibraries = compiler.cacheStrategy.newSet();
 
   JavaScriptBackend get backend => compiler.backend;
   BackendHelpers get helpers => backend.helpers;
   Resolution get resolution => compiler.resolution;
 
   DiagnosticReporter get reporter => compiler.reporter;
   CommonElements get commonElements => compiler.commonElements;
 
-  void onInstantiatedType(InterfaceType type) {
+  void onInstantiatedType(ResolutionInterfaceType type) {
     if (_unusedClasses.remove(type.element)) {
       _registeredClasses.add(type.element);
     }
   }
 
   WorldImpact processNativeClasses(Iterable<LibraryElement> libraries) {
     WorldImpactBuilderImpl impactBuilder = new WorldImpactBuilderImpl();
     _processNativeClasses(impactBuilder, libraries);
     return impactBuilder;
   }
@@ skipping 302 matching lines @@
     });
   }
 
   void registerNativeBehavior(
       WorldImpactBuilder impactBuilder, NativeBehavior nativeBehavior, cause) {
     _processNativeBehavior(impactBuilder, nativeBehavior, cause);
   }
 
   void _processNativeBehavior(
       WorldImpactBuilder impactBuilder, NativeBehavior behavior, cause) {
-    void registerInstantiation(InterfaceType type) {
+    void registerInstantiation(ResolutionInterfaceType type) {
       impactBuilder.registerTypeUse(new TypeUse.nativeInstantiation(type));
     }
 
     int unusedBefore = _unusedClasses.length;
     Set<ClassElement> matchingClasses = new Set<ClassElement>();
     for (var type in behavior.typesInstantiated) {
       if (type is SpecialType) {
         if (type == SpecialType.JsObject) {
           registerInstantiation(compiler.commonElements.objectType);
         }
         continue;
       }
-      if (type is InterfaceType) {
+      if (type is ResolutionInterfaceType) {
         if (type == commonElements.intType) {
           registerInstantiation(type);
         } else if (type == commonElements.doubleType) {
           registerInstantiation(type);
         } else if (type == commonElements.numType) {
           registerInstantiation(commonElements.doubleType);
           registerInstantiation(commonElements.intType);
         } else if (type == commonElements.stringType) {
           registerInstantiation(type);
         } else if (type == commonElements.nullType) {
           registerInstantiation(type);
         } else if (type == commonElements.boolType) {
           registerInstantiation(type);
         } else if (compiler.types.isSubtype(
             type, backend.backendClasses.listImplementation.rawType)) {
           registerInstantiation(type);
         }
         // TODO(johnniwinther): Improve spec string precision to handle type
         // arguments and implements relations that preserve generics. Currently
         // we cannot distinguish between `List`, `List<dynamic>`, and
         // `List<int>` and take all to mean `List<E>`; in effect not including
         // any native subclasses of generic classes.
         // TODO(johnniwinther,sra): Find and replace uses of `List` with the
         // actual implementation classes such as `JSArray` et al.
         matchingClasses
             .addAll(_findUnusedClassesMatching((ClassElement nativeClass) {
-          InterfaceType nativeType = nativeClass.thisType;
-          InterfaceType specType = type.element.thisType;
+          ResolutionInterfaceType nativeType = nativeClass.thisType;
+          ResolutionInterfaceType specType = type.element.thisType;
           return compiler.types.isSubtype(nativeType, specType);
         }));
       } else if (type.isDynamic) {
         matchingClasses.addAll(_unusedClasses);
       } else {
-        assert(type is VoidType);
+        assert(type is ResolutionVoidType);
       }
     }
     if (matchingClasses.isNotEmpty && _registeredClasses.isEmpty) {
       matchingClasses.addAll(_onFirstNativeClass(impactBuilder));
     }
     _registerTypeUses(impactBuilder, matchingClasses, cause);
 
     // Give an info so that library developers can compile with -v to find why
     // all the native classes are included.
     if (unusedBefore > 0 && unusedBefore == matchingClasses.length) {
@@ skipping 145 matching lines @@
 
   void _addSubtypes(ClassElement cls, NativeEmitter emitter) {
     if (!backend.isNative(cls)) return;
     if (doneAddSubtypes.contains(cls)) return;
     doneAddSubtypes.add(cls);
 
     // Walk the superclass chain since classes on the superclass chain might not
     // be instantiated (abstract or simply unused).
     _addSubtypes(cls.superclass, emitter);
 
-    for (DartType type in cls.allSupertypes) {
+    for (ResolutionDartType type in cls.allSupertypes) {
       List<Element> subtypes =
           emitter.subtypes.putIfAbsent(type.element, () => <ClassElement>[]);
       subtypes.add(cls);
     }
 
     // Skip through all the mixin applications in the super class
     // chain. That way, the direct subtypes set only contain the
     // natives classes.
     ClassElement superclass = cls.superclass;
     while (superclass != null && superclass.isMixinApplication) {
       assert(!backend.isNative(superclass));
       superclass = superclass.superclass;
     }
 
     List<Element> directSubtypes =
         emitter.directSubtypes.putIfAbsent(superclass, () => <ClassElement>[]);
     directSubtypes.add(cls);
   }
 
   void logSummary(log(message)) {
     log('Compiled ${_registeredClasses.length} native classes, '
         '${_unusedClasses.length} native classes omitted.');
   }
 }