Prefix resolution_types with Resolution.

pkg/compiler/lib/src/compiler.dart

 // Copyright (c) 2012, 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.compiler_base;
 
 import 'dart:async' show EventSink, Future;
 
 import '../compiler_new.dart' as api;
 import 'cache_strategy.dart' show CacheStrategy;
 import 'closure.dart' as closureMapping show ClosureTask;
 import 'common/backend_api.dart' show Backend;
 import 'common/names.dart' show Selectors;
 import 'common/names.dart' show Identifiers, Uris;
 import 'common/resolution.dart'
     show
         ParsingContext,
         Resolution,
         ResolutionWorkItem,
         ResolutionImpact,
         Target;
 import 'common/tasks.dart' show CompilerTask, GenericTask, Measurer;
 import 'common/work.dart' show WorkItem;
 import 'common.dart';
 import 'compile_time_constants.dart';
 import 'constants/values.dart';
 import 'core_types.dart' show CommonElements;
 import 'elements/resolution_types.dart'
-    show DartType, DynamicType, InterfaceType, Types;
+    show
+        ResolutionDartType,
+        ResolutionDynamicType,
+        ResolutionInterfaceType,
+        Types;
 import 'deferred_load.dart' show DeferredLoadTask;
 import 'diagnostics/code_location.dart';
 import 'diagnostics/diagnostic_listener.dart' show DiagnosticReporter;
 import 'diagnostics/invariant.dart' show REPORT_EXCESS_RESOLUTION;
 import 'diagnostics/messages.dart' show Message, MessageTemplate;
 import 'dump_info.dart' show DumpInfoTask;
 import 'elements/elements.dart';
 import 'elements/modelx.dart' show ErroneousElementX;
 import 'enqueue.dart' show Enqueuer, EnqueueTask, ResolutionEnqueuer;
 import 'environment.dart';
@@ skipping 1262 matching lines @@
 
   ClassElement _patchAnnotationClass;
   ClassElement get patchAnnotationClass =>
       _patchAnnotationClass ??= _findRequired(jsHelperLibrary, '_Patch');
 
   ClassElement _nativeAnnotationClass;
   ClassElement get nativeAnnotationClass =>
       _nativeAnnotationClass ??= _findRequired(jsHelperLibrary, 'Native');
 
   @override
