Prefix resolution_types with Resolution.

pkg/compiler/lib/src/common/backend_api.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.backend_api;
 
 import 'dart:async' show Future;
 
 import '../common.dart';
 import '../common/codegen.dart' show CodegenImpact;
 import '../common/resolution.dart' show ResolutionImpact, Frontend, Target;
 import '../compile_time_constants.dart'
     show BackendConstantEnvironment, ConstantCompilerTask;
 import '../compiler.dart' show Compiler;
 import '../constants/constant_system.dart' show ConstantSystem;
 import '../constants/expressions.dart' show ConstantExpression;
 import '../constants/values.dart' show ConstantValue;
-import '../elements/resolution_types.dart' show DartType, InterfaceType;
+import '../elements/resolution_types.dart'
+    show ResolutionDartType, ResolutionInterfaceType;
 import '../elements/elements.dart'
     show
         ClassElement,
         Element,
         FunctionElement,
         MemberElement,
         MethodElement,
         LibraryElement;
 import '../elements/entities.dart';
 import '../enqueue.dart' show Enqueuer, EnqueueTask, ResolutionEnqueuer;
@@ skipping 114 matching lines @@
 
   /// Called to notify to the backend that a class is implemented by an
   /// instantiated class. Any backend specific [WorldImpact] of this is
   /// returned.
   WorldImpact registerImplementedClass(ClassElement cls,
           {bool forResolution}) =>
       const WorldImpact();
 
   /// Called to instruct to the backend register [type] as instantiated on
   /// [enqueuer].
-  void registerInstantiatedType(InterfaceType type) {}
+  void registerInstantiatedType(ResolutionInterfaceType type) {}
 
   /// Register a runtime type variable bound tests between [typeArgument] and
   /// [bound].
   void registerTypeVariableBoundsSubtypeCheck(
-      DartType typeArgument, DartType bound) {}
+      ResolutionDartType typeArgument, ResolutionDartType bound) {}
 
   /// Called to instruct the backend to register that a closure exists for a
   /// function on an instantiated generic class. Any backend specific
   /// [WorldImpact] of this is returned.
   WorldImpact registerClosureWithFreeTypeVariables(Element closure,
           {bool forResolution}) =>
       const WorldImpact();
 
   /// Called to register that a member has been closurized. Any backend specific
   /// [WorldImpact] of this is returned.
@@ skipping 183 matching lines @@
   void registerNativeData(dynamic nativeData);
 }
 
 /// Interface for resolving calls to foreign functions.
 abstract class ForeignResolver {
   /// Returns the constant expression of [node], or `null` if [node] is not
   /// a constant expression.
   ConstantExpression getConstant(Node node);
 
   /// Registers [type] as instantiated.
-  void registerInstantiatedType(InterfaceType type);
+  void registerInstantiatedType(ResolutionInterfaceType type);
 
   /// Resolves [typeName] to a type in the context of [node].
-  DartType resolveTypeFromString(Node node, String typeName);
+  ResolutionDartType resolveTypeFromString(Node node, String typeName);
 }
 
 /// Backend transformation methods for the world impacts.
 class ImpactTransformer {
   /// Transform the [ResolutionImpact] into a [WorldImpact] adding the
   /// backend dependencies for features used in [worldImpact].
   WorldImpact transformResolutionImpact(
       ResolutionEnqueuer enqueuer, ResolutionImpact worldImpact) {
     return worldImpact;
   }
@@ skipping 39 matching lines @@
   ClassElement get indexableImplementation;
   ClassElement get mutableIndexableImplementation;
   ClassElement get indexingBehaviorImplementation;
   ClassElement get interceptorImplementation;
 
   bool isDefaultEqualityImplementation(Element element);
   bool isInterceptorClass(ClassElement cls);
   bool isNativeClass(ClassElement element);
   bool isNativeMember(MemberElement element);
 }