Prefix resolution_types with Resolution.

pkg/compiler/lib/src/mirrors_used.dart

 // Copyright (c) 2013, 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 dart2js.mirrors_used;
 
 import 'common/tasks.dart' show CompilerTask;
 import 'common.dart';
 import 'compile_time_constants.dart' show ConstantCompiler;
 import 'compiler.dart' show Compiler;
 import 'constants/expressions.dart';
 import 'constants/values.dart'
     show
         ConstantValue,
         ConstructedConstantValue,
         ListConstantValue,
         StringConstantValue,
         TypeConstantValue;
-import 'elements/resolution_types.dart' show DartType, InterfaceType;
+import 'elements/resolution_types.dart'
+    show ResolutionDartType, ResolutionInterfaceType;
 import 'elements/elements.dart'
     show
         ClassElement,
         Element,
         FieldElement,
         ImportElement,
         LibraryElement,
         MetadataAnnotation,
         ScopeContainerElement;
 import 'resolution/tree_elements.dart' show TreeElements;
@@ skipping 377 matching lines @@
       MessageKind kind = onlyStrings
           ? MessageKind.MIRRORS_EXPECTED_STRING_OR_LIST
           : MessageKind.MIRRORS_EXPECTED_STRING_TYPE_OR_LIST;
       reporter.reportHintMessage(
           node, kind, {'name': node, 'type': apiTypeOf(constant)});
       return null;
     }
   }
 
   /// Find the first non-implementation interface of constant.
-  DartType apiTypeOf(ConstantValue constant) {
-    DartType type = constant.getType(compiler.commonElements);
+  ResolutionDartType apiTypeOf(ConstantValue constant) {
+    ResolutionDartType type = constant.getType(compiler.commonElements);
     LibraryElement library = type.element.library;
     if (type.isInterfaceType && library.isInternalLibrary) {
-      InterfaceType interface = type;
+      ResolutionInterfaceType interface = type;
       ClassElement cls = type.element;
       cls.ensureResolved(compiler.resolution);
-      for (DartType supertype in cls.allSupertypes) {
+      for (ResolutionDartType supertype in cls.allSupertypes) {
         if (supertype.isInterfaceType &&
             !supertype.element.library.isInternalLibrary) {
           return interface.asInstanceOf(supertype.element);
         }
       }
     }
     return type;
   }
 
   /// Convert a list of strings and types to a list of elements. Types are
   /// converted to their corresponding element, and strings are resolved as
   /// follows:
   ///
   /// First find the longest library name that is a prefix of the string, if
   /// there are none, resolve using [resolveExpression]. Otherwise, resolve the
   /// rest of the string using [resolveLocalExpression].
   List<Element> resolveUsageList(List list) {
     if (list == null) return null;
     if (list.length == 1 && list[0] == '*') {
       return analyzer.wildcard;
     }
     List<Element> result = <Element>[];
     for (var entry in list) {
-      if (entry is DartType) {
-        DartType type = entry;
+      if (entry is ResolutionDartType) {
+        ResolutionDartType type = entry;
         result.add(type.element);
       } else {
         String string = entry;
         LibraryElement libraryCandiate;
         String libraryNameCandiate;
         for (LibraryElement l in compiler.libraryLoader.libraries) {
           if (l.hasLibraryName) {
             String libraryName = l.libraryOrScriptName;
             if (string == libraryName) {
               // Found an exact match.
@@ skipping 104 matching lines @@
       // @MirrorsUsed(targets: fisk)
       //                       ^^^^
       //
       // Instead of saying 'fisk' should pretty print the problematic constant
       // value.
       return spannable;
     }
     return node;
   }
 }