-  InterfaceType get objectType {
+  ResolutionInterfaceType get objectType {
     objectClass.ensureResolved(resolution);
     return objectClass.rawType;
   }
 
   @override
-  InterfaceType get boolType {
+  ResolutionInterfaceType get boolType {
     boolClass.ensureResolved(resolution);
     return boolClass.rawType;
   }
 
   @override
-  InterfaceType get doubleType {
+  ResolutionInterfaceType get doubleType {
     doubleClass.ensureResolved(resolution);
     return doubleClass.rawType;
   }
 
   @override
-  InterfaceType get functionType {
+  ResolutionInterfaceType get functionType {
     functionClass.ensureResolved(resolution);
     return functionClass.rawType;
   }
 
   @override
-  InterfaceType get intType {
+  ResolutionInterfaceType get intType {
     intClass.ensureResolved(resolution);
     return intClass.rawType;
   }
 
   @override
-  InterfaceType get resourceType {
+  ResolutionInterfaceType get resourceType {
     resourceClass.ensureResolved(resolution);
     return resourceClass.rawType;
   }
 
   @override
-  InterfaceType listType([DartType elementType]) {
+  ResolutionInterfaceType listType([ResolutionDartType elementType]) {
     listClass.ensureResolved(resolution);
-    InterfaceType type = listClass.rawType;
+    ResolutionInterfaceType type = listClass.rawType;
     if (elementType == null) {
       return type;
     }
     return type.createInstantiation([elementType]);
   }
 
   @override
-  InterfaceType mapType([DartType keyType, DartType valueType]) {
+  ResolutionInterfaceType mapType(
+      [ResolutionDartType keyType, ResolutionDartType valueType]) {
     mapClass.ensureResolved(resolution);
-    InterfaceType type = mapClass.rawType;
+    ResolutionInterfaceType type = mapClass.rawType;
     if (keyType == null && valueType == null) {
       return type;
     } else if (keyType == null) {
-      keyType = const DynamicType();
+      keyType = const ResolutionDynamicType();
     } else if (valueType == null) {
-      valueType = const DynamicType();
+      valueType = const ResolutionDynamicType();
     }
     return type.createInstantiation([keyType, valueType]);
   }
 
   @override
-  InterfaceType get nullType {
+  ResolutionInterfaceType get nullType {
     nullClass.ensureResolved(resolution);
     return nullClass.rawType;
   }
 
   @override
-  InterfaceType get numType {
+  ResolutionInterfaceType get numType {
     numClass.ensureResolved(resolution);
     return numClass.rawType;
   }
 
   @override
-  InterfaceType get stringType {
+  ResolutionInterfaceType get stringType {
     stringClass.ensureResolved(resolution);
     return stringClass.rawType;
   }
 
   @override
-  InterfaceType get symbolType {
+  ResolutionInterfaceType get symbolType {
     symbolClass.ensureResolved(resolution);
     return symbolClass.rawType;
   }
 
   @override
-  InterfaceType get typeType {
+  ResolutionInterfaceType get typeType {
     typeClass.ensureResolved(resolution);
     return typeClass.rawType;
   }
 
   @override
-  InterfaceType get stackTraceType {
+  ResolutionInterfaceType get stackTraceType {
     stackTraceClass.ensureResolved(resolution);
     return stackTraceClass.rawType;
   }
 
   @override
-  InterfaceType iterableType([DartType elementType]) {
+  ResolutionInterfaceType iterableType([ResolutionDartType elementType]) {
     iterableClass.ensureResolved(resolution);
-    InterfaceType type = iterableClass.rawType;
+    ResolutionInterfaceType type = iterableClass.rawType;
     if (elementType == null) {
       return type;
     }
     return type.createInstantiation([elementType]);
   }
 
   @override
-  InterfaceType futureType([DartType elementType]) {
+  ResolutionInterfaceType futureType([ResolutionDartType elementType]) {
     futureClass.ensureResolved(resolution);
-    InterfaceType type = futureClass.rawType;
+    ResolutionInterfaceType type = futureClass.rawType;
     if (elementType == null) {
       return type;
     }
     return type.createInstantiation([elementType]);
   }
 
   @override
-  InterfaceType streamType([DartType elementType]) {
+  ResolutionInterfaceType streamType([ResolutionDartType elementType]) {
     streamClass.ensureResolved(resolution);
-    InterfaceType type = streamClass.rawType;
+    ResolutionInterfaceType type = streamClass.rawType;
     if (elementType == null) {
       return type;
     }
     return type.createInstantiation([elementType]);
   }
 
   void onLibraryCreated(LibraryElement library) {
     Uri uri = library.canonicalUri;
     if (uri == Uris.dart_core) {
       coreLibrary = library;
@@ skipping 535 matching lines @@
   void resolveMetadataAnnotation(MetadataAnnotation metadataAnnotation) {
     _compiler.resolver.resolveMetadataAnnotation(metadataAnnotation);
   }
 
   @override
   FunctionSignature resolveSignature(FunctionElement function) {
     return _compiler.resolver.resolveSignature(function);
   }
 
   @override
-  DartType resolveTypeAnnotation(Element element, TypeAnnotation node) {
+  ResolutionDartType resolveTypeAnnotation(
+      Element element, TypeAnnotation node) {
     return _compiler.resolver.resolveTypeAnnotation(element, node);
   }
 
   @override
   void ensureResolved(Element element) {
     if (_compiler.serialization.isDeserialized(element)) {
       return;
     }
     computeWorldImpact(element);
   }
@@ skipping 227 matching lines @@
   _ElementScanner(this.scanner);
   void scanLibrary(LibraryElement library) => scanner.scanLibrary(library);
   void scanUnit(CompilationUnitElement unit) => scanner.scan(unit);
 }
 
 class _EmptyEnvironment implements Environment {
   const _EmptyEnvironment();
 
   String valueOf(String key) => null;
 